thursday-agent 0.2.0 → 0.4.0

package/features/ai/components/model-picker.tsx

@@ -22,6 +22,7 @@ import type {
   TextModelProviderId,
 } from "../model.schema";
 import { canMakeKind, MEDIA_MODEL_PROVIDERS } from "../model.schema";
+import { ChatGptSignIn } from "./chatgpt-sign-in";
 import { ModelBrowser } from "./model-browser";
 import { ProviderIcon } from "./provider-icon";
 
@@ -35,10 +36,13 @@ export function ModelPicker({
   provider,
   model,
   kind,
+  unset,
   onChange,
 }: {
   provider: TextModelProviderId | null;
   model: string;
+  /** What no provider reads as, when the caller has no default to fall back to. */
+  unset?: string;
   /** What the model makes. Absent means a text model (bots, calls); set, only providers and suggestions for that kind remain. */
   kind?: MediaKind;
   onChange: (next: { provider: TextModelProviderId; model: string }) => void;
@@ -90,7 +94,7 @@ export function ModelPicker({
               // Unset is a value, not a blank: a text model falls back to the app
               // default (model.ts resolveDefaultModel), a media kind is simply not offered
               <span className="text-muted-foreground">
-                {kind ? "Not picked" : "App default"}
+                {unset ?? (kind ? "Not picked" : "App default")}
               </span>
             )}
             <ChevronDown className="size-3.5 text-muted-foreground" />
@@ -177,6 +181,18 @@ export function AskForKey({
     },
   });
 
+  // Signed in to, not typed; the sign-in's `config` signal re-reads hasKey and this goes away
+  if (provider.signIn) {
+    return (
+      <div className="flex items-center justify-between gap-2">
+        <p className="px-1 font-mono text-[11px] text-muted-foreground">
+          Runs on your plan once you sign in
+        </p>
+        <ChatGptSignIn variant="outline" />
+      </div>
+    );
+  }
+
   return (
     <div className="flex gap-2">
       <Input

package/features/ai/components/provider-icon.tsx

@@ -28,6 +28,7 @@ const getIconByProvider = (
     case "google":
       return GoogleIcon;
     case "openai":
+    case "chatgpt":
       return OpenAIIcon;
     case "vercel-ai-gateway":
       return VercelIcon;

package/features/ai/load-tools.ts

@@ -1,28 +1,22 @@
 import { asSchema, type ToolSet, tool } from "ai";
 import { formatDistanceToNowStrict } from "date-fns";
-import { IS_DEV } from "@/config";
+import { CALL_EXEC_TIMEOUT_MS, IS_DEV } from "@/config";
 import type { TextModel } from "@/features/ai/model";
-import { clockNow, tidying } from "@/features/ai/prompts/prompt-helper";
+import { clockNow } from "@/features/ai/prompts/prompt-helper";
 import {
+  answerTool,
   askThursdayTool,
-  createReportTool,
   delegateSpec,
   taskSpec,
 } from "@/features/ai/tools/bot.tool";
 import { CALL_TOOLS } from "@/features/ai/tools/call.tool";
 import { createMcpTools } from "@/features/ai/tools/mcp.tool";
-import {
-  botRememberTool,
-  createMemoryTools,
-} from "@/features/ai/tools/memory.tool";
+import { createMemoryTools } from "@/features/ai/tools/memory.tool";
 import { createSearchTool } from "@/features/ai/tools/search.tool";
 import { createSkillTools } from "@/features/ai/tools/skills.tool";
-import { tidyDoneTool } from "@/features/ai/tools/tidy.tool";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
 import { createWorkspaceTools } from "@/features/ai/tools/workspace.tool";
-import { readBotNotesOn } from "@/features/bot/bot.query";
 import { taskActivity } from "@/features/bot/bot.schema";
-import { listNoteIndex } from "@/features/memory/memory.query";
 import { loadSkills } from "@/features/skills/skills.discover";
 import { readCallSkillsOn } from "@/features/thursday/thursday.query";
 import { jobShellEnv, openWorkspace } from "@/features/workspace/workspace";
@@ -30,19 +24,18 @@ import { toDate } from "@/lib/date-like";
 import { logger } from "@/lib/logger";
 import { estimateTokens } from "@/lib/tokens";
 import { clip } from "@/lib/utils";
-import { resolveSearchModel } from "./model";
 
 /**
  * Which tools each runtime is handed; what it is told about them is the prompt's job.
  * Every tool runs on the server, including calls made during a voice session; only `end_call`
  * has no execute (the page hangs up). The split is by time, not capability: anything that
- * presupposes waiting (MCP, studio, browser) belongs to the bot. Every runtime writes to
- * memory, but only the call gets the whole of it: revising, carrying and naming need the user there.
+ * presupposes waiting (MCP, studio, browser) belongs to the bot. Only the call and an edit on
+ * the memory screen write to memory: revising, carrying and naming need the user there. A bot reads it.
  * Skills are the one thing that crosses back, and only when asked for: the call reads one itself
  * when Settings › Thursday says so (thursday.query readCallSkillsOn).
  */
 
-export type ToolTarget = "thursday" | "bot" | "tidy";
+export type ToolTarget = "thursday" | "bot" | "memory-edit";
 
 /** Which runtime is running, and what that run knows about itself. */
 export type ToolRun =
@@ -55,13 +48,13 @@ export type ToolRun =
       target: "bot";
       /** This run's bot name, the key of the bot table. */
       bot: string;
-      /** This job; the bot's shell pins its browser session to it (workspace.ts). */
-      taskId?: string | null;
-      /** The model this run already resolved (bot.run resolveModel); `web_search` runs on it (model.ts resolveSearchModel). */
+      /** The browser session this run's shell drives (workspace.ts jobShellEnv): the job's, or a borrowed bot's own. */
+      session?: string | null;
+      /** The model this run already resolved (bot.run resolveModel); its own native search is what `web_search` uses when no Exa key is set (tools/search.tool). */
       model?: TextModel | null;
     }
-  /** The memory tidy pass (memory.tidy): memory, and nothing that takes time. */
-  | { target: "tidy" };
+  /** An edit from the memory screen (memory/memory.edit): memory's read and two writes, run as the model calls them. */
+  | { target: "memory-edit" };
 
 /**
  * Starting work and following it. bot.runner is imported dynamically to break a cycle
@@ -80,19 +73,27 @@ function createTaskTools(callId: string | null | undefined): ToolSet {
           "@/features/bot/bot.query"
         );
         const found = await findJobBot(bot);
-        if (!found) {
+        // A switched-off bot resolves (a job it already has still resumes) but is
+        // not one to pick, so it fails here rather than in listJobBots.
+        if (!found || found.disabled) {
           const names = (await listJobBots()).map((one) => one.name);
           return `There is no bot called "${bot}". The bots are: ${names.join(", ")}. Nothing was handed over — call again with one of those.`;
         }
 
         // The row carries the bot's own spelling, not the transcript's
         const { startTask } = await import("@/features/bot/bot.runner");
-        const id = await startTask({ bot: found.name, request, label, callId });
+        const id = await startTask({
+          bot: found.name,
+          request,
+          label,
+          callId,
+          from: "thursday",
+        });
         return {
           taskId: id,
           // The label is the handle: without it in front of her, a follow-up
           // becomes a second job instead of a word to the one running
-          note: `${found.name} has "${label}". Say so and keep talking — the result is put in front of you later. Everything further about it — an answer, a correction, carrying it on after it reports — is \`${TOOL_NAMES.task}\` with "${label}".`,
+          note: `${found.name} has "${label}". Say so and keep talking — the result is put in front of you later. Everything further about it — an answer, a correction, carrying it on after it answers — is \`${TOOL_NAMES.task}\` with "${label}".`,
         };
       },
     }),
@@ -116,7 +117,7 @@ function createTaskTools(callId: string | null | undefined): ToolSet {
           // The clock, because the one in the instructions is from when the call
           // opened and a call can run for hours; `since` is measured against this.
           const now = { now: clockNow() };
-          // A named job comes back whole; the list clips outcomes, and the model pads a clipped report
+          // A named job comes back whole; the list clips outcomes, and the model pads a clipped answer
           if (task) {
             const found = await resolveTask(task);
             const one = found;
@@ -161,10 +162,22 @@ function createTaskTools(callId: string | null | undefined): ToolSet {
             })),
           };
         }
-        if (!task)
-          return "Say which job — by its label. Call `status` with no job named to see them.";
-        const one = await resolveTask(task);
-        if (!one) return await noSuchJob(task);
+        // A name is how a job is taken, but the one that just moved is what
+        // "that one" means out loud, and making the model fetch a label it
+        // already heard is what sends it to `delegate` instead. Cancel still
+        // needs the name: it cannot be taken back.
+        const { listInboxTasks } = await import("@/features/bot/task.query");
+        const one = task
+          ? await resolveTask(task)
+          : action === "answer"
+            ? ((await listInboxTasks())[0] ?? null)
+            : null;
+        if (!one) {
+          if (task) return await noSuchJob(task);
+          return action === "answer"
+            ? "No job has moved yet — say which one, or check `status` first."
+            : "Say which job — by its label. Call `status` with no job named to see them.";
+        }
 
         const { answerTask, cancelTask } = await import(
           "@/features/bot/bot.runner"
@@ -174,9 +187,12 @@ function createTaskTools(callId: string | null | undefined): ToolSet {
           return { label: one.label, status: "cancelled" };
         }
         if (!answer?.trim()) return "Say what to pass on.";
-        await answerTask(one.id, answer.trim());
+        await answerTask(one.id, answer.trim(), "thursday");
         return {
+          // Named even when the model named it: with no job given this is the
+          // one that moved last, and saying which makes a wrong one obvious
           label: one.label,
+          bot: one.bot,
           status: "running",
           note:
             one.status === "running"
@@ -234,23 +250,26 @@ export async function loadTools(run: ToolRun): Promise<ToolSet> {
 }
 
 async function buildTools(run: ToolRun): Promise<ToolSet> {
-  // The runtime is the hand: the call as the user talks, the pass that reads
-  // calls back, a bot mid-job (memory.tool botRememberTool records its own).
-  const memory = createMemoryTools(run.target === "tidy" ? "tidy" : "call");
-
-  if (run.target === "tidy") {
-    // Reading calls back (memory/memory.tidy): the one runtime besides the call
-    // that writes memory. No screen to show a note on and no shell, so no workspace is opened.
-    const { [TOOL_NAMES.memory_show]: _show, ...rest } = memory;
-    return { ...rest, [TOOL_NAMES.tidy_done]: tidyDoneTool };
+  if (run.target === "memory-edit") {
+    // Memory's own read and writes, in the user's hand: they asked for it on
+    // screen. Opening a note to change it is not a recall (memory.tool countReads)
+    const hand = createMemoryTools("user", null, { countReads: false });
+    return {
+      [TOOL_NAMES.memory_recall]: hand[TOOL_NAMES.memory_recall],
+      [TOOL_NAMES.memory_remember]: hand[TOOL_NAMES.memory_remember],
+      [TOOL_NAMES.memory_forget]: hand[TOOL_NAMES.memory_forget],
+    };
   }
 
+  // The call's hand. A bot is handed only the reads from it (below).
+  const memory = createMemoryTools(
+    "call",
+    run.target === "thursday" ? (run.callId ?? null) : null,
+  );
+
   const sandbox = await openWorkspace();
 
   if (run.target === "thursday") {
-    // memory_show only when there is something to tidy (prompt-helper tidying)
-    const { [TOOL_NAMES.memory_show]: show, ...always } = memory;
-    const { crowded, heavy } = tidying(await listNoteIndex());
     // Off unless switched on: a skill is a page of instructions arriving
     // mid-sentence. Switched off, the prompt does not list them as hers either
     // (thursday.prompt), so the two always say the same thing
@@ -259,11 +278,15 @@ async function buildTools(run: ToolRun): Promise<ToolSet> {
       : {};
 
     return {
-      ...always,
-      ...(crowded || heavy.length ? { [TOOL_NAMES.memory_show]: show } : {}),
+      ...memory,
       ...skills,
-      // The shell alone. A whole file is a job, not a glance (workspace.tool)
-      ...createWorkspaceTools(sandbox, { write: false }),
+      // The shell alone, for no longer than a call can sit silent on it: the mic
+      // is closed while a tool runs (config CALL_EXEC_TIMEOUT_MS). A whole file is
+      // a job, not a glance (workspace.tool)
+      ...createWorkspaceTools(sandbox, {
+        write: false,
+        timeoutMs: CALL_EXEC_TIMEOUT_MS,
+      }),
       // Handing work over, following it, and hanging up belong to the voice session only
       ...createTaskTools(run.callId),
       ...CALL_TOOLS,
@@ -272,21 +295,21 @@ async function buildTools(run: ToolRun): Promise<ToolSet> {
 
   // A bot works inside a job it did not open: it can pull another bot in but cannot start a job.
   // `ask_bot` and `ask_back` are attached by the runner (bot.run), which swaps `ask_thursday`
-  // for `ask_back` in a borrowed bot. `report` ends every run.
+  // for `ask_back` in a borrowed bot. `answer` ends every run.
   const skills = await loadSkills(sandbox);
   return {
-    // A bot reads memory and adds to it; the rest of the set is the call's
-    // (memory.tool botRememberTool), and there is no screen to show a note on
+    // A bot only reads memory: every write is the call's, and there is no screen to show a note on
     [TOOL_NAMES.memory_recall]: memory[TOOL_NAMES.memory_recall],
-    [TOOL_NAMES.memory_remember]: botRememberTool,
-    // Runs on this bot's own model when it can search, else on whichever
-    // provider has a key; absent when none does (search.tool)
-    ...createSearchTool(await resolveSearchModel(run.model), sandbox),
-    // The browser rides in the shell: its session is this job's, set by the
-    // server rather than typed by the model (workspace.ts jobShellEnv)
+    [TOOL_NAMES.memory_conversation]: memory[TOOL_NAMES.memory_conversation],
+    // Exa when its key is set, else this bot's own model when it can search;
+    // absent when neither, and the browser is the way in (search.tool)
+    ...(await createSearchTool(run.model, sandbox)),
+    // The browser rides in the shell: its session is this seat's — the job's, or
+    // a borrowed bot's own — set by the server rather than typed by the model
+    // (workspace.ts jobShellEnv)
     ...createWorkspaceTools(sandbox, {
       write: true,
-      env: jobShellEnv(run.taskId),
+      env: jobShellEnv(run.session),
       // What the shell is like and what this machine has, on the first command
       // of the run only (workspace.tool shellGuide). The call gets no guide:
       // one command is a glance, not a job to plan around
@@ -296,7 +319,6 @@ async function buildTools(run: ToolRun): Promise<ToolSet> {
     ...(await createMcpTools(run.bot, sandbox)),
     ...createSkillTools({ sandbox, skills }),
     [TOOL_NAMES.ask_thursday]: askThursdayTool,
-    // No field for its own instructions when nobody keeps them (bot.schema BOT_NOTES_KEY)
-    [TOOL_NAMES.report]: createReportTool(await readBotNotesOn()),
+    [TOOL_NAMES.answer]: answerTool,
   };
 }