thursday-agent 0.2.0 → 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/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,13 +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",
-
-  update_notes: "update_notes",
 } as const;
 
 /**

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

@@ -1,9 +1,10 @@
 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 { EXEC_TIMEOUT_MS, type Sandbox } from "@/lib/sandbox";
+import type { Sandbox } from "@/lib/sandbox";
 
 /**
  * Shell access, plus `write_file` for bots: multi-line files through a

package/features/bot/bot.action.ts

@@ -5,12 +5,11 @@ import { textModelProviderSchema } from "@/features/ai/model.schema";
 import { serverAction } from "@/lib/protocol/server-action";
 import { publicError } from "@/lib/public-error";
 import {
-  clearBotNote,
   createBot,
   deleteBot,
   findBot,
   updateBot,
-  writeBotNotesOn,
+  writeBotMemoryOn,
 } from "./bot.query";
 import {
   answerTask,
@@ -21,7 +20,7 @@ import {
 } from "./bot.runner";
 import { BotFormSchema, botIconSchema } from "./bot.schema";
 import { findBotSeed, rollSeedColors } from "./bot.seed";
-import { markReported, resolveTask } from "./task.query";
+import { markSeen, resolveTask } from "./task.query";
 
 export const createBotAction = serverAction(async (input: unknown) => {
   const form = BotFormSchema.parse(input);
@@ -80,18 +79,9 @@ export const deleteBotAction = serverAction(async (name: string) => {
   if (!(await deleteBot(name))) publicError("Bot not found");
 });
 
-/**
- * Throws away what a bot wrote about itself. The only human touch on notes:
- * they are never edited here, because a line the user typed would come back
- * rewritten by the bot's next report.
- */
-export const clearBotNoteAction = serverAction(async (name: string) => {
-  await clearBotNote(name);
-});
-
-/** Switched off, no bot writes to its own instructions and none is shown one. What is already written stays. */
-export const setBotNotesOnAction = serverAction(async (on: unknown) => {
-  await writeBotNotesOn(on === true);
+/** 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
@@ -142,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) => {

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

@@ -1,9 +1,7 @@
 import { eq, inArray, sql } from "drizzle-orm";
-import { BOT_NOTES } from "@/config";
 import { database } from "@/database/db";
 import {
   botMcpToolTable,
-  botNoteTable,
   botTable,
   mcpToolTable,
   taskTable,
@@ -11,11 +9,11 @@ import {
 import type { TextModelProviderId } from "@/features/ai/model.schema";
 import { readConfig, writeConfig } from "@/features/config/config.query";
 import {
-  BOT_NOTES_KEY,
+  BOT_MEMORY_KEY,
   type BotForm,
   type BotIcon,
   DEFAULT_BOT,
-  isBotNotesOn,
+  isBotMemoryOn,
   type JobBot,
   type PinnedTool,
   pickedModel,
@@ -31,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,
@@ -38,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);
@@ -60,13 +75,19 @@ 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. */
 export async function findAllBots() {
-  const [bots, pins, spent, notes] = await Promise.all([
+  const [bots, pins, spent] = await Promise.all([
     database.select().from(botTable).orderBy(botTable.createdAt),
     database
       .select({
@@ -88,7 +109,6 @@ export async function findAllBots() {
       })
       .from(taskTable)
       .groupBy(taskTable.bot),
-    database.select().from(botNoteTable),
   ]);
 
   const byBot = new Map<string, PinnedTool[]>();
@@ -110,59 +130,21 @@ export async function findAllBots() {
         : [[row.bot, new Date(Number(row.lastJobAt) * 1000)] as const],
     ),
   );
-  const noteOf = new Map(notes.map((row) => [row.bot, row]));
   return bots.map((bot) => ({
     ...bot,
     tools: byBot.get(bot.name) ?? [],
     tokens: tokensOf.get(bot.name) ?? { input: 0, output: 0 },
     lastJobAt: lastJobOf.get(bot.name) ?? null,
-    note: noteOf.get(bot.name)?.text ?? null,
-    noteAt: noteOf.get(bot.name)?.updatedAt ?? null,
   }));
 }
 
-// A bot's own notes. Nothing here belongs to a job: the row survives every job
-// the bot runs and is read back into its next prompt (ai/prompts/bot.prompt).
-
-/** What this bot has written to itself. Keyed by name, so DEFAULT_BOT has one too. */
-export async function readBotNote(bot: string): Promise<string | null> {
-  const [row] = await database
-    .select({ text: botNoteTable.text })
-    .from(botNoteTable)
-    .where(eq(botNoteTable.bot, bot));
-  return row?.text ?? null;
-}
-
-/**
- * The whole block, as the pass rewrote it (bot.notes). Cut rather than refused: the schema
- * already caps it, and a run that gets this far has handed its report back. Empty clears it.
- */
-export async function writeBotNote(bot: string, text: string): Promise<void> {
-  const next = text.trim().slice(0, BOT_NOTES.chars).trim();
-  if (!next) return clearBotNote(bot);
-
-  const updatedAt = new Date();
-  await database
-    .insert(botNoteTable)
-    .values({ bot, text: next, updatedAt })
-    .onConflictDoUpdate({
-      target: botNoteTable.bot,
-      set: { text: next, updatedAt },
-    });
-}
-
-/** Whether any bot keeps its own instructions at all (bot.schema BOT_NOTES_KEY). */
-export async function readBotNotesOn(): Promise<boolean> {
-  return isBotNotesOn(await readConfig(BOT_NOTES_KEY));
-}
-
-export async function writeBotNotesOn(on: boolean): Promise<void> {
-  await writeConfig(BOT_NOTES_KEY, on ? "on" : "off");
+/** 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));
 }
 
-/** The one thing the user does to notes: throw them away when a bot has learned something wrong. */
-export async function clearBotNote(bot: string): Promise<void> {
-  await database.delete(botNoteTable).where(eq(botNoteTable.bot, bot));
+export async function writeBotMemoryOn(on: boolean): Promise<void> {
+  await writeConfig(BOT_MEMORY_KEY, on ? "on" : "off");
 }
 
 export async function findBot(name: string) {
@@ -228,7 +210,5 @@ export async function deleteBot(name: string) {
     .delete(botTable)
     .where(eq(botTable.name, name))
     .returning({ name: botTable.name });
-  // Notes are keyed by name with no foreign key, so nothing cascades for them.
-  await clearBotNote(name);
   return removed.length > 0;
 }