Rebuild OpenAI Dots

export const SAM = {
  id: "sam",
  dot: {
    name: "Pip",
    owner: "Sam",
    responsibilities: [
      {
        job: "Track product feedback from #feedback and the support inbox, and group the reports.",
        sources: ["#feedback", "support inbox"],
        attention: "A problem several people report, or anything that blocks a customer.",
        mustNot: "Reply to anyone without Sam's approval.",
      },
      {
        job: "Make sure every customer who wrote to support hears back within a day.",
        sources: ["support inbox"],
        attention: "Anyone who has waited more than a day.",
        mustNot: "Promise a ship date.",
      },
    ],
    rules: { send_email: "ask", open_draft_pr: "allow", merge_pr: "block" },
    routing: { progress: "app", decisions: "slack" },
    slackUserId: "U0SAM",
  },
};

export const samsDot = defineAgentInstance(dot, primaryDot(SAM.id, SAM.dot, [installationFor(samsGmail)]));

export const data = new FileFoundryDataAdapter({
  file: dataPath("foundry.json"),
  agents: [samsDot],
  conversations: [createConversation(samsDot, { id: `${samsDot.id}-app`, title: "App", context: { conversationKey: "app" } })],
});

export default defineAgent({
  description: "An always-on agent that works on its person's responsibilities and acts within their rules",
  components: composeAgent(gmailApp, slackApp, person),

  model: (_agent, ctx) => (isCall(ctx) ? callModel() : dotModel(ctx.agentInstance.workspaceId)),
  systemPrompt: async (_agent, ctx) => dotPrompt(await currentDot(ctx), ctx, isCall(ctx)),
  store: ({ conversationId }) => FileStore.open(conversationId),
  memory: [person],

  tools: (_agent, ctx) => dotTools(ctx),
  schedules: [research],
  playbooks: (_agent, ctx) => dotPlaybooks(ctx),      // the owner's Slack messages; new mail

  // The mailbox's reads as functions: research reads it in code.
  repl: () => defineRepl({
    language: "javascript",
    session: JsSession.create(),
    mount: { discovery: "auto" },
    programmaticTools: { select: ({ apps }) => apps.flatMap((app) => app.tools.filter((tool) => tool.readOnly)), keepDirect: false },
  }),
  // Gmail's send under auto-review, and follow-ups; gone on read-only runs.
  configure: (agent, ctx) => configureDot(agent, ctx),

  // Its own computer, but not on read-only runs.
  workingEnvironment: async (_agent, ctx) => (readOnly(ctx.request, await currentDot(ctx)) ? undefined : dotComputer),

  // Coding jobs go to the dot's own builder, a durable subagent Foundry
  // creates on the first task. Read-only runs lose its tools in configureDot.
  durableSubagents: {
    builder: { agent: builder, description: "Coding and heavy build jobs on its own computer." },
  },

  // The Slack bot user is the app's; every other account is one a person connected.
  accountSessions: {
    identifier: "dot-accounts",
    withSession: (request, use) => request.accountId === slackBot.id
      ? use({ token: process.env.SLACK_BOT_TOKEN || OFFLINE_SLACK_TOKEN })
      : connectedAccounts.withSession(request, use),
  },

  // The monitor pauses the dot after hand-offs and denials in a row.
  run: (agent, ctx) => (isCall(ctx) ? call(agent, ctx) : monitored(agent, ctx, reviewedTools(), () => ctx.defaultRun())),
});

/** Runs the person started: from the app, or by messaging the dot in Slack (only its owner gets in). New mail does not count. */
export function startedByPerson(request: FoundryRequest): boolean {
  if (request.source?.kind === "direct") return true;
  return request.source?.kind === "transmission" && request.source.provider === slackMessages.id;
}

/** A run the dot started on a run that could act. Transmissions never count, whatever their payload says. */
export function followUp(request: FoundryRequest): boolean {
  const kind = request.source?.kind;
  return (kind === "activation" || kind === "spawn" || kind === "background")
    && (request.payload as { followUp?: unknown } | null | undefined)?.followUp === true;
}

/** Runs that only read: research, wake-ups, new mail, and every run of a paused dot. */
export function readOnly(request: FoundryRequest, dot?: { readonly paused?: unknown }): boolean {
  if (dot?.paused === true) return true;
  return !(startedByPerson(request) || followUp(request) || request.source?.kind === "delegation");
}

export async function dotTools(ctx: Context): Promise<GloveFoldArgs<any>[]> {
  const read = researchTools(ctx.agentId);           // read_channel, read_notes, keep_note, suggest
  const dot = await currentDot(ctx);
  if (readOnly(ctx.request, dot)) return read;
  const review = reviewOf(dot, [], ctx.request);
  return [...read, ...actionsFor(ctx.agentId).map((action) => reviewed(action, review))];
}

// agents/dot/apps/gmail.app.ts: on read-only runs, only the mailbox's reads mount.
tools: (tool, ctx) => (readOnly(ctx.request) && !tool.readOnly && !reads.includes(tool.name) ? "hide" : policy(tool, ctx)),

export function followUps(agent: IGloveRunnable, agentId: string, acts: boolean): void {
  if (!acts) {
    for (const name of STARTS_RUNS) aroundTool(agent, name, () => undefined);
    // …and glove_foundry_schedules becomes a tool that only lists.
    return;
  }
  for (const name of STARTS_RUNS) {
    aroundTool(agent, name, ({ run, ...tool }) => ({
      ...tool,
      do: (input: Record<string, unknown>, _display, _glove, signal) => run({
        ...input,
        ...(name === "glove_foundry_spawn" && !input.agentId && !input.definitionId ? { agentId } : {}),
        payload: { followUp: true, ...(input.payload !== undefined ? { payload: input.payload } : {}) },
      }, signal),
    }));
  }
  // An update never changes what a schedule carries, so no run can stamp the
  // research schedule and make research act.
  aroundTool(agent, "glove_foundry_schedules", ({ run, ...tool }) => ({
    ...tool,
    do: (input: Record<string, unknown>, _display, _glove, signal) => {
      const { payload: _payload, ...kept } = input;
      return run(kept, signal);
    },
  }));
}

/** Always handed to the person. */
export const ALWAYS_YOURS: ReadonlySet<string> = new Set(["change_password", "transfer_money"]);
/** Never below "ask first". */
export const ALWAYS_ASKS: ReadonlySet<string> = new Set(["delete_permanently", "install_software", "buy_with_saved_card"]);

export function levelFor(name: string, rules: Readonly<Record<string, Level>>): Level {
  if (ALWAYS_YOURS.has(name)) return "block";
  const level = rules[name] ?? "ask";
  return ALWAYS_ASKS.has(name) && (level === "allow" || level === "when_asked") ? "ask" : level;
}

export function reviewed<I>(action: Action<I>, review: Review): GloveFoldArgs<I> {
  const { recipient, handOff, rule = action.name, ...tool } = action;
  const level = levelFor(rule, review.rules);
  const described = { ...tool, description: `${tool.description} Rule: ${ruleLabel(rule, review.rules)}.` };

  if (level === "block") {
    return {
      ...described,
      do: async (input) => notRun(rule, `It stays with ${review.owner}. ${handOff(input)} ${review.tellPerson}`),
    };
  }
  const asks = level === "ask" || (level === "when_asked" && !review.askedByPerson);
  // The instruction check: writing to someone the person never heard from always asks.
  const unknownRecipient = (input: I) =>
    recipient !== undefined && !review.contacts.includes(recipient(input).trim().toLowerCase());
  return {
    ...described,
    requiresPermission: asks ? true : unknownRecipient,
  };
}

export async function reviewSends(agent: IGloveRunnable, ctx: Context, dot: ParsedDot): Promise<void> {
  if (readOnly(ctx.request, dot)) return aroundTool(agent, sendTool(), () => undefined);   // read-only runs can't send
  const review = reviewOf(dot, await knownContacts(agent), ctx.request);   // who wrote in, via gmail.search_threads
  aroundTool(agent, sendTool(), (send) => reviewed<Send>({
    name: send.name,
    description: "Send an email from the mailbox you work from: a reply (pass threadId and inReplyTo) or a new message.",
    jsonSchema: send.jsonSchema,
    rule: "send_email",
    recipient: (input) => input.payload.to,
    handOff: (input) => `Send "${input.payload.subject}" to ${input.payload.to} yourself.`,
    do: (input, _display, _glove, signal) => send.run(input, signal),           // Foundry still delivers it
  }, review));
}

for (const outcome of ended) streak = outcome === "ran" ? 0 : streak + 1;
  if (streak >= PAUSE_AFTER) {
    const instance = await storedInstance(ctx);
    await Effect.runPromise(ctx.data.putAgent({
      ...instance,
      context: { ...instance.context, paused: true },
      updatedAt: new Date().toISOString(),
    }));
    streak = 0;
  }

export const dotComputer = defineWorkingEnvironment({
  options: { stdlib: [fetchFiles({ maxResponseBytes: 2_000_000 })] },
  persistence: foundryDataEnvironmentPersistence({ scope: "agent" }),
});

export function instanceMemory(description: string) {
  return defineMemory({
    description,
    context: {
      adapter: ({ workspaceId, agentId }) =>
        Effect.sync(() => layerContext([
          { name: "account", adapter: accountMemory(workspaceId), access: "read" },
          { name: "dot", adapter: pinned(`${workspaceId}/${agentId}`), access: "write" },
        ])),
    },
  });
}

export function messagesFrom(slackUserId: string) {
  return composePlaybook({
    name: "slack-messages",
    transmission: slackMessages,
    match: { event: message, routes: [slackMessagesIn], predicate: { definition: fromOwner, parameters: { slackUserId } } },
    directives: [{
      action: answer,
      instruction: "Answer with post_to_slack in the same channel. For a mention in a channel, answer in its thread. Use what you know from the app too.",
    }],
    applications: [slackApp],
  });
}

export function specialistFor(org: string, specialist: Omit<Dot, "kind"> & { account?: AccountReference }) {
  const { account, ...dot } = specialist;
  const parsed = Dot.parse({ ...dot, kind: "specialist" });
  return {
    id: `${org}-${parsed.name.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`,
    workspaceId: org,
    name: parsed.name,
    description: `Specialist dot for ${parsed.owner}: ${parsed.responsibilities.map((item) => item.job).join(" ")}`,
    context: parsed,
    installations: [install(slackApp, undefined, { account: account ?? slackBot })],
  };
}

pnpm --filter glove-foundry-standing-agents verify

1. Pip (sam-dot) and the app conversation are seeded data; research runs every 2h there; the mailbox watch is connected
2. research read #feedback and the mailbox in code, kept notes and suggested: "CSV export times out on large reports: …"
   23 tools mounted, none that act (no send_email, open_draft_pr, merge_pr, change_password, Gmail send, post_to_slack), no builder, no computer, no schedule or spawn
   runs from schedules, spawn and background are read-only unless they are follow-ups; new mail always is
3. "ask": the Gmail send waited for approval; approved: "Sent the reply to dana@acme.test."
4. "block": merge_pr handed to Sam in Slack: "Over to you: Review PR #42 and merge it yourself."
   change_password with a rule of "allow" is still Sam's (built-in safety): …
5. "allow": open_draft_pr ran with no approval: "Opened draft PR #101: Stream large CSV exports."
   send_email on "allow" still asks before writing to an address that never wrote in
6. Slack DM from Sam joined "transmission:agent:sam-dot:slack"; answered there: "From the app: Billing questions go to Priya."
   a stranger's mention started nothing
7. new mail started a read-only run: "New mail from ken@umbrella.test about the CSV export; noted with the other reports."
8. on Pip's own computer: /workspace/feedback-this-week.md
9. handed to Pip's builder (dot/workers/builder, a durable subagent); back in the app: "The builder finished. Wrote /out/weekly-feedback.md: …"
10. a follow-up Sam set, every Monday at 9:00 in his time zone: "Set: every Monday at 9:00 New York time, I'll open a draft PR for the week's export fixes."
    open_draft_pr on "when_asked": no approval when Sam asks; on the follow-up's run it asked first, and Sam denied it
11. a denial and two hand-offs in a row paused Pip; asked for a draft PR, the tool wasn't there
    Sam resumes it with configureAgent; the draft PRs already opened stay open

kuiper login
kuiper projects create dots && kuiper use dots
kuiper units create dots

kuiper providers add anthropic --key -            # once per organisation
kuiper secrets set SLACK_BOT_TOKEN=- SLACK_SIGNING_SECRET=- FOUNDRY_TOKEN=- WEB_SESSION_SECRET=-
kuiper secrets set GOOGLE_CLIENT_SECRET=- GOOGLE_SERVICE_ACCOUNT_JSON=-
kuiper env set -u dots DOTS_DATA_DIR=/data \
  'FOUNDRY_TOKEN=${{secrets.FOUNDRY_TOKEN}}' \
  'WEB_SESSION_SECRET=${{secrets.WEB_SESSION_SECRET}}' WEB_URL=https://… \
  'ANTHROPIC_API_KEY=${{models.API_KEY}}' \
  'ANTHROPIC_BASE_URL=${{models.ANTHROPIC_BASE_URL}}' \
  'SLACK_BOT_TOKEN=${{secrets.SLACK_BOT_TOKEN}}' \
  'SLACK_SIGNING_SECRET=${{secrets.SLACK_SIGNING_SECRET}}' \
  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 dots --wait

# Set <WEB_URL>/webhooks/slack as the Slack app's request URL.