thursday-agent 0.1.2 → 0.3.0

package/app/api/events/app-event.server.ts

@@ -0,0 +1,45 @@
+import { BROWSER_GONE_MS } from "@/config";
+import { createEventBus, type EventBus } from "@/lib/protocol/events";
+import {
+  createEventStream,
+  type EventStream,
+} from "@/lib/protocol/events.server";
+import { createPresence, type Presence } from "@/lib/protocol/presence";
+import { type AppEvent, isSignal } from "./app-event";
+
+/**
+ * Server-side bus and the stream that carries it to the browser. Pinned on
+ * globalThis because next dev reloads this module while open streams still
+ * subscribe to the first bus.
+ */
+type Pinned = {
+  __appEvents?: EventBus<AppEvent>;
+  __appEventStream?: EventStream<AppEvent>;
+  __presence?: Presence;
+  __bootId?: string;
+};
+const pinned = globalThis as Pinned;
+
+export const appEvents: EventBus<AppEvent> = (pinned.__appEvents ??=
+  createEventBus<AppEvent>());
+
+/**
+ * Whether a browser is on the stream. The app stops what it is doing when the
+ * last one has been gone for BROWSER_GONE_MS; who stops what is wired at boot
+ * (instrumentation), not here.
+ */
+export const presence: Presence = (pinned.__presence ??=
+  createPresence(BROWSER_GONE_MS));
+
+/** Signals coalesce over 150ms; data events pass through. */
+export const appEventStream: EventStream<AppEvent> =
+  (pinned.__appEventStream ??= createEventStream(appEvents, {
+    coalesce: {
+      ms: 150,
+      keyOf: (event) => (isSignal(event) ? event.type : null),
+    },
+    onWatchers: presence.track,
+  }));
+
+/** Identifies this server process; changes on restart. */
+export const BOOT_ID: string = (pinned.__bootId ??= crypto.randomUUID());

package/app/api/events/app-event.ts

@@ -0,0 +1,42 @@
+/**
+ * Every event the server sends the browser. Two kinds: a signal carries no data
+ * and the receiver revalidates the matching GET; a data event is the value
+ * itself. A new signal must also be added to `SIGNALS` below.
+ */
+export type AppEvent =
+  /** Sent on connect. A changed `boot` means the server restarted; re-read everything. */
+  | { type: "hello"; boot: string }
+  /** Signal: a task changed (every write in bot.query). */
+  | { type: "tasks" }
+  /** Signal: a note or fact changed. */
+  | { type: "memory" }
+  /** Signal: a server was registered, removed, synced, or finished OAuth. */
+  | { type: "mcp" }
+  /** Signal: a sign-in was written away from the settings screen (ai/chatgpt's sign-in answer). */
+  | { type: "config" }
+  /** Data: show this note on screen, or hide it when null (memory.tool). */
+  | { type: "memory-view"; path: string | null }
+  /** Data: a finished job produced a document; `path` is workspace-relative. */
+  | { type: "artifact"; taskId: string; label: string; path: string };
+
+/** Union members carrying nothing but `type`. */
+type Signal<E = AppEvent> = E extends AppEvent
+  ? keyof E extends "type"
+    ? E["type"]
+    : never
+  : never;
+
+/**
+ * Signals are coalesced before sending (app-event.server). The `Record` type
+ * makes a signal missing here a compile error.
+ */
+export const SIGNALS: Record<Signal, true> = {
+  tasks: true,
+  memory: true,
+  mcp: true,
+  config: true,
+};
+
+export const isSignal = (
+  event: AppEvent,
+): event is Extract<AppEvent, { type: Signal }> => event.type in SIGNALS;

package/app/api/llm-model/catalog/route.ts

@@ -0,0 +1,12 @@
+import { readGatewayCatalog } from "@/features/ai/model";
+import type { GatewayModel } from "@/features/ai/model.schema";
+import { serverRoute } from "@/lib/protocol/server-route";
+
+/**
+ * Everything the gateway carries, every modality in one listing. It answers
+ * unauthenticated, so the shelf reads before a key is set; only running a model
+ * needs one. The answer is built in ai/model, where `callableRows` reads the same list.
+ */
+export const GET = serverRoute(
+  async (): Promise<GatewayModel[]> => readGatewayCatalog(),
+);

package/app/api/llm-model/credits/route.ts

@@ -0,0 +1,11 @@
+import { readGatewayCredits } from "@/features/ai/model";
+import type { GatewayCredits } from "@/features/ai/model.schema";
+import { serverRoute } from "@/lib/protocol/server-route";
+
+/**
+ * What is left on the gateway key, null when none is set. Read by the gateway's
+ * row in Settings › Keys and its key dialog; the answer is built in ai/model.
+ */
+export const GET = serverRoute(
+  async (): Promise<GatewayCredits | null> => readGatewayCredits(),
+);

package/app/api/llm-model/route.ts

@@ -0,0 +1,26 @@
+import { readChatGptPlan } from "@/features/ai/chatgpt";
+import {
+  type AiProvider,
+  TEXT_MODEL_PROVIDER_LIST,
+} from "@/features/ai/model.schema";
+import { readConfig } from "@/features/config/config.query";
+import { serverRoute } from "@/lib/protocol/server-route";
+
+/** Callable providers, whether each one's key is set, and the plan a sign-in is on. */
+export const GET = serverRoute(async () =>
+  Promise.all(
+    TEXT_MODEL_PROVIDER_LIST.map(
+      async (item): Promise<AiProvider> => ({
+        id: item.id,
+        label: item.label,
+        apiKeyName: item.apiKeyName,
+        suggestModels: item.suggestModels,
+        hasKey: Boolean(await readConfig(item.apiKeyName)),
+        ...(item.signIn && {
+          signIn: true as const,
+          plan: await readChatGptPlan(),
+        }),
+      }),
+    ),
+  ),
+);

package/app/api/llm-model/subscription/route.ts

@@ -0,0 +1,11 @@
+import { readChatGptUsage } from "@/features/ai/chatgpt";
+import type { SubscriptionUsage } from "@/features/ai/model.schema";
+import { serverRoute } from "@/lib/protocol/server-route";
+
+/**
+ * How much of the GPT Subscription plan is used, null when nobody is signed in. Read by its
+ * row in Settings › Keys and its sign-in dialog; the answer is built in ai/chatgpt.
+ */
+export const GET = serverRoute(
+  async (): Promise<SubscriptionUsage | null> => readChatGptUsage(),
+);

package/app/api/memory/edit/route.ts

@@ -0,0 +1,7 @@
+import { streamMemoryEdit } from "@/features/memory/memory.edit";
+import { serverRoute } from "@/lib/protocol/server-route";
+
+/** An edit from the memory screen, streamed as it runs (memory.edit). */
+export const POST = serverRoute(async (request) =>
+  streamMemoryEdit(await request.json(), request.signal),
+);

package/app/api/memory/route.ts

@@ -0,0 +1,21 @@
+import { findAllNotes, findNoteByPath } from "@/features/memory/memory.query";
+import { serverRoute } from "@/lib/protocol/server-route";
+import { publicError } from "@/lib/public-error";
+
+/**
+ * Read only; writes go through memory.action. One MemoryNote[] page, `?offset=`
+ * for the next. `?path=` returns one note: paths contain `/`, so not a segment.
+ */
+export const GET = serverRoute(async (request) => {
+  const params = new URL(request.url).searchParams;
+
+  const path = params.get("path");
+  if (path) {
+    const note = await findNoteByPath(path);
+    if (!note) publicError("Note not found");
+    return note;
+  }
+
+  const offset = Number(params.get("offset") ?? 0);
+  return findAllNotes({ offset: Number.isFinite(offset) ? offset : 0 });
+});

package/app/api/query-key.ts

@@ -0,0 +1,159 @@
+/**
+ * Every endpoint the browser reads. Keys double as SWR cache keys; `revalidate`
+ * matches by url prefix, so invalidating `queryKey.memory` also refreshes
+ * `queryKey.notePath(path)`. Writes go through server actions, not here.
+ */
+/** Encodes per segment, keeping the path's `/`. */
+const encodePath = (path: string) =>
+  path.split("/").map(encodeURIComponent).join("/");
+
+/**
+ * Inverse of encodePath for catch-all segments. No decoding: Next already
+ * decodes segments, and decoding again throws on names containing `%`.
+ */
+export const decodePath = (segments: string[]) => segments.join("/");
+
+export const queryKey = {
+  /** MemoryNote[] first page: pinned first, then by warmth */
+  memory: "/api/memory",
+  /** Next page; `offset` is the count received so far */
+  memoryPage: (offset: number) => ({
+    url: "/api/memory",
+    query: { offset: offset || null },
+  }),
+  /** One note with all facts, by path. Paths contain `/`, so it is a query, not a
+   *  segment: pass the hook null instead of building this key when closed. */
+  notePath: (path: string) => ({ url: "/api/memory", query: { path } }),
+
+  /** MCPServerSummary[] with tool counts, no tools */
+  mcp: "/api/mcp",
+  /** MCPServer, one server with its tools */
+  mcpServer: (name: string | null) => ({
+    url: "/api/mcp",
+    pathVariable: [name],
+  }),
+
+  /** Every MCP tool across servers, flat */
+  mcpTools: "/api/mcp/tools",
+
+  /** SkillSummary[], custom first */
+  skills: "/api/skills",
+  /**
+   * SkillNode: a folder listing or a file's text inside a skill.
+   * `path` is relative to the skill folder; "" is the skill itself.
+   */
+  skillNode: (source: string | null, dir: string | null, path: string) => ({
+    url: "/api/skills",
+    pathVariable: [source, dir],
+    query: { path },
+  }),
+
+  /**
+   * Bot[]. `tasks` and `taskHistory` sit under this prefix, so editing a bot
+   * also revalidates the inbox and loaded history pages.
+   */
+  bot: "/api/bot",
+
+  /** boolean: whether bots keep their own memory (Settings > Bots) */
+  botMemory: "/api/bot/memory",
+  /** BotMemory: one bot's own memory files, newest first (Settings > Bots) */
+  botMemoryFiles: (bot: string) => ({
+    url: "/api/bot/memory/files",
+    query: { bot },
+  }),
+
+  /**
+   * Inbox: Task[] newest first with threads, everything running or asking plus
+   * the most recent finished few. Read by use-thursday only; the `tasks` signal
+   * triggers revalidation, with a 30s poll as fallback.
+   */
+  tasks: "/api/bot/task",
+  /**
+   * History page: Task[] newest first. `before` is the last page's final
+   * updatedAt (ISO), null for the first page.
+   */
+  taskHistory: (before: string | null) => ({
+    url: "/api/bot/task",
+    query: { history: 1, before },
+  }),
+  /** ResultPart[]: the full result of one tool call; lists carry only a few lines. */
+  toolResult: (taskId: string | null, callId: string | null) => ({
+    url: "/api/bot/task",
+    pathVariable: [taskId],
+    query: { call: callId },
+  }),
+  /**
+   * WorkspaceFolder: one folder's rows, and nothing below them. The bare key
+   * is the root, so invalidating it refreshes every folder.
+   */
+  workspace: "/api/workspace",
+  workspaceFolder: (path: string, rows: number) => ({
+    url: "/api/workspace",
+    query: { path: path || null, rows },
+  }),
+
+  /**
+   * ArtifactShelf: the top of `artifacts/`, one row per artifact.
+   * `artifactSet` opens one of those rows. The bare key is the menu, so
+   * invalidating it refreshes an open set too.
+   */
+  artifacts: "/api/artifact",
+  artifactShelf: (rows: number) => ({
+    url: "/api/artifact",
+    query: { rows },
+  }),
+  artifactSet: (name: string, rows: number) => ({
+    url: "/api/artifact",
+    query: { set: name, rows },
+  }),
+
+  /** Raw workspace file, no Result envelope; for iframe, img and fetch, not SWR. */
+  file: (path: string) => `/api/file/${encodePath(path)}`,
+  /** File viewer page (new tab): md rendered, html and pdf framed */
+  fileView: (path: string) => `/artifact/${encodePath(path)}`,
+
+  /**
+   * Server-sent events, not a read; only app-event.client's `AppEventSource`
+   * opens it. The payloads are the AppEvent union in app/api/events/app-event.ts.
+   */
+  events: "/api/events",
+
+  /** ConfigStatus[]: which declared config keys are set; values stay on the server */
+  config: "/api/config",
+
+  /**
+   * CallRecord[] page, newest call first, turns in speaking order; pages count
+   * calls (CALL_HISTORY_PAGE). `before` is the oldest call's `startedAt` (ISO)
+   * on the previous page, null for the first. Calls with no turns are omitted.
+   */
+  callHistory: (before: string | null) => ({
+    url: "/api/thursday/call",
+    query: { before },
+  }),
+
+  /** boolean: whether the call may read a skill itself (Settings › Thursday) */
+  callSkills: "/api/thursday/skills",
+
+  /**
+   * POST, not a read; the one endpoint here SWR never touches. Body is
+   * {toolCallId, callId, name, input}; one JSON Result per call, abortable.
+   */
+  toolCall: "/api/thursday/tool-call",
+  /** POST, an edit from the memory screen, streamed as it runs (memory.edit). */
+  memoryEdit: "/api/memory/edit",
+
+  /** Providers this app can call and whether each key is set */
+  llmModel: "/api/llm-model",
+  /** Models reachable with the AI Gateway key; gateway only */
+  modelCatalog: "/api/llm-model/catalog",
+  /**
+   * GatewayCredits | null: what is left on the gateway key, null without one.
+   * Under `llmModel`, so the key dialog's revalidate re-reads it after a save.
+   */
+  gatewayCredits: "/api/llm-model/credits",
+  /**
+   * SubscriptionUsage | null: how much of the GPT Subscription plan is used, null when
+   * signed out. Under `llmModel`, so signing in or out re-reads it.
+   */
+  subscriptionUsage: "/api/llm-model/subscription",
+} as const;

package/app/api/thursday/tool-call/route.ts

@@ -0,0 +1,67 @@
+import { asSchema } from "ai";
+import z from "zod";
+import { loadTools } from "@/features/ai/load-tools";
+import { modelErrorToString } from "@/features/ai/model";
+import { serverRoute } from "@/lib/protocol/server-route";
+import { publicError } from "@/lib/public-error";
+
+/**
+ * Executes a tool call from the voice session. The page forwards what the model
+ * asked for; bots never come through here (they call `execute` directly).
+ * A route rather than a server action because actions run serially per client
+ * and one turn may call two tools at once. One POST, one JSON, no streaming;
+ * hanging up aborts the fetch and the signal reaches the tool.
+ */
+
+const ToolCallSchema = z.object({
+  toolCallId: z.string().min(1),
+  /** The call this came from; `delegate` attaches the job to it. */
+  callId: z.string().nullish(),
+  name: z.string().min(1),
+  input: z.unknown().optional(),
+});
+
+const isAsyncIterable = (value: unknown): value is AsyncIterable<unknown> =>
+  typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+
+/** For streaming tools the last chunk is the answer. */
+async function drain(output: unknown): Promise<unknown> {
+  if (!isAsyncIterable(output)) return output;
+  let latest: unknown;
+  for await (const part of output) latest = part;
+  return latest;
+}
+
+export const POST = serverRoute(async (request) => {
+  const { toolCallId, callId, name, input } = ToolCallSchema.parse(
+    await request.json(),
+  );
+
+  // The set the voice runtime may run, not whatever the body names.
+  const tools = await loadTools({ target: "thursday", callId });
+  const tool = tools[name];
+  if (!tool) publicError(`There is no tool called "${name}".`);
+
+  // end_call has no execute by design: the page owns the call and intercepts it.
+  if (!tool.execute) publicError(`"${name}" is handled by the page, not here.`);
+
+  const parsed = await asSchema(tool.inputSchema).validate?.(input ?? {});
+  if (parsed && !parsed.success) {
+    publicError(
+      `"${name}" got arguments that do not fit: ${parsed.error.message}`,
+    );
+  }
+
+  try {
+    const output = await tool.execute(parsed?.value ?? input ?? {}, {
+      toolCallId,
+      messages: [],
+      context: undefined,
+      abortSignal: request.signal,
+    });
+    return { output: await drain(output) };
+  } catch (cause) {
+    // A tool failure is a line the model reads and recovers from, not a masked server error.
+    publicError(`"${name}" failed: ${modelErrorToString(cause)}`);
+  }
+});

package/bin/thursday.mjs

@@ -138,6 +138,9 @@ const child = spawn(process.execPath, [join(APP, "server.js")], {
     // This machine only. A voice agent with a shell is not a thing to expose.
     HOSTNAME: process.env.HOSTNAME || "127.0.0.1",
     NODE_ENV: "production",
+    // The server parks running jobs on a stop before it exits (instrumentation);
+    // without this, Next exits on the signal first
+    NEXT_MANUAL_SIG_HANDLE: "true",
   },
 });
 

package/components/ui/button-group.tsx

@@ -0,0 +1,45 @@
+"use client";
+
+import { cva, type VariantProps } from "class-variance-authority";
+import type { ComponentProps } from "react";
+import { cn } from "@/lib/utils";
+
+/**
+ * Joins plain `<Button>`s into one control (outer corners only, shared 1px
+ * seams). Nested groups get a gap between them. For a selected value use
+ * `Segmented`.
+ */
+const buttonGroupVariants = cva(
+  "flex w-fit items-stretch has-[>[data-slot=button-group]]:gap-1.5 [&>*]:relative [&>*]:focus-visible:z-10",
+  {
+    variants: {
+      orientation: {
+        horizontal:
+          "[&>*:not(:first-child)]:rounded-l-none [&>*:not(:first-child)]:border-l-0 [&>*:not(:last-child)]:rounded-r-none",
+        vertical:
+          "flex-col [&>*:not(:first-child)]:rounded-t-none [&>*:not(:first-child)]:border-t-0 [&>*:not(:last-child)]:rounded-b-none",
+      },
+    },
+    defaultVariants: {
+      orientation: "horizontal",
+    },
+  },
+);
+
+function ButtonGroup({
+  className,
+  orientation = "horizontal",
+  ...props
+}: ComponentProps<"div"> & VariantProps<typeof buttonGroupVariants>) {
+  return (
+    <div
+      data-slot="button-group"
+      data-orientation={orientation}
+      role="group"
+      className={cn(buttonGroupVariants({ orientation }), className)}
+      {...props}
+    />
+  );
+}
+
+export { ButtonGroup, buttonGroupVariants };