Rebuild Claude Duet

export const DEFAULT_PREFERENCES: Preferences = {
  briefAt: "07:30",
  checkInHours: [10, 13, 16, 19],
  hearAbout: ["payments due or failed", "documents to sign", "clients waiting on a reply", "calendar clashes"],
};

export function partnerFor(person: Person, preferences: Preferences = DEFAULT_PREFERENCES) {
  return {
    id: person.id,
    workspaceId: person.id,
    name: "Partner",
    description: `${person.name}'s partner: looks after their inbox, calendar and errands.`,
    context: { name: person.name, timezone: person.timezone, preferences },
  };
}

export const threadFor = (person: Pick<Person, "id">) => ({
  id: `${person.id}-thread`, workspaceId: person.id, title: "Partner",
  context: { conversationKey: "thread" },   // new mail joins it through this key
});

const ada = defineAgentInstance(partner, {
  ...partnerFor(DEMO_PERSON),
  installations: [installationFor(adaGmail), installationFor(adaCalendar)],
});

export const data = new FileFoundryDataAdapter({
  file: dataPath("foundry.json"),
  agents: [ada],   // its computer is created on the first long job
  conversations: [createConversation(ada, threadFor(DEMO_PERSON))],
});

export default defineApplication({
  name: "Proactive partner",
  data,
  services,                                  // your accounts; routes and bindings in a file
  routes: [gmailRoutes(adaGmail.id).in, gmailRoutes(adaGmail.id).out],
  bindings: [sendBinding(ada.id, adaGmail.id)],
});

export default defineAgent({
  description: "Looks after one person's inbox, calendar and errands, and reaches out before they ask",
  components: composeAgent(gmailApp, calendarApp, personal),   // each app installed with the person's account

  model: (_agent, context) => (isCall(context) ? callModel() : partnerModel(context.agentInstance.workspaceId)),
  systemPrompt: (_agent, context) => partnerPrompt(context, isCall(context)),
  store: ({ conversationId }) => FileStore.open(conversationId),
  memory: [personal],

  tools: () => [...actionTools(), notifyTool],                  // pay, sign, delete; notify_person
  schedules: (_agent, { agentInstance }) => partnerSchedules(agentInstance.context),
  playbooks: (_agent, { installations }) => {                   // new mail, as it arrives
    const mail = installations.find((item) => item.kind === "application" && item.id === gmailApp.id);
    return mail?.accountId ? [newMailFor(mail.accountId)] : [];
  },
  repl: () => defineRepl({                                      // the apps' reads, as functions
    language: "javascript",
    session: JsSession.create(),
    mount: { discovery: "auto" },
    programmaticTools: { select: ({ apps }) => apps.flatMap((app) => app.tools.filter((tool) => tool.readOnly)), keepDirect: false },
  }),
  configure: async (agent, ctx) => {
    useReadSkill(agent, await loadSkills());
    guardSends(agent, ctx);                                     // Gmail's send, behind the guard
  },

  durableSubagents: {                                         // long jobs go to its own computer
    computer: { agent: computer, description: "Builds pages and dashboards and researches across sites." },
  },
  accountSessions,

  run: (agent, context) => (isCall(context) ? call(agent, context) : context.defaultRun()),
});

export function partnerSchedules(context: Readonly<Record<string, unknown>>) {
  const timezone = String(context.timezone ?? "UTC");
  const preferences = (context.preferences ?? DEFAULT_PREFERENCES) as Preferences;
  const [hour = "7", minute = "30"] = preferences.briefAt.split(":");
  return [
    defineSchedule({
      name: "morning-brief",
      timing: { kind: "cron", expression: `${Number(minute)} ${Number(hour)} * * *`, timezone },
      message: "Morning brief. Read the inbox and today's calendar, then send one short brief with notify_person: what needs them today, in order, and any clash you can fix. …",   // one program over gmail.* and calendar.*
    }),
    defineSchedule({
      name: "check-in",
      timing: { kind: "cron", expression: `0 ${preferences.checkInHours.join(",")} * * *`, timezone },
      message: "Check-in. Read the inbox. If something they want to hear about needs them before the next check-in, notify_person once … Otherwise do not notify, and reply exactly: (nothing new)",
    }),
  ];
}

export const notifyTool: GloveFoldArgs<any> = {
  name: "notify_person",
  description: "Send the person a push notification. Use it only when something needs them.",
  inputSchema: z.object({ title: z.string().max(80), body: z.string().max(600) }),
  async do(note) {
    // It goes to the person themselves, so only the strict tier applies.
    if (strictlyBlocked(`${note.title}\n${note.body}`)) {
      return { status: "error", data: null, message: "Blocked: card and ID numbers never go to a phone." };
    }
    if (process.env.PUSH_URL) {
      await fetch(process.env.PUSH_URL, { method: "POST", headers: { title: note.title }, body: note.body });
    }
    await record({ kind: "notification", ...note });
    return { status: "success", data: { notified: true } };
  },
};

export function guardSends(agent: IGloveRunnable, ctx: Pick<AgentAssemblyContext, "request" | "messageText">) {
  aroundTool(agent, installedApplicationTransmissionToolName(gmailApp, gmail), (send) => ({
    name: send.name,
    description: `${send.description} Never include card or government ID numbers.`,
    jsonSchema: send.jsonSchema,
    requiresPermission: (input) => !strictlyBlocked(textOf(input)),
    async do(input, _display, _glove, signal) {
      // The person's own words, when they started this run, tell the guard what they asked for.
      const reason = await blockedBecause(textOf(input), ctx.request.source?.kind === "direct" ? ctx.messageText : undefined);
      if (reason) return { status: "error", data: null, message: `Blocked: ${reason}. Tell the person you will not send it, and why.` };
      return send.run(input, signal);
    },
  }));
}

export function strictlyBlocked(text: string): boolean {
  return Boolean(cardNumberIn(text) || governmentIdIn(text));
}

export async function blockedBecause(text: string, request?: string): Promise<string | undefined> {
  if (cardNumberIn(text)) return "it contains a payment card number";
  if (governmentIdIn(text)) return "it contains a government ID number";
  if (!classifier) return undefined;
  const { answers } = await classifier.classify({
    state: { message: text, request: request ?? "" },
    questions: {
      sensitive: noul("Does the message share someone's health details or personal finances?"),
      asked: noul("Did the request explicitly ask to share those details in this message?"),
    },
  });
  return answers.sensitive.noul > 0.8 && answers.asked.noul < 0.5
    ? "it shares health or money details they did not ask to share"
    : undefined;
}

export const call = voiceCall({
  room: (context) => {
    const { call: room } = callRequest.parse(context.request.payload);
    return webSocketRoom({ port: room.port, token: room.token, agentName: "Partner" });
  },
  greeting: "The person just called. Greet them by name in one short sentence and ask what they need.",
});

pnpm --filter glove-foundry-proactive-partner verify

1. on Ada's clock: morning brief 07:30, check-ins 10:00, 13:00, 16:00, 19:00 (America/New_York); her Gmail watch is connected
2. pushed: "Morning brief", from her inbox and calendar read in code
3. check-in: (nothing new), no notification
4. new mail, pushed: "Payment failed: INV-88"
5. waiting for approval: pay_invoice
   in Ada's thread: Paid INV-88: $240 to Acme Hosting.
6. in Ada's thread: Told Leo 1:30 works.
7. in Ada's thread: I won't send card numbers, even to Sam. I can send him the hotel's booking link instead.
8. in Ada's thread: Done: Built dashboard.html: October invoices by vendor, $3,410 total, one overdue (INV-88). …
9. in Ada's thread: I can't move money between accounts, even with your approval. That one is yours to do in your bank's app.
10. brief moved to 08:15 (15 8 * * *)

kuiper login
kuiper projects create partner && kuiper use partner
kuiper units create partner

kuiper providers add anthropic --key -            # once per organisation
kuiper secrets set GOOGLE_CLIENT_SECRET=- GOOGLE_SERVICE_ACCOUNT_JSON=- PUSH_URL=- FOUNDRY_TOKEN=-
kuiper env set -u partner PARTNER_DATA_DIR=/data \
  'FOUNDRY_TOKEN=${{secrets.FOUNDRY_TOKEN}}' \
  'ANTHROPIC_API_KEY=${{models.API_KEY}}' \
  'ANTHROPIC_BASE_URL=${{models.ANTHROPIC_BASE_URL}}' \
  'PUSH_URL=${{secrets.PUSH_URL}}' \
  GOOGLE_CLIENT_ID=… 'GOOGLE_CLIENT_SECRET=${{secrets.GOOGLE_CLIENT_SECRET}}' \
  GMAIL_PUBSUB_TOPIC=… GMAIL_PUBSUB_SUBSCRIPTION=… \
  'GOOGLE_SERVICE_ACCOUNT_JSON=${{secrets.GOOGLE_SERVICE_ACCOUNT_JSON}}'

kuiper deploy --source . -u partner --wait
kuiper dashboard -u partner --enable              # inspector login