thursday-agent 0.4.0 → 0.6.0

package/features/ai/load-tools.ts

@@ -3,12 +3,7 @@ import { formatDistanceToNowStrict } from "date-fns";
 import { CALL_EXEC_TIMEOUT_MS, IS_DEV } from "@/config";
 import type { TextModel } from "@/features/ai/model";
 import { clockNow } from "@/features/ai/prompts/prompt-helper";
-import {
-  answerTool,
-  askThursdayTool,
-  delegateSpec,
-  taskSpec,
-} from "@/features/ai/tools/bot.tool";
+import { delegateSpec, threadSpec } from "@/features/ai/tools/bot.tool";
 import { CALL_TOOLS } from "@/features/ai/tools/call.tool";
 import { createMcpTools } from "@/features/ai/tools/mcp.tool";
 import { createMemoryTools } from "@/features/ai/tools/memory.tool";
@@ -16,12 +11,17 @@ import { createSearchTool } from "@/features/ai/tools/search.tool";
 import { createSkillTools } from "@/features/ai/tools/skills.tool";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
 import { createWorkspaceTools } from "@/features/ai/tools/workspace.tool";
-import { taskActivity } from "@/features/bot/bot.schema";
+import { threadActivity } from "@/features/bot/bot.schema";
 import { loadSkills } from "@/features/skills/skills.discover";
 import { readCallSkillsOn } from "@/features/thursday/thursday.query";
-import { jobShellEnv, openWorkspace } from "@/features/workspace/workspace";
+import {
+  botShellEnv,
+  jobShellEnv,
+  openWorkspace,
+} from "@/features/workspace/workspace";
 import { toDate } from "@/lib/date-like";
 import { logger } from "@/lib/logger";
+import { isPublicError } from "@/lib/public-error";
 import { estimateTokens } from "@/lib/tokens";
 import { clip } from "@/lib/utils";
 
@@ -41,14 +41,14 @@ export type ToolTarget = "thursday" | "bot" | "memory-edit";
 export type ToolRun =
   | {
       target: "thursday";
-      /** The current call; written on the task row `delegate` opens. */
+      /** The current call; written on the thread row `delegate` opens. */
       callId?: string | null;
     }
   | {
       target: "bot";
       /** This run's bot name, the key of the bot table. */
       bot: string;
-      /** The browser session this run's shell drives (workspace.ts jobShellEnv): the job's, or a borrowed bot's own. */
+      /** The browser session this run's shell drives (workspace.ts jobShellEnv): this participant's own in the job. */
       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;
@@ -58,10 +58,10 @@ export type ToolRun =
 
 /**
  * Starting work and following it. bot.runner is imported dynamically to break a cycle
- * (runner -> bot.run -> this file). `delegate` records which call opened the job; that decides
- * who is told when it ends (bot.runner).
+ * (runner -> bot.run -> this file). `delegate` records which call opened the job, so a
+ * later call's prompt finds the job under the line that opened it (Earlier calls).
  */
-function createTaskTools(callId: string | null | undefined): ToolSet {
+function createThreadTools(callId: string | null | undefined): ToolSet {
   return {
     [TOOL_NAMES.delegate]: tool({
       description: delegateSpec.description,
@@ -81,8 +81,8 @@ function createTaskTools(callId: string | null | undefined): ToolSet {
         }
 
         // The row carries the bot's own spelling, not the transcript's
-        const { startTask } = await import("@/features/bot/bot.runner");
-        const id = await startTask({
+        const { startThread } = await import("@/features/bot/bot.runner");
+        const id = await startThread({
           bot: found.name,
           request,
           label,
@@ -90,20 +90,20 @@ function createTaskTools(callId: string | null | undefined): ToolSet {
           from: "thursday",
         });
         return {
-          taskId: id,
+          threadId: 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 answers — is \`${TOOL_NAMES.task}\` with "${label}".`,
+          note: `${found.name} has "${label}". Its updates reach the conversation on their own. Anything further about this work — an answer, a correction, the next step once it finishes — is \`${TOOL_NAMES.thread}\` with "${label}".`,
         };
       },
     }),
 
-    [TOOL_NAMES.task]: tool({
-      description: taskSpec.description,
-      inputSchema: taskSpec.parameters,
-      execute: async ({ action, task, answer }) => {
-        const { listTaskHistory, resolveTask } = await import(
-          "@/features/bot/task.query"
+    [TOOL_NAMES.thread]: tool({
+      description: threadSpec.description,
+      inputSchema: threadSpec.parameters,
+      execute: async ({ action, thread, answer, recipient, replyTo }) => {
+        const { listThreadOverview, resolveThread } = await import(
+          "@/features/bot/thread.query"
         );
         if (action === "status") {
           // `status` only reads, and text left in `answer` reaches nobody — it
@@ -118,15 +118,21 @@ function createTaskTools(callId: string | null | undefined): ToolSet {
           // 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 answer
-          if (task) {
-            const found = await resolveTask(task);
-            const one = found;
-            if (!one) return await noSuchJob(task);
+          if (thread) {
+            const one = await resolveThread(thread);
+            if (!one) return await noSuchJob(thread);
+            const { findThreadView } = await import(
+              "@/features/bot/thread.query"
+            );
+            const room = (await findThreadView(one.id))?.room;
             return {
               ...now,
               ...dropped,
               label: one.label,
+              id: one.id,
               bot: one.bot,
+              participants: room?.participants ?? [],
+              questions: room?.questions ?? [],
               status: one.status,
               since: formatDistanceToNowStrict(toDate(one.updatedAt), {
                 addSuffix: true,
@@ -137,62 +143,122 @@ function createTaskTools(callId: string | null | undefined): ToolSet {
                 : {}),
             };
           }
-          const tasks = await listTaskHistory({ limit: 8 });
-          // No threads — only as much as is worth reading out: what it is
+          const threads = await listThreadOverview();
+          // No messages — only as much as is worth reading out: what it is
           // asking, the one line of what it is doing, or how it ended
           return {
             ...now,
             ...dropped,
-            tasks: tasks.map((task) => ({
-              label: task.label,
-              bot: task.bot,
-              status: task.status,
-              since: formatDistanceToNowStrict(toDate(task.updatedAt), {
+            threads: threads.map((thread) => ({
+              id: thread.id,
+              label: thread.label,
+              bot: thread.bot,
+              status: thread.status,
+              participants: thread.room.participants,
+              questions: thread.room.questions.map((question) => ({
+                ...question,
+                text: clip(question.text, 200),
+              })),
+              since: formatDistanceToNowStrict(toDate(thread.updatedAt), {
                 addSuffix: true,
               }),
-              ...(task.ask
-                ? { asking: task.ask.question, options: task.ask.options }
+              ...(thread.ask
+                ? { asking: thread.ask.question, options: thread.ask.options }
                 : {}),
-              ...(task.status === "running"
-                ? { now: taskActivity(task.lines) }
+              ...(thread.status === "running"
+                ? { now: threadActivity(thread.lines) }
                 : {}),
-              ...(task.outcome && task.status !== "waiting"
-                ? { outcome: clip(task.outcome, 200) }
+              ...(thread.outcome && thread.status !== "waiting"
+                ? { outcome: clip(thread.outcome, 200) }
                 : {}),
             })),
           };
         }
-        // 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)
+        // A name is how a job is taken. Unnamed, `open` shows the job that just
+        // moved, and `answer` reaches the one open question; words with no question
+        // waiting belong to a job the user names, never to whichever moved last.
+        // Cancel always needs the name: it cannot be taken back.
+        const { listInboxThreads, markSeen } = await import(
+          "@/features/bot/thread.query"
+        );
+        const unnamed = !thread && (action === "answer" || action === "open");
+        const inbox = unnamed ? await listInboxThreads() : [];
+        const asking =
+          action === "answer"
+            ? inbox.filter((row) => row.room.questions.length)
+            : [];
+        if (asking.length > 1)
+          return `Questions are waiting in more than one job: ${asking
+            .map(
+              (row) =>
+                `"${row.label}" (${row.room.questions.map((question) => question.bot).join(", ")})`,
+            )
+            .join(", ")}. Name the job.`;
+        const one = thread
+          ? await resolveThread(thread)
           : action === "answer"
-            ? ((await listInboxTasks())[0] ?? null)
-            : null;
+            ? (asking[0] ?? null)
+            : unnamed
+              ? (inbox[0] ?? null)
+              : null;
         if (!one) {
-          if (task) return await noSuchJob(task);
-          return action === "answer"
+          if (thread) return await noSuchJob(thread);
+          if (action === "answer")
+            return `No question is waiting. Name the job this is for; \`${TOOL_NAMES.thread}\` \`status\` lists them.`;
+          return unnamed
             ? "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(
+        if (action === "open") {
+          // The room on the call screen draws the inbox; an older job is only in the history
+          const room = unnamed ? inbox : await listInboxThreads();
+          if (!room.some((row) => row.id === one.id))
+            return `"${one.label}" is older than the call screen keeps; it is under Settings › Threads.`;
+          const { appEvents } = await import(
+            "@/app/api/events/app-event.server"
+          );
+          appEvents.emit({ type: "showThread", threadId: one.id });
+          return { label: one.label, open: true };
+        }
+        if (action === "seen") {
+          // The same as opening it on screen: it leaves the work waiting on the user
+          await markSeen([one.id]);
+          return { label: one.label, seen: true };
+        }
+        const { answerThread, cancelThread } = await import(
           "@/features/bot/bot.runner"
         );
         if (action === "cancel") {
-          await cancelTask(one.id);
+          await cancelThread(one.id);
           return { label: one.label, status: "cancelled" };
         }
         if (!answer?.trim()) return "Say what to pass on.";
-        await answerTask(one.id, answer.trim(), "thursday");
+        let told: Awaited<ReturnType<typeof answerThread>>;
+        try {
+          told = await answerThread(
+            one.id,
+            answer.trim(),
+            "thursday",
+            recipient ?? undefined,
+            replyTo ?? undefined,
+          );
+        } catch (cause) {
+          // Which question, or that it is gone, is the model's to fix: one line it can act on
+          if (isPublicError(cause)) return cause.message;
+          throw cause;
+        }
+        if (told?.answered)
+          return {
+            label: one.label,
+            answered: told.answered,
+            note: `${told.answered.bot} has the answer to its question and goes on from it.`,
+          };
         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,
+          bot: told?.to ?? one.bot,
           status: "running",
           note:
             one.status === "running"
@@ -206,11 +272,11 @@ function createTaskTools(callId: string | null | undefined): ToolSet {
 
 /** An unresolved reference answers with the recent jobs; a bare "no such job" is read as an error and relayed as one. */
 async function noSuchJob(ref: string): Promise<string> {
-  const { listTaskHistory } = await import("@/features/bot/task.query");
-  const recent = await listTaskHistory({ limit: 5 });
+  const { listThreadOverview } = await import("@/features/bot/thread.query");
+  const recent = await listThreadOverview();
   if (!recent.length) return "No jobs have been handed over yet.";
   const names = recent
-    .map((task) => `"${task.label}" (${task.bot}, ${task.status})`)
+    .map((thread) => `"${thread.label}" (${thread.bot}, ${thread.status})`)
     .join(", ");
   return `There is no job called "${ref}". The latest are: ${names}. Call again with one of those names.`;
 }
@@ -261,11 +327,16 @@ async function buildTools(run: ToolRun): Promise<ToolSet> {
     };
   }
 
-  // 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,
-  );
+  // The call's hand; a fact it writes is tied to the call it was said in. A bot
+  // is handed only the reads from it (below).
+  const { [TOOL_NAMES.memory_conversation]: conversation, ...memory } =
+    createMemoryTools(
+      "call",
+      run.target === "thursday" ? (run.callId ?? null) : null,
+    );
+  const readBack: ToolSet = {
+    [TOOL_NAMES.memory_conversation]: conversation,
+  };
 
   const sandbox = await openWorkspace();
 
@@ -279,46 +350,46 @@ async function buildTools(run: ToolRun): Promise<ToolSet> {
 
     return {
       ...memory,
+      ...readBack,
       ...skills,
-      // 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)
+      // The shell alone, for no longer than her answer can wait on it (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),
+      ...createThreadTools(run.callId),
       ...CALL_TOOLS,
     };
   }
 
   // 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. `answer` ends every run.
+  // The runner attaches messaging with the active continuation (bot.run).
   const skills = await loadSkills(sandbox);
   return {
     // 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_conversation]: memory[TOOL_NAMES.memory_conversation],
+    ...readBack,
     // 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)
+    // The browser rides in the shell: its session is this participant's in this job,
+    // set by the server rather than typed by the model (workspace.ts jobShellEnv),
+    // and so is the bot's artifacts folder
     ...createWorkspaceTools(sandbox, {
       write: true,
-      env: jobShellEnv(run.session),
+      env: { ...jobShellEnv(run.session), ...botShellEnv(run.bot) },
       // 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:
+      // of the run only (workspace.tool SHELL_GUIDE). The call gets no guide:
       // one command is a glance, not a job to plan around
       guide: true,
+      // Its own memory stays within its limits whichever of the two writes it
+      // (bot.memory), and its finished work stays in its own folder
+      bot: run.bot,
     }),
     // Pinned tools come with schemas; the rest sit behind `tool_search`, absent when nothing is left to find (mcp.tool)
     ...(await createMcpTools(run.bot, sandbox)),
     ...createSkillTools({ sandbox, skills }),
-    [TOOL_NAMES.ask_thursday]: askThursdayTool,
-    [TOOL_NAMES.answer]: answerTool,
   };
 }

package/features/ai/model.schema.ts

@@ -1,9 +1,5 @@
 import { z } from "zod";
 import { BOT_RUN } from "@/config";
-import {
-  REALTIME_PROVIDERS,
-  type SpeachModelProviderId,
-} from "@/lib/realtime/realtime.schema";
 
 /** Providers and model catalogs. Nothing is stored here; a model is named by whatever runs on it. */
 
@@ -25,20 +21,6 @@ export const textModelRefSchema = z.object({
 export type TextModelProviderId = z.infer<typeof textModelProviderSchema>;
 export type TextModelRef = z.infer<typeof textModelRefSchema>;
 
-/** Who runs the call. The ids are the realtime drivers that exist (lib/realtime/realtime.schema). */
-export const speachModelProviderSchema = z.enum(REALTIME_PROVIDERS);
-
-export const speachModelRefSchema = z.object({
-  provider: speachModelProviderSchema,
-  /** Null means whatever that provider's default voice is. */
-  voice: z.string().trim().min(1).max(64).nullish(),
-  /** Null means that provider's first model (SPEACH_MODEL_PROVIDERS). Free text so a new model needs no edit here. */
-  model: z.string().trim().min(1).max(80).nullish(),
-});
-
-export type { SpeachModelProviderId };
-export type SpeachModelRef = z.infer<typeof speachModelRefSchema>;
-
 /** Size of a suggested model, not quality. A label rather than a price because prices move. */
 export const MODEL_TIERS = ["small", "mid", "large"] as const;
 export type ModelTier = (typeof MODEL_TIERS)[number];
@@ -262,11 +244,6 @@ export const MEDIA_MODEL_PROVIDERS: Record<
           label: "Grok Imagine 2.0",
           tier: "small",
         },
-        {
-          id: "google/gemini-3.1-flash-image",
-          label: "Gemini 3.1 Flash Image",
-          tier: "mid",
-        },
         { id: "bfl/flux-2-pro", label: "FLUX 2 Pro", tier: "mid" },
         {
           id: "bytedance/seedream-5.0-pro",
@@ -274,11 +251,6 @@ export const MEDIA_MODEL_PROVIDERS: Record<
           tier: "mid",
         },
         { id: "recraft/recraft-v4.1", label: "Recraft V4.1", tier: "mid" },
-        {
-          id: "google/gemini-3-pro-image",
-          label: "Gemini 3 Pro Image",
-          tier: "large",
-        },
         {
           id: "openai/gpt-image-2.5-sunburst",
           label: "GPT Image 2.5 Sunburst",
@@ -370,10 +342,6 @@ export const canMakeKind = (provider: string, kind: MediaKind): boolean =>
   (MEDIA_MODEL_PROVIDERS[provider as MediaModelProviderId]?.models[kind]
     ?.length ?? 0) > 0;
 
-/** How a pick is stored and shown: "openai/gpt-image-2". Split on the first slash only; gateway ids carry a slash of their own. */
-export const formatMediaModel = (ref: MediaModelRef) =>
-  `${ref.provider}/${ref.model}`;
-
 /** `provider/model` for a text model, as the default-model config stores it. */
 export function parseTextModel(value: string | undefined): TextModelRef | null {
   const [provider, ...rest] = (value ?? "").trim().split("/");
@@ -384,6 +352,7 @@ export function parseTextModel(value: string | undefined): TextModelRef | null {
   return parsed.success ? parsed.data : null;
 }
 
+/** How a media pick is stored: "openai/gpt-image-2". Split on the first slash only; gateway ids carry a slash of their own. */
 export function parseMediaModel(
   value: string | undefined,
 ): MediaModelRef | null {
@@ -595,93 +564,6 @@ const modelOfTier = (
 export const defaultModelOf = (provider: { suggestModels: SuggestModel[] }) =>
   modelOfTier(provider, "mid");
 
-/**
- * The speech-to-speech backends. `models` and `voices` are suggestion lists, not validation
- * lists (the api takes more, e.g. a cloned voice id); the first model is the default. Written
- * out rather than fetched, best first.
- */
-export const SPEACH_MODEL_PROVIDERS: Record<
-  SpeachModelProviderId,
-  {
-    label: string;
-    apiKeyName: string;
-    /** What a key of theirs starts with (`detectSpeachProvider`); longest match wins. */
-    keyPrefix: string[];
-    /** Newest first — the head of this list is the default. */
-    models: { id: string; label: string }[];
-    voices: string[];
-    defaultVoice: string;
-  }
-> = {
-  openai: {
-    apiKeyName: TEXT_MODEL_PROVIDERS.openai.apiKeyName,
-    label: TEXT_MODEL_PROVIDERS.openai.label,
-    keyPrefix: ["sk-"],
-    models: [
-      { id: "gpt-realtime-2.1", label: "Realtime 2.1" },
-      { id: "gpt-realtime-2.1-mini", label: "Realtime 2.1 mini" },
-      { id: "gpt-realtime-2", label: "Realtime 2" },
-    ],
-    // The spec's VoiceIdsShared enum; `marin` and `cedar` lead as the realtime docs' best-quality voices
-    voices: [
-      "marin",
-      "cedar",
-      "alloy",
-      "ash",
-      "ballad",
-      "coral",
-      "echo",
-      "sage",
-      "shimmer",
-      "verse",
-    ],
-    defaultVoice: "marin",
-  },
-  xai: {
-    apiKeyName: TEXT_MODEL_PROVIDERS.xai.apiKeyName,
-    label: TEXT_MODEL_PROVIDERS.xai.label,
-    keyPrefix: ["xai-"],
-    models: [
-      { id: "grok-voice-think-fast-2.0", label: "Voice Think Fast 2.0" },
-      // Tracks whatever xAI ships next; second because a name that moves under a running call is not a default
-      { id: "grok-voice-latest", label: "Voice latest" },
-    ],
-    // `eve` is xAI's own default. All built-in ids; a cloned voice from POST /v1/custom-voices goes in the same field
-    voices: ["eve", "ara", "leo", "rex", "sal"],
-    defaultVoice: "eve",
-  },
-};
-
-/**
- * Which voice provider a pasted key belongs to; null when unknown. `sk-ant-` is excluded
- * because Anthropic keys share OpenAI's prefix and Anthropic cannot take a call.
- */
-export function detectSpeachProvider(
-  key: string,
-): SpeachModelProviderId | null {
-  const trimmed = key.trim();
-  if (!trimmed || trimmed.startsWith("sk-ant-")) return null;
-
-  let found: SpeachModelProviderId | null = null;
-  let longest = 0;
-  for (const id of Object.keys(
-    SPEACH_MODEL_PROVIDERS,
-  ) as SpeachModelProviderId[]) {
-    for (const prefix of SPEACH_MODEL_PROVIDERS[id].keyPrefix) {
-      if (trimmed.startsWith(prefix) && prefix.length > longest) {
-        found = id;
-        longest = prefix.length;
-      }
-    }
-  }
-  return found;
-}
-
-/** The record above in a stable order — the voice picker walks it. */
-export const SPEACH_MODEL_PROVIDER_LIST = (
-  Object.keys(SPEACH_MODEL_PROVIDERS) as SpeachModelProviderId[]
-).map((id) => ({ id, ...SPEACH_MODEL_PROVIDERS[id] }));
-
 /** The record above in a stable order — routes and pickers walk it. */
 export const TEXT_MODEL_PROVIDER_LIST = (
   Object.keys(TEXT_MODEL_PROVIDERS) as TextModelProviderId[]
@@ -747,7 +629,7 @@ export type GatewayModel = {
   label: string;
   /** Who runs it, the gateway's own word. Four of them are providers this app draws (provider-icon). */
   owner: string;
-  /** Settled in ai/model `readGatewayCatalog`, not passed through; null when the gateway did not say. */
+  /** The gateway's own word, as `readGatewayCatalog` received it; null when it did not say. */
   type?: string | null;
   /** The gateway's own words for what a model can do; only `tool-use` is read. */
   tags: string[];