thursday-agent 0.3.0 → 0.5.0

package/features/ai/tools/skills.tool.ts

@@ -6,9 +6,8 @@ import { splitFrontmatter } from "@/features/skills/skills.query";
 import type { Sandbox } from "@/lib/sandbox";
 
 /**
- * A skill's full text is returned once per run; repeat loads get a pointer
- * back to the first result, since every step resends the whole context.
- * The tool set is built per run, so the `loaded` set lives in this closure.
+ * Reuse instructions only while their full text remains in this bot's context.
+ * A resume can carry them; compaction can remove them.
  */
 export const createSkillTools = ({
   skills,
@@ -17,7 +16,6 @@ export const createSkillTools = ({
   skills: SkillMetadata[];
   sandbox: Sandbox;
 }) => {
-  const loaded = new Set<string>();
   return {
     [TOOL_NAMES.load_skill]: tool({
       description:
@@ -29,7 +27,7 @@ export const createSkillTools = ({
             "Exact name from the Skills list. Do not guess names that are not on it.",
           ),
       }),
-      execute: async ({ name }) => {
+      execute: async ({ name }, { messages }) => {
         const skill = skills.find(
           (s) => s.name.toLowerCase() === name.toLowerCase(),
         );
@@ -41,10 +39,30 @@ export const createSkillTools = ({
         }
 
         const skillFile = `${skill.path}/SKILL.md`;
-        if (loaded.has(skill.path)) {
+        const carried = messages.some(
+          (message) =>
+            Array.isArray(message.content) &&
+            message.content.some((part) => {
+              if (
+                part.type !== "tool-result" ||
+                part.toolName !== TOOL_NAMES.load_skill ||
+                part.output.type !== "json"
+              )
+                return false;
+              const value = part.output.value as {
+                skillDirectory?: string;
+                content?: string;
+              } | null;
+              return (
+                value?.skillDirectory === skill.path &&
+                typeof value.content === "string"
+              );
+            }),
+        );
+        if (carried) {
           return {
             skillDirectory: skill.path,
-            note: `You already loaded '${skill.name}' in this run — its instructions are above, unchanged. Scroll back to that result rather than reading it again; if you need the file itself, read ${skillFile} with the shell.`,
+            note: `Use the full '${skill.name}' instructions already in your conversation. To check for changes on disk, read ${skillFile} with the shell.`,
           };
         }
 
@@ -55,7 +73,6 @@ export const createSkillTools = ({
           path: skill.path,
           limit: 50,
         });
-        loaded.add(skill.path);
 
         return {
           skillDirectory: skill.path,

package/features/ai/tools/tool-name.ts

@@ -7,7 +7,6 @@ export const TOOL_NAMES = {
   memory_recall: "memory_recall",
   memory_remember: "memory_remember",
   memory_forget: "memory_forget",
-  memory_show: "memory_show",
   memory_conversation: "memory_conversation",
 
   bash: "bash",

package/features/ai/tools/workspace.tool.ts

@@ -18,6 +18,8 @@ export const createWorkspaceTools = (
     env?: Record<string, string>;
     /** Attach the shell guide to this run's first `bash` result (bots only). */
     guide?: boolean;
+    /** How long one command may run; unset is the sandbox's own limit (config EXEC_TIMEOUT_MS). */
+    timeoutMs?: number;
   },
 ): ToolSet => {
   /** Fold absolute sandbox paths against cwd; they still resolve when handed back. */
@@ -45,6 +47,7 @@ export const createWorkspaceTools = (
       const result = await sandbox.exec(command, {
         signal: abortSignal,
         env: options.env,
+        timeoutMs: options.timeoutMs,
       });
       if (!owed) return result;
       owed = false;

package/features/bot/bot.action.ts

@@ -110,7 +110,12 @@ export const startTaskAction = serverAction(
     const worker = await findBot(bot);
     if (!worker) publicError(`No bot called "${bot}".`);
     const label = labelFor(said);
-    const id = await startTask({ bot: worker.name, request: said, label });
+    const id = await startTask({
+      bot: worker.name,
+      request: said,
+      label,
+      from: "user",
+    });
     return { id, label, bot: worker.name };
   },
 );

package/features/bot/bot.run.ts

@@ -41,17 +41,21 @@ import {
   type TokenUsage,
 } from "@/features/bot/bot.schema";
 import {
-  closeHiddenBrowser,
+  botBrowserSession,
   filesOnDisk,
   openBotFolder,
   openJobScratch,
 } from "@/features/workspace/workspace";
 import { logger } from "@/lib/logger";
 import { publicError } from "@/lib/public-error";
+import { createKeyedLock } from "@/lib/queue";
 import { estimateTokens } from "@/lib/tokens";
+import { PromiseChain } from "@/lib/utils";
 import { findJobBot } from "./bot.query";
 import {
   findTask,
+  listBorrowedTails,
+  listBotThread,
   listWrittenPaths,
   optionsOf,
   writtenPathsIn,
@@ -65,6 +69,11 @@ import {
 
 /** One thing that happened in a run. The runner adds which bot and inside which `ask_bot` call. */
 export type BotEvent =
+  /** A request enters this participant's own thread before its model runs. */
+  | {
+      type: "request";
+      content: Extract<ModelMessage, { role: "user" }>["content"];
+    }
   /** A finished chunk of prose. */
   | { type: "text"; text: string }
   /** A tool call. `id` is where the result lands. */
@@ -147,6 +156,8 @@ export type RunOptions = {
    * in one window.
    */
   session?: string | null;
+  /** Shared by every participant in this live segment; history itself lives in the DB. */
+  desks?: ReturnType<typeof createBotDesks>;
   /**
    * Drained once per step boundary; each string goes in front of the model as
    * a user turn before the next step. Only the job's own bot has one.
@@ -189,11 +200,11 @@ export async function runBot(
 ): Promise<void> {
   const depth = options.depth ?? 0;
   const parent = options.parent ?? null;
-  const name = input.bot.trim();
+  const bot = await findJobBot(input.bot.trim());
+  const name = bot?.name ?? input.bot.trim();
   const emit = (event: BotEvent) =>
     options.emit({ ...event, bot: name, parent });
 
-  const bot = await findJobBot(name);
   if (!bot) {
     await emit({
       type: "error",
@@ -205,7 +216,11 @@ export async function runBot(
   // Switched off is not a bot to pick — the backstop for every fresh start
   // (`delegate`, `ask_bot`, the screen). A resume carries `messages` instead and
   // is let through: its thread already exists and the user can still answer it.
-  if (bot.disabled && "request" in input) {
+  const previous =
+    "askedBy" in input && options.taskId
+      ? await listBotThread(options.taskId, name)
+      : [];
+  if (bot.disabled && "request" in input && !previous.length) {
     await emit({
       type: "error",
       message: `${bot.name} is switched off. Use a name from the list.`,
@@ -214,6 +229,30 @@ export async function runBot(
     return;
   }
 
+  options = { ...options, desks: options.desks ?? createBotDesks() };
+  let history: ModelMessage[];
+  if ("messages" in input) {
+    history = input.messages;
+  } else {
+    const content = previous.length
+      ? `## ${input.askedBy} → ${name}: the next request\n\n${input.request.trim()}${input.context?.trim() ? `\n\n## What ${input.askedBy} passes on\n\n${input.context.trim()}` : ""}`
+      : buildHandoff({
+          chain: input.chain,
+          bots: [...input.above, name],
+          did: input.context ?? null,
+          part: input.request,
+        });
+    history = [
+      ...resumeThread(
+        previous,
+        options.taskId ? await listBorrowedTails(options.taskId) : undefined,
+      ),
+      { role: "user", content },
+    ];
+    options.signal?.throwIfAborted();
+    await emit({ type: "request", content });
+  }
+
   // Tools are built on the model: web search runs on this bot's model (load-tools).
   const model = await resolveModel(bot);
   // The job's row: the same one for every seat on the job, a borrowed bot's too
@@ -254,21 +293,6 @@ export async function runBot(
     ("askedBy" in input ? 0 : row?.contextBudget) || Number.POSITIVE_INFINITY,
   );
 
-  const history: ModelMessage[] =
-    "messages" in input
-      ? input.messages
-      : [
-          {
-            role: "user",
-            content: buildHandoff({
-              chain: input.chain,
-              bots: [...input.above, name],
-              did: input.context ?? null,
-              part: input.request,
-            }),
-          },
-        ];
-
   /** Remaining `ask_back` calls for a borrowed bot; the tool counts it down. */
   const asks = { left: BOT_RUN.askBack };
   // A borrowed bot asks back instead of asking Thursday. Any seat above the
@@ -344,6 +368,7 @@ export async function runBot(
         const summary = await compact(model.model, agentTools, messages, {
           signal: options.signal,
           budget,
+          instructions: prompt.text,
         }).finally(quiet.release);
         logger.debug(
           `compacted ${messages.length} messages at ${size} tokens (budget ${budget})`,
@@ -701,17 +726,19 @@ async function filesUnder(
 /**
  * The model summarizes its own context and continues from the summary. Tools
  * are passed with calling off: providers refuse a history of tool calls
- * without the tools that made them. A context too long to summarise whole —
- * the very thing a compaction is for — is tried once more without the tool
- * calls and results but the last few. A failure throws with its cause kept:
- * the runner parks what a retry or a smaller budget can fix (bot.runner
- * parkTask) and fails the rest; the thread stays.
+ * without the tools that made them. The run's own instructions go too: the
+ * summary is written by the bot the thread belongs to, and the provider's
+ * cached prefix, instructions first, still matches the run's. A context too
+ * long to summarise whole — the very thing a compaction is for — is tried once
+ * more without the tool calls and results but the last few. A failure throws
+ * with its cause kept: the runner parks what a retry or a smaller budget can
+ * fix (bot.runner parkTask) and fails the rest; the thread stays.
  */
 async function compact(
   model: LanguageModel,
   tools: ToolSet,
   messages: ModelMessage[],
-  options: { signal?: AbortSignal; budget: number },
+  options: { signal?: AbortSignal; budget: number; instructions: string },
 ): Promise<{ text: string; usage: TokenUsage }> {
   let failure: unknown;
   try {
@@ -745,10 +772,11 @@ async function summarize(
   model: LanguageModel,
   tools: ToolSet,
   messages: ModelMessage[],
-  options: { signal?: AbortSignal; budget: number },
+  options: { signal?: AbortSignal; budget: number; instructions: string },
 ): Promise<{ text: string; usage: TokenUsage }> {
   const { text, usage } = await generateText({
     model,
+    system: options.instructions,
     tools,
     toolChoice: "none",
     messages: [
@@ -875,15 +903,20 @@ export async function runBotToText(
   await runBot(input, {
     ...options,
     emit: async (event) => {
-      if (event.type === "answer") {
+      if (
+        event.parent === (options.parent ?? null) &&
+        event.type === "answer"
+      ) {
         outcome = event.stopped
           ? `${event.text}\n\n(As far as they got — they stopped before finishing.)`
           : event.text;
       }
-      if (event.type === "error") failure = event.message;
+      if (event.parent === (options.parent ?? null) && event.type === "error")
+        failure = event.message;
       await options.emit(event);
     },
   });
+  options.signal?.throwIfAborted();
   if (failure) publicError(failure);
   return outcome;
 }
@@ -914,6 +947,11 @@ function withAskBot(
   },
 ): ToolSet {
   if (asker.peers.length === 0) return tools;
+  // Calls made in the same step answer from one evolving conversation.
+  const conversations = new WeakMap<
+    ModelMessage[],
+    { messages: ModelMessage[]; answer: ReturnType<typeof PromiseChain> }
+  >();
 
   const agentTools: ToolSet = {
     ...tools,
@@ -921,66 +959,143 @@ function withAskBot(
       description: askBotSpec.description,
       inputSchema: askBotSpec.parameters,
       execute: async ({ bot, request, context }, call) => {
-        // A bot above is blocked waiting on this very call; borrowing it back never returns
+        const found = await findJobBot(bot);
+        if (!found) return `No bot named "${bot}". Use a name from the list.`;
+        bot = found.name;
         if (bot === asker.name || asker.above.includes(bot)) {
-          return `${bot} is already on this job, above you and waiting on your part. Pick another bot, or do it yourself.`;
-        }
-        // The borrowed bot works in the job's folder but drives a browser session
-        // of its own, under this call's id. When it answers, the same rule as a
-        // job's end: what it showed on their screen stays, what nobody can see
-        // closes (workspace.ts closeHiddenBrowser).
-        const session = asker.options.taskId
-          ? `${asker.options.session ?? asker.options.taskId}-${call.toolCallId.slice(0, 8)}`
-          : null;
-        const exchanges: { question: string; answer: string }[] = [];
-        const answer = async (question: string) => {
-          const reply = await answerBack({
-            model: asker.model,
-            instructions: asker.instructions,
-            // Same tools, calling off (see compact).
-            tools: agentTools,
-            messages: call.messages,
-            asked: { bot, request },
-            question,
-            signal: asker.options.signal,
-          });
-          await asker.emit({ type: "answered", question, ...reply });
-          exchanges.push({ question, answer: reply.text });
-          return reply.text;
-        };
-        try {
-          const outcome = await runBotToText(
-            {
-              bot,
-              request,
-              context,
-              askedBy: asker.name,
-              chain: asker.chain,
-              above: [...asker.above, asker.name],
-            },
-            {
-              ...asker.options,
-              // This call's signal, not the job's: a stream that ends — the job
-              // stopping, or the model going quiet — ends the part it waited on
-              signal: call.abortSignal ?? asker.options.signal,
-              depth: asker.depth + 1,
-              parent: call.toolCallId,
-              session,
-              answer,
-            },
-          );
-          return exchanges.length
-            ? `${outcome}\n\n${exchangeLines(bot, exchanges)}`
-            : outcome;
-        } finally {
-          if (session) void closeHiddenBrowser(session);
+          return `${bot} is already above you and waiting on this part. Use ask_back for a question, or pick another bot.`;
         }
+        const signal = call.abortSignal ?? asker.options.signal;
+        const desks = asker.options.desks!;
+        return desks.run(asker.name, bot, signal, async () => {
+          const session = asker.options.taskId
+            ? botBrowserSession(asker.options.taskId, bot)
+            : null;
+          const exchanges: { question: string; answer: string }[] = [];
+          let conversation = conversations.get(call.messages);
+          if (!conversation) {
+            conversation = {
+              messages: [...call.messages],
+              answer: PromiseChain(),
+            };
+            conversations.set(call.messages, conversation);
+          }
+          const current = conversation;
+          const answer = (question: string) =>
+            current.answer(async () => {
+              signal?.throwIfAborted();
+              const reply = await answerBack({
+                model: asker.model,
+                instructions: asker.instructions,
+                tools: agentTools,
+                messages: current.messages,
+                asked: { bot, request },
+                question,
+                signal,
+              });
+              current.messages.push(
+                {
+                  role: "user",
+                  content: `${bot} asks about the part you handed over:\n\n${question}`,
+                },
+                { role: "assistant", content: reply.text },
+              );
+              await asker.emit({ type: "answered", question, ...reply });
+              exchanges.push({ question, answer: reply.text });
+              return reply.text;
+            });
+          try {
+            const outcome = await runBotToText(
+              {
+                bot,
+                request,
+                context,
+                askedBy: asker.name,
+                chain: asker.chain,
+                above: [...asker.above, asker.name],
+              },
+              {
+                ...asker.options,
+                signal,
+                depth: asker.depth + 1,
+                parent: call.toolCallId,
+                session,
+                // Only the task's owner drains words sent by the user.
+                notes: undefined,
+                answer,
+              },
+            );
+            return exchanges.length
+              ? `${outcome}\n\n${exchangeLines(bot, exchanges)}`
+              : outcome;
+          } catch (cause) {
+            signal?.throwIfAborted();
+            publicError(
+              [modelErrorToString(cause), exchangeLines(bot, exchanges)]
+                .filter(Boolean)
+                .join("\n\n"),
+            );
+          }
+        });
       },
     }),
   };
   return agentTools;
 }
 
+/** One execution per participant, with wait-cycle detection across concurrent branches. */
+export function createBotDesks() {
+  const lock = createKeyedLock();
+  const waiting = new Map<string, Map<string, number>>();
+  const pending = new Set<Promise<unknown>>();
+  const reaches = (
+    from: string,
+    to: string,
+    seen = new Set<string>(),
+  ): boolean => {
+    if (from === to) return true;
+    if (seen.has(from)) return false;
+    seen.add(from);
+    return [...(waiting.get(from)?.keys() ?? [])].some((next) =>
+      reaches(next, to, seen),
+    );
+  };
+  return {
+    async run<T>(
+      from: string,
+      to: string,
+      signal: AbortSignal | undefined,
+      work: () => Promise<T>,
+    ): Promise<T> {
+      signal?.throwIfAborted();
+      if (reaches(to, from))
+        publicError(
+          `${to} is waiting on your work. Finish this part before asking them, or choose another bot.`,
+        );
+      const edges = waiting.get(from) ?? new Map<string, number>();
+      waiting.set(from, edges);
+      edges.set(to, (edges.get(to) ?? 0) + 1);
+      const run = lock(to, async () => {
+        signal?.throwIfAborted();
+        return work();
+      });
+      pending.add(run);
+      try {
+        return await run;
+      } finally {
+        pending.delete(run);
+        const left = (edges.get(to) ?? 1) - 1;
+        if (left) edges.set(to, left);
+        else edges.delete(to);
+        if (!edges.size) waiting.delete(from);
+      }
+    },
+    async settle() {
+      while (pending.size) await Promise.allSettled([...pending]);
+    },
+  };
+}
+
 /** Appended under the answer: what the borrowed bot asked and what this bot answered. */
 function exchangeLines(
   bot: string,