thursday-agent 0.1.2 → 0.3.0

package/features/ai/components/chatgpt-sign-in.tsx

@@ -0,0 +1,66 @@
+"use client";
+
+import { type ComponentProps, useEffect, useRef, useState } from "react";
+import { Button } from "@/components/ui/button";
+import { toast } from "@/components/ui/toast";
+import { startChatGptSignInAction } from "@/features/config/config.action";
+import { useServerAction } from "@/lib/protocol/use-server-action";
+
+/** How often to look whether the sign-in window was closed, and how long to keep looking: as long as the server listens for its answer. */
+const WINDOW_POLL_MS = 700;
+const WINDOW_WATCH_MS = 10 * 60_000;
+
+/**
+ * Opens ChatGPT's sign-in in a window of its own. The answer lands on the server, which keeps it
+ * and signals the screen (`config`); whoever draws this takes it away once signed in. Until then
+ * the button waits, and stops waiting when the window is closed without finishing.
+ */
+export function ChatGptSignIn({
+  variant,
+}: {
+  variant?: ComponentProps<typeof Button>["variant"];
+}) {
+  const [waiting, setWaiting] = useState(false);
+  const watch = useRef<ReturnType<typeof setInterval> | null>(null);
+  const stopWatching = () => {
+    if (watch.current) clearInterval(watch.current);
+    watch.current = null;
+  };
+  useEffect(() => stopWatching, []);
+
+  const [start, starting] = useServerAction(startChatGptSignInAction, {
+    onOk: (url) => {
+      const popup = window.open(
+        url,
+        "thursday-chatgpt",
+        "popup,width=520,height=720",
+      );
+      if (!popup) {
+        toast.add({
+          type: "error",
+          title: "The sign-in window was blocked",
+          description: "Allow pop-ups for this page, then try again",
+        });
+        return;
+      }
+      setWaiting(true);
+      stopWatching();
+      const deadline = Date.now() + WINDOW_WATCH_MS;
+      watch.current = setInterval(() => {
+        if (!popup.closed && Date.now() < deadline) return;
+        stopWatching();
+        setWaiting(false);
+      }, WINDOW_POLL_MS);
+    },
+  });
+
+  return (
+    <Button
+      variant={variant}
+      loading={starting || waiting}
+      onClick={() => start()}
+    >
+      Sign in with ChatGPT
+    </Button>
+  );
+}

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,22 +1,19 @@
-import { type ToolSet, tool } from "ai";
+import { asSchema, type ToolSet, tool } from "ai";
 import { formatDistanceToNowStrict } from "date-fns";
+import { IS_DEV } from "@/config";
 import type { TextModel } from "@/features/ai/model";
-import { tidying } from "@/features/ai/prompts/prompt-helper";
+import { clockNow, tidying } from "@/features/ai/prompts/prompt-helper";
 import {
+  answerTool,
   askThursdayTool,
   delegateSpec,
-  reportTool,
   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 { taskActivity } from "@/features/bot/bot.schema";
@@ -25,8 +22,9 @@ import { loadSkills } from "@/features/skills/skills.discover";
 import { readCallSkillsOn } from "@/features/thursday/thursday.query";
 import { jobShellEnv, openWorkspace } from "@/features/workspace/workspace";
 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.
@@ -38,7 +36,7 @@ import { resolveSearchModel } from "./model";
  * 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 =
@@ -51,13 +49,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
@@ -76,7 +74,9 @@ 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.`;
         }
@@ -88,7 +88,7 @@ function createTaskTools(callId: string | null | undefined): ToolSet {
           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}".`,
         };
       },
     }),
@@ -109,12 +109,16 @@ function createTaskTools(callId: string | null | undefined): ToolSet {
                 note: "The text in `answer` was not passed on — `status` only reads. Send it again as `answer` if the bot is meant to hear it.",
               }
             : {};
-          // A named job comes back whole; the list clips outcomes, and the model pads a clipped report
+          // 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 answer
           if (task) {
             const found = await resolveTask(task);
             const one = found;
             if (!one) return await noSuchJob(task);
             return {
+              ...now,
               ...dropped,
               label: one.label,
               bot: one.bot,
@@ -132,6 +136,7 @@ function createTaskTools(callId: string | null | undefined): ToolSet {
           // No threads — 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,
@@ -152,10 +157,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"
@@ -167,7 +184,10 @@ function createTaskTools(callId: string | null | undefined): ToolSet {
         if (!answer?.trim()) return "Say what to pass on.";
         await answerTask(one.id, answer.trim());
         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"
@@ -190,16 +210,58 @@ async function noSuchJob(ref: string): Promise<string> {
   return `There is no job called "${ref}". The latest are: ${names}. Call again with one of those names.`;
 }
 
+/**
+ * What the set costs the model, beside the prompt's own line (prompts/prompt-helper
+ * logPromptSize). Descriptions and schemas are both counted because both are sent
+ * on every step. No budget here: the set is decided by the code, except for the MCP
+ * tools a bot is pinned to — those show up by name.
+ */
+async function logToolSize(target: ToolTarget, tools: ToolSet): Promise<void> {
+  const rows: { name: string; tokens: number }[] = [];
+  for (const [name, held] of Object.entries(tools)) {
+    const schema = await asSchema(held.inputSchema).jsonSchema;
+    // A description may be a function of the call's context; only a fixed one is counted
+    const said = typeof held.description === "string" ? held.description : "";
+    rows.push({
+      name,
+      tokens: estimateTokens(said) + estimateTokens(JSON.stringify(schema)),
+    });
+  }
+  rows.sort((a, b) => b.tokens - a.tokens);
+  const total = rows.reduce((sum, row) => sum + row.tokens, 0);
+  logger.debug(
+    `${target} tools ${total} tokens over ${rows.length} — ${rows
+      .map((row) => `${row.name} ${row.tokens}`)
+      .join(", ")}`,
+  );
+}
+
 export async function loadTools(run: ToolRun): Promise<ToolSet> {
-  const memory = createMemoryTools();
+  const tools = await buildTools(run);
+  // Measured only where the line would be printed: the schemas have to be built
+  // to be counted, and unlike a prompt this set does not grow with use.
+  if (IS_DEV) await logToolSize(run.target, tools);
+  return tools;
+}
 
-  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 };
+async function buildTools(run: ToolRun): Promise<ToolSet> {
+  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") {
@@ -227,26 +289,30 @@ export async function loadTools(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
+      guide: true,
     }),
     // 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.report]: reportTool,
+    [TOOL_NAMES.answer]: answerTool,
   };
 }