thursday-agent 0.1.2 → 0.3.0

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

@@ -1,14 +1,25 @@
 import { generateText, type ToolSet, tool } from "ai";
 import z from "zod";
+import { SEARCH } from "@/config";
 import type { TextModel } from "@/features/ai/model";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
+import { EXA_API_KEY } from "@/features/config/config.const";
+import { readConfig } from "@/features/config/config.query";
 import type { Sandbox } from "@/lib/sandbox";
+import { clip, errorToString } from "@/lib/utils";
 
 /**
- * Web search as one tool with one name. The provider-native search runs one call down on a
- * search-capable model (`resolveSearchModel`), never in the bot's own request: a provider tool
- * cannot be handed to another provider's model, names and result shapes differ per provider,
- * and Google cannot send its search tool alongside function tools in one request.
+ * Web search as one tool with one name, served whichever way this install can.
+ *
+ * Exa when its key is set: one HTTP call, the pages themselves back. Otherwise the run's own
+ * model's native search, one call down on a searcher that sees nothing but the question — a
+ * provider tool cannot be handed to another provider's model, names and result shapes differ
+ * per provider, and Google cannot send its search tool alongside function tools in one request.
+ *
+ * A run whose model has no search of its own (the gateway) and no Exa key gets no search tool:
+ * it goes to the browser. Borrowing whichever provider had a key meant a second model call on a
+ * model nobody picked, which is where the minute-long searches came from — search is one lookup
+ * or it is a job, and a job is what the browser already is.
  */
 
 /** System prompt for the model one call down; it sees nothing but the question. */
@@ -17,57 +28,135 @@ what supports it. Say plainly what you could not find or confirm — do not fill
 the gap with a guess. Every number carries the date you saw it. Be brief: this
 is read by another model, not by a person.`;
 
-/** How many sources are worth carrying back. Past this it is noise. */
-const SOURCE_LIMIT = 8;
+const DESCRIPTION =
+  "Search the web and get back what the pages say, with their links. For a fact, a price, a date, what a page says. Not for a page that has to be clicked, filled, or signed into — that is the browser.";
 
-/** Absent when no provider that searches has a key (features/ai/model); the bot goes to the browser instead. */
-export const createSearchTool = (
-  search: TextModel | null,
+const QUERY = z
+  .string()
+  .describe(
+    "What you want to know, as one full question. Put the place and the time in when they matter — the searcher sees nothing but this line.",
+  );
+
+/** Exa's own endpoint. One POST: the whole point of this path is that it is not a model call. */
+const EXA_URL = "https://api.exa.ai/search";
+
+/** One hit as Exa sends it; only the fields that are read back are named. */
+type ExaHit = {
+  title?: string | null;
+  url?: string | null;
+  publishedDate?: string | null;
+  text?: string | null;
+};
+
+async function exaSearch(
+  apiKey: string,
+  query: string,
+  signal: AbortSignal,
+): Promise<string> {
+  const response = await fetch(EXA_URL, {
+    method: "POST",
+    signal,
+    headers: { "content-type": "application/json", "x-api-key": apiKey },
+    body: JSON.stringify({
+      query,
+      type: "auto",
+      numResults: SEARCH.sources,
+      contents: {
+        text: { maxCharacters: SEARCH.excerptChars },
+        // A page Exa has not cached is fetched now, but one slow site does not hold the search
+        livecrawl: "fallback",
+        livecrawlTimeout: 5_000,
+      },
+    }),
+  });
+  // Exa's own words: only it can say whether the key is wrong, spent or rate-limited
+  if (!response.ok)
+    return `Exa answered ${response.status}: ${clip((await response.text()).trim(), 200)}`;
+
+  const body = (await response.json()) as { results?: ExaHit[] };
+  const hits = body.results ?? [];
+  if (!hits.length)
+    return "Nothing came back for that. Try other words, or open a page in the browser.";
+
+  return hits
+    .map((hit) => {
+      const head = [hit.title?.trim(), hit.url?.trim()]
+        .filter(Boolean)
+        .join(" — ");
+      const date = hit.publishedDate?.slice(0, 10);
+      return [date ? `${head} · ${date}` : head, hit.text?.trim()]
+        .filter(Boolean)
+        .join("\n");
+    })
+    .join("\n\n");
+}
+
+async function askSearcher(
+  searcher: { model: TextModel["model"]; tools: ToolSet },
+  query: string,
+  signal: AbortSignal,
+): Promise<string> {
+  const { text, sources } = await generateText({
+    model: searcher.model,
+    tools: searcher.tools,
+    system: SEARCHER,
+    prompt: query,
+    abortSignal: signal,
+  });
+
+  const urls = [
+    ...new Set(
+      sources.flatMap((source) =>
+        source.sourceType === "url"
+          ? [source.title ? `${source.title} — ${source.url}` : source.url]
+          : [],
+      ),
+    ),
+  ].slice(0, SEARCH.sources);
+
+  return [text.trim(), urls.length ? `Sources:\n${urls.join("\n")}` : ""]
+    .filter(Boolean)
+    .join("\n\n");
+}
+
+/** Absent when there is neither an Exa key nor a run model that searches; the bot goes to the browser instead. */
+export const createSearchTool = async (
+  run: TextModel | null | undefined,
   sandbox: Sandbox,
-): ToolSet => {
-  if (!search?.searchTools) return {};
-  const { model, searchTools } = search;
+): Promise<ToolSet> => {
+  const exaKey = await readConfig(EXA_API_KEY);
+  // This run's own model, never a borrowed one. A const so the closure below keeps the narrowing
+  const native = run?.searchTools
+    ? { model: run.model, tools: run.searchTools }
+    : null;
+
+  const search = exaKey
+    ? (query: string, signal: AbortSignal) => exaSearch(exaKey, query, signal)
+    : native
+      ? (query: string, signal: AbortSignal) =>
+          askSearcher(native, query, signal)
+      : null;
+  if (!search) return {};
 
   return {
     [TOOL_NAMES.web_search]: tool({
-      description:
-        "Search the web and get back an answer with its sources. For a fact, a price, a date, what a page says. Not for a page that has to be clicked, filled, or signed into — that is the browser.",
-      inputSchema: z.object({
-        query: z
-          .string()
-          .describe(
-            "What you want to know, as one full question. Put the place and the time in when they matter — the searcher sees nothing but this line.",
-          ),
-      }),
+      description: DESCRIPTION,
+      inputSchema: z.object({ query: QUERY }),
       execute: async ({ query }, { abortSignal }) => {
-        const { text, sources } = await generateText({
-          model,
-          tools: searchTools,
-          system: SEARCHER,
-          prompt: query,
-          abortSignal,
+        const deadline = AbortSignal.timeout(SEARCH.timeoutMs);
+        const signal = abortSignal
+          ? AbortSignal.any([abortSignal, deadline])
+          : deadline;
+
+        const answer = await search(query, signal).catch((cause: unknown) => {
+          // The job itself was cancelled: that is not a result to hand back
+          if (abortSignal?.aborted) throw cause;
+          if (deadline.aborted)
+            return `The search did not come back in ${SEARCH.timeoutMs / 1000}s. Ask something narrower, or open the page in the browser.`;
+          return `Search failed: ${errorToString(cause)}. The browser is the other way in.`;
         });
 
-        const urls = [
-          ...new Set(
-            sources.flatMap((source) =>
-              source.sourceType === "url"
-                ? [
-                    source.title
-                      ? `${source.title} — ${source.url}`
-                      : source.url,
-                  ]
-                : [],
-            ),
-          ),
-        ].slice(0, SOURCE_LIMIT);
-
-        return sandbox.fold(
-          [text.trim(), urls.length ? `Sources:\n${urls.join("\n")}` : ""]
-            .filter(Boolean)
-            .join("\n\n"),
-          "web-search",
-        );
+        return sandbox.fold(answer, "web-search");
       },
     }),
   };

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

@@ -118,7 +118,7 @@ const imageTool = async (): Promise<StudioTool | null> => {
         ),
       aspectRatio: z
         .enum(RATIOS)
-        .nullable()
+        .nullish()
         .describe("Aspect ratio. Null for square."),
     }),
     execute: async ({ prompt, aspectRatio }, { sandbox, abortSignal }) => {
@@ -161,11 +161,11 @@ const speechTool = async (): Promise<StudioTool | null> => {
         ),
       voice: z
         .string()
-        .nullable()
+        .nullish()
         .describe("A voice name the provider knows. Null for its default."),
       instructions: z
         .string()
-        .nullable()
+        .nullish()
         .describe(
           'How to read it — "slowly", "warm", "like a news anchor". Null for plain.',
         ),
@@ -259,14 +259,14 @@ const videoTool = async (): Promise<StudioTool | null> => {
         ),
       aspectRatio: z
         .enum(["16:9", "9:16"])
-        .nullable()
+        .nullish()
         .describe("Aspect ratio. Null for 16:9."),
       seconds: z
         .number()
         .int()
         .min(2)
         .max(10)
-        .nullable()
+        .nullish()
         .describe(
           "Length in seconds, 2 to 10. Null for the provider's default.",
         ),

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

@@ -8,6 +8,7 @@ export const TOOL_NAMES = {
   memory_remember: "memory_remember",
   memory_forget: "memory_forget",
   memory_show: "memory_show",
+  memory_conversation: "memory_conversation",
 
   bash: "bash",
   write_file: "write_file",
@@ -24,11 +25,9 @@ export const TOOL_NAMES = {
   ask_bot: "ask_bot",
   ask_thursday: "ask_thursday",
   ask_back: "ask_back",
-  report: "report",
+  answer: "answer",
 
   end_call: "end_call",
-
-  tidy_done: "tidy_done",
 } as const;
 
 /**

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

@@ -1,6 +1,7 @@
 import { relative } from "node:path";
 import { type ToolSet, tool } from "ai";
 import z from "zod";
+import { EXEC_TIMEOUT_MS } from "@/config";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
 import { writeRefusal } from "@/features/workspace/workspace";
 import type { Sandbox } from "@/lib/sandbox";
@@ -15,6 +16,8 @@ export const createWorkspaceTools = (
     write: boolean;
     /** Per-run environment for `bash` (a job's browser session). */
     env?: Record<string, string>;
+    /** Attach the shell guide to this run's first `bash` result (bots only). */
+    guide?: boolean;
   },
 ): ToolSet => {
   /** Fold absolute sandbox paths against cwd; they still resolve when handed back. */
@@ -23,20 +26,30 @@ export const createWorkspaceTools = (
     return r && !r.startsWith("..") ? r : p;
   };
 
+  // The tool set is built per run, so one guide per run lives in this closure.
+  let owed = options.guide === true;
+
   const bash = tool({
     description: "Run a bash command.",
     inputSchema: z.object({
       command: z.string(),
       description: z
         .string()
-        .nullable()
+        .nullish()
         .describe(
           "One short line for the user: what this command does and why. Shown on their screen while it runs — not a restatement of the command.",
         ),
     }),
     // The only tool here long-running enough to be cancelled.
-    execute: ({ command }, { abortSignal }) =>
-      sandbox.exec(command, { signal: abortSignal, env: options.env }),
+    execute: async ({ command }, { abortSignal }) => {
+      const result = await sandbox.exec(command, {
+        signal: abortSignal,
+        env: options.env,
+      });
+      if (!owed) return result;
+      owed = false;
+      return { ...result, guide: SHELL_GUIDE };
+    },
   });
 
   if (!options.write) return { [TOOL_NAMES.bash]: bash };
@@ -53,7 +66,7 @@ export const createWorkspaceTools = (
       content: z.string(),
       description: z
         .string()
-        .nullable()
+        .nullish()
         .describe(
           "One short line for the user: what this file is. Shown on their screen next to the path.",
         ),
@@ -69,3 +82,19 @@ export const createWorkspaceTools = (
 
   return { [TOOL_NAMES.bash]: bash, [TOOL_NAMES.write_file]: writeFile };
 };
+
+/**
+ * How this shell differs from a terminal, attached to a run's first `bash`
+ * result and never again. Each line is a way a job is lost for minutes and
+ * none can be found out from a command's output: state that silently does not
+ * carry, a question nobody will answer, a variable that was removed rather
+ * than never set. What this machine *has* is not here — that decides the first
+ * command, so it is in the prompt (prompts/bot.prompt environment).
+ */
+const SHELL_GUIDE = `## The shell here
+
+Every command is a new shell: \`cd\`, exported variables and an activated venv are gone by the next one — chain what depends on the last step into a single command.
+
+Nothing is watching it. A command that stops to ask never gets an answer and is killed after ${EXEC_TIMEOUT_MS / 1000}s, so pass the flag that skips the question (\`-y\`, \`--yes\`, \`--no-input\`), and send anything genuinely long to the background with its output redirected to a file.
+
+Keys are not in the environment: every variable named like a key, a token or a secret is removed before the shell starts. An empty one is not an unset one — say which it was, and ask for what a command needs.`;

package/features/bot/bot.action.ts

@@ -4,11 +4,23 @@ import { z } from "zod";
 import { textModelProviderSchema } from "@/features/ai/model.schema";
 import { serverAction } from "@/lib/protocol/server-action";
 import { publicError } from "@/lib/public-error";
-import { createBot, deleteBot, findBot, updateBot } from "./bot.query";
-import { answerTask, cancelTask, removeTask, startTask } from "./bot.runner";
+import {
+  createBot,
+  deleteBot,
+  findBot,
+  updateBot,
+  writeBotMemoryOn,
+} from "./bot.query";
+import {
+  answerTask,
+  cancelTask,
+  removeFinishedTasks,
+  removeTask,
+  startTask,
+} from "./bot.runner";
 import { BotFormSchema, botIconSchema } from "./bot.schema";
 import { findBotSeed, rollSeedColors } from "./bot.seed";
-import { deleteFinishedTasks, markReported, resolveTask } from "./task.query";
+import { markSeen, resolveTask } from "./task.query";
 
 export const createBotAction = serverAction(async (input: unknown) => {
   const form = BotFormSchema.parse(input);
@@ -67,6 +79,11 @@ export const deleteBotAction = serverAction(async (name: string) => {
   if (!(await deleteBot(name))) publicError("Bot not found");
 });
 
+/** Switched off, no bot is shown its own memory. What is already written stays on disk. */
+export const setBotMemoryOnAction = serverAction(async (on: unknown) => {
+  await writeBotMemoryOn(on === true);
+});
+
 // Tasks are opened by the `delegate` tool during a call, or here when the user
 // hands one over from the screen. Each returns at once, the run itself continues
 // in bot.runner behind `after()`.
@@ -115,9 +132,9 @@ export const cancelTaskAction = serverAction(async (ref: string) => {
   return { id: task.id, label: task.label, status: "cancelled" as const };
 });
 
-/** Marks tasks as relayed to the call, clearing their inbox dot. Batched because a call opening relays everything pending at once. */
-export const markReportedAction = serverAction(async (ids: string[]) => {
-  await markReported(ids.filter((id) => typeof id === "string" && id));
+/** Marks endings as had by the user: relayed on a call, or on a task list they opened. Batched, since both reach many at once. */
+export const markSeenAction = serverAction(async (ids: string[]) => {
+  await markSeen(ids.filter((id) => typeof id === "string" && id));
 });
 
 export const deleteTaskAction = serverAction(async (id: string) => {
@@ -126,5 +143,5 @@ export const deleteTaskAction = serverAction(async (id: string) => {
 
 /** Empties the log of what is over. Running and waiting jobs are not touched. */
 export const clearFinishedTasksAction = serverAction(async () => {
-  return { removed: await deleteFinishedTasks() };
+  return { removed: await removeFinishedTasks() };
 });

package/features/bot/bot.memory.ts

@@ -0,0 +1,89 @@
+import { open, readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { BOT_MEMORY_LISTED } from "@/config";
+import { botFolder, WORKSPACE } from "@/features/workspace/workspace";
+import type { BotMemory, BotMemoryFile } from "./bot.schema";
+
+/**
+ * A bot's own memory: files it keeps in its folder, one topic each, written and read with
+ * its own shell. The disk is the only index — a file's first line is its listing line — so
+ * keeping something is one write, and no list can fall out of step with the files.
+ */
+
+/** Workspace-relative, the way a prompt names it (config PATHS.bots). */
+export const botMemoryFolder = (bot: string): string =>
+  `${botFolder(bot)}/memory`;
+
+/** Enough of a file to find its first line in; the rest is the bot's to open. */
+const HEAD_BYTES = 1024;
+
+/**
+ * Newest first. `limit` is how many are read for their first line: the prompt lists
+ * BOT_MEMORY_LISTED, the bot's page (Settings > Bots) as many as a Workspace folder shows.
+ */
+export async function listBotMemory(
+  bot: string,
+  limit = BOT_MEMORY_LISTED,
+): Promise<BotMemory> {
+  const folder = botMemoryFolder(bot);
+  const dir = join(WORKSPACE, folder);
+  const names = await readdir(dir).catch(() => []);
+  const found = await Promise.all(
+    names
+      .filter((name) => !name.startsWith("."))
+      .map(async (name) => {
+        const info = await stat(join(dir, name)).catch(() => null);
+        return info?.isFile()
+          ? { name, changed: info.mtimeMs, bytes: info.size }
+          : null;
+      }),
+  );
+  const files = found
+    .filter((file) => file !== null)
+    .sort((a, b) => b.changed - a.changed);
+  const entries = await Promise.all(
+    files.slice(0, limit).map(
+      async ({ name, changed, bytes }): Promise<BotMemoryFile> => ({
+        file: name,
+        path: `${folder}/${name}`,
+        line: await firstLine(join(dir, name)),
+        at: new Date(changed),
+        bytes,
+      }),
+    ),
+  );
+  return { folder, entries, total: files.length };
+}
+
+/**
+ * The line a file is listed by: its first, without a heading's `#`. A file that opens with
+ * frontmatter anyway — a shape models are trained on — is listed by its `description`, or by
+ * the first line after it.
+ */
+async function firstLine(path: string): Promise<string> {
+  const handle = await open(path, "r").catch(() => null);
+  if (!handle) return "";
+  try {
+    const head = Buffer.alloc(HEAD_BYTES);
+    const { bytesRead } = await handle.read(head, 0, HEAD_BYTES, 0);
+    const lines = head
+      .toString("utf8", 0, bytesRead)
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean);
+    if (lines[0] === "---") {
+      const said = lines.find((line) => line.startsWith("description:"));
+      if (said) {
+        return said
+          .slice("description:".length)
+          .trim()
+          .replace(/^["']|["']$/g, "");
+      }
+      const end = lines.indexOf("---", 1);
+      return end > 0 ? (lines[end + 1] ?? "").replace(/^#+\s*/, "") : "";
+    }
+    return (lines[0] ?? "").replace(/^#+\s*/, "");
+  } finally {
+    await handle.close();
+  }
+}

package/features/bot/bot.query.ts

@@ -7,10 +7,13 @@ import {
   taskTable,
 } from "@/database/tables";
 import type { TextModelProviderId } from "@/features/ai/model.schema";
+import { readConfig, writeConfig } from "@/features/config/config.query";
 import {
+  BOT_MEMORY_KEY,
   type BotForm,
   type BotIcon,
   DEFAULT_BOT,
+  isBotMemoryOn,
   type JobBot,
   type PinnedTool,
   pickedModel,
@@ -26,6 +29,8 @@ const asJobBot = (row: {
   /** Empty runs on the app default model (bot.run resolveModel). */
   provider: TextModelProviderId | null;
   model: string | null;
+  disabled: boolean;
+  compactAt: number | null;
 }): JobBot => ({
   name: row.name,
   description: row.description,
@@ -33,21 +38,36 @@ const asJobBot = (row: {
   icon: row.icon,
   provider: row.provider,
   model: row.model,
+  disabled: row.disabled,
+  compactAt: row.compactAt,
 });
 
-/** Who a job can go to: the user's bots, or DEFAULT_BOT when there are none. */
+/**
+ * Who a job can go to: the user's bots, or DEFAULT_BOT when there are none.
+ * Switched-off bots are left out here and nowhere else — this one read is what
+ * every prompt's roster and `delegate`'s list are built from, so off is off in
+ * all of them without a second rule to keep.
+ */
 export async function listJobBots(): Promise<JobBot[]> {
   const rows = await database
     .select()
     .from(botTable)
     .orderBy(botTable.createdAt);
 
-  return rows.length ? rows.map(asJobBot) : [DEFAULT_BOT];
+  // The fallback answers "no bots exist", never "every bot is off": switching
+  // them all off is a choice, and conjuring a worker would undo it.
+  return rows.length
+    ? rows.filter((row) => !row.disabled).map(asJobBot)
+    : [DEFAULT_BOT];
 }
 
 /**
- * The bot a job names. Exact name first, then case-insensitive only; no looser
- * matching. A miss returns null so `delegate` can list the roster instead.
+ * The bot a job names, switched off or not: a job already under way resumes
+ * through here, and refusing it would strand a thread the user can still answer.
+ * `delegate` is what checks `disabled`, because that is where a bot is picked.
+ *
+ * Exact name first, then case-insensitive only; no looser matching. A miss
+ * returns null so `delegate` can list the roster instead.
  */
 export async function findJobBot(name: string): Promise<JobBot | null> {
   const row = await findBot(name);
@@ -55,8 +75,14 @@ export async function findJobBot(name: string): Promise<JobBot | null> {
 
   // Case is not a different name: the spoken name arrives through a transcript
   const said = name.trim().toLowerCase();
-  const bots = await listJobBots();
-  return bots.find((bot) => bot.name.toLowerCase() === said) ?? null;
+  const [match] = await database
+    .select()
+    .from(botTable)
+    .where(eq(sql`lower(${botTable.name})`, said));
+  if (match) return asJobBot(match);
+
+  // The worker that exists when no row does; it has no row to match against
+  return DEFAULT_BOT.name.toLowerCase() === said ? DEFAULT_BOT : null;
 }
 
 /** Bots with their pinned tools and token totals: a set of queries plus grouping, not a join. */
@@ -112,6 +138,15 @@ export async function findAllBots() {
   }));
 }
 
+/** Whether bots keep their own memory at all (bot.schema BOT_MEMORY_KEY). */
+export async function readBotMemoryOn(): Promise<boolean> {
+  return isBotMemoryOn(await readConfig(BOT_MEMORY_KEY));
+}
+
+export async function writeBotMemoryOn(on: boolean): Promise<void> {
+  await writeConfig(BOT_MEMORY_KEY, on ? "on" : "off");
+}
+
 export async function findBot(name: string) {
   const [bot] = await database
     .select()