thursday-agent 0.4.0 → 0.6.0

package/features/thursday/thursday.action.ts

@@ -2,58 +2,43 @@
 
 import { asSchema } from "ai";
 import z from "zod";
+import { LIVE_PROVIDER } from "@/features/ai/live.schema";
 import { loadTools } from "@/features/ai/load-tools";
-import {
-  SPEACH_MODEL_PROVIDER_LIST,
-  SPEACH_MODEL_PROVIDERS,
-  type SpeachModelRef,
-} from "@/features/ai/model.schema";
+import { loadLivePrompt } from "@/features/ai/prompts/live.prompt";
 import { loadThursdayPrompt } from "@/features/ai/prompts/thursday.prompt";
-import { removeTask } from "@/features/bot/bot.runner";
-import { listAllTaskIds } from "@/features/bot/task.query";
+import { removeThread } from "@/features/bot/bot.runner";
+import { listAllThreadIds } from "@/features/bot/thread.query";
 import { readConfig } from "@/features/config/config.query";
 import { deleteAllNotes } from "@/features/memory/memory.query";
+import {
+  LIVE_MODEL,
+  LiveCloseSchema,
+  type ToolManifest,
+} from "@/lib/live/live.schema";
+import { acceptedReasoning, createLiveCall } from "@/lib/live/live.server";
 import { serverAction } from "@/lib/protocol/server-action";
 import { publicError } from "@/lib/public-error";
-import { issueClientSecret } from "@/lib/realtime/client-secret";
-import type { ToolManifest } from "@/lib/realtime/realtime.schema";
 import {
   deleteCall,
   deleteEndedCalls,
   endCall,
   insertCall,
+  saveThought,
   saveTurns,
   writeCallSkillsOn,
 } from "./thursday.query";
 import {
   type CallHandshake,
+  CallThoughtSchema,
   CallTurnSchema,
-  type ThursdaySettings,
   ThursdaySettingsSchema,
 } from "./thursday.schema";
 
 // Server actions run one at a time per client, so the recording actions stay
 // small: a tool call mid-sentence may be queued behind them.
 
-/** The picked model if its key still exists, else the first provider with a key. */
-async function resolveVoiceModel(
-  picked: ThursdaySettings["model"],
-): Promise<SpeachModelRef> {
-  if (
-    picked &&
-    (await readConfig(SPEACH_MODEL_PROVIDERS[picked.provider].apiKeyName))
-  ) {
-    return picked;
-  }
-
-  // Voice and model ids are provider-specific, so neither carries over.
-  for (const provider of SPEACH_MODEL_PROVIDER_LIST) {
-    if (await readConfig(provider.apiKeyName)) {
-      return { provider: provider.id, voice: null, model: null };
-    }
-  }
-  publicError("No voice key — calls run on one. Add one in Config.");
-}
+/** An offer with every ICE candidate gathered stays far below this. */
+const SDP_MAX_LENGTH = 65_536;
 
 /**
  * The same tool set /api/thursday/tool-call executes. Tools without `execute`
@@ -78,47 +63,67 @@ async function loadToolManifest(): Promise<ToolManifest[]> {
 }
 
 /**
- * Opens a call: inserts the row and returns the credential plus what to send
- * once connected. Settings live in the browser (thursday.store), so they arrive
- * as an argument and are parsed, not trusted.
+ * Opens a Live call from the browser's SDP offer. Both prompts, the tool manifest
+ * and the account key stay here; the browser gets the SDP answer, the call row
+ * and what it needs to draw and save the call. `calledBack` is the page placing it
+ * for waiting work rather than the user, which changes what she opens with.
  */
 export const openCallAction = serverAction(
-  async (settings: ThursdaySettings): Promise<CallHandshake> => {
+  async (
+    settings: unknown,
+    sdp: unknown,
+    calledBack?: unknown,
+  ): Promise<CallHandshake> => {
     const thursday = ThursdaySettingsSchema.parse(settings);
+    const offer = z.string().min(1).max(SDP_MAX_LENGTH).parse(sdp);
+    const apiKey = await readConfig(LIVE_PROVIDER.apiKeyName);
+    if (!apiKey) {
+      publicError(`No ${LIVE_PROVIDER.label} key — add one in Config.`);
+    }
 
-    const ref = await resolveVoiceModel(thursday.model);
-    const provider = SPEACH_MODEL_PROVIDERS[ref.provider];
-    const apiKey = await readConfig(provider.apiKeyName);
-    if (!apiKey) publicError(`No ${provider.label} key — add one in Config.`);
-
-    // Assembled per call, never cached: the prompt reads what earlier calls stored.
-    const [prompt, tools] = await Promise.all([
-      loadThursdayPrompt(thursday.systemPrompt, thursday.locale),
+    // Assembled per call, never cached: both prompts read what earlier calls stored.
+    const [voice, backend, tools, reasoning] = await Promise.all([
+      loadLivePrompt({
+        voicePrompt: thursday.voicePrompt,
+        webSearch: thursday.webSearch,
+        locale: thursday.locale,
+        calledBack: z.boolean().default(false).parse(calledBack),
+      }),
+      loadThursdayPrompt(thursday.backendPrompt),
       loadToolManifest(),
+      acceptedReasoning({
+        apiKey,
+        model: thursday.backendModel,
+        effort: thursday.reasoningEffort,
+      }),
     ]);
 
-    // Free-text model ids are not validated here; the provider rejects at issue time.
-    const model = ref.model ?? provider.models[0].id;
-    // Issue before insert: a rejected credential must not leave an open call row
-    // nobody can close.
-    const credential = await issueClientSecret({
-      provider: ref.provider,
+    // Connect before insert: a refused key or model must not leave an open row nobody can close.
+    // Free-text model ids are not checked here; the provider refuses them and says why.
+    const connection = await createLiveCall({
       apiKey,
-      model,
+      sdp: offer,
+      voice: thursday.voice,
+      instructions: voice.text,
+      input: voice.input,
+      backend: {
+        model: thursday.backendModel,
+        instructions: backend,
+        tools,
+        reasoning,
+        webSearch: thursday.webSearch,
+      },
+    });
+    const callId = await insertCall({
+      provider: LIVE_PROVIDER.id,
+      model: LIVE_MODEL,
+      backendModel: thursday.backendModel,
     });
-    const callId = await insertCall({ provider: ref.provider, model });
 
     return {
       callId,
-      provider: ref.provider,
-      credential,
-      session: {
-        model,
-        voice: ref.voice ?? provider.defaultVoice,
-        instructions: prompt.text,
-        tools,
-      },
-      opening: prompt.opening,
+      sdp: connection.transport.sdp,
+      opening: voice.opening,
     };
   },
 );
@@ -132,14 +137,35 @@ export const setCallSkillsAction = serverAction(async (on: unknown) => {
 });
 
 export const saveTurnsAction = serverAction(
-  async (callId: string, turns: unknown) => {
-    await saveTurns(callId, CallTurnSchema.array().min(1).parse(turns));
+  async (callId: unknown, turns: unknown) => {
+    await saveTurns(
+      z.string().min(1).parse(callId),
+      CallTurnSchema.array().min(1).parse(turns),
+    );
   },
 );
 
-export const endCallAction = serverAction(async (callId: string) => {
-  await endCall(callId);
-});
+export const saveThoughtAction = serverAction(
+  async (callId: unknown, thought: unknown) => {
+    await saveThought(
+      z.string().min(1).parse(callId),
+      CallThoughtSchema.parse(thought),
+    );
+  },
+);
+
+/**
+ * Ends the row. `close` is what `session.closed` confirmed; absent when the
+ * confirmation never came, which leaves the billed seconds unknown.
+ */
+export const endCallAction = serverAction(
+  async (callId: unknown, close?: unknown) => {
+    await endCall(
+      z.string().min(1).parse(callId),
+      LiveCloseSchema.nullish().parse(close),
+    );
+  },
+);
 
 /**
  * Deletes a call and its turns; the next call's prompt no longer includes it.
@@ -161,19 +187,19 @@ export const deleteEndedCallsAction = serverAction(async () =>
 
 /**
  * Wipes what the app has kept of its own use: every ended call and its turns,
- * every job and its thread, and every memory note. Keys, bots and connectors
+ * every thread and its messages, and every memory note. Keys, bots and connectors
  * stay — the set `pnpm reset` calls History.
  *
  * History is not one domain, so this reaches into three and each clears its own
- * rows. Live work is stopped before its row goes: `removeTask` aborts a running
+ * rows. Live work is stopped before its row goes: `removeThread` aborts a running
  * job and closes its shell.
  */
 export const resetHistoryAction = serverAction(async () => {
-  const taskIds = await listAllTaskIds();
-  for (const id of taskIds) await removeTask(id);
+  const threadIds = await listAllThreadIds();
+  for (const id of threadIds) await removeThread(id);
 
   const calls = await deleteEndedCalls();
   const notes = await deleteAllNotes();
 
-  return { calls, tasks: taskIds.length, notes };
+  return { calls, threads: threadIds.length, notes };
 });

package/features/thursday/thursday.query.ts

@@ -11,11 +11,17 @@ import {
 } from "drizzle-orm";
 import { CALL_HISTORY_PAGE } from "@/config";
 import { database } from "@/database/db";
-import { callMessageTable, callTable } from "@/database/tables";
-import { listCallJobs } from "@/features/bot/task.query";
+import {
+  callMessageTable,
+  callTable,
+  callThoughtTable,
+} from "@/database/tables";
+import { listCallJobs } from "@/features/bot/thread.query";
 import { readConfig, writeConfig } from "@/features/config/config.query";
+import type { LiveClose } from "@/lib/live/live.schema";
 import {
   type CallRecord,
+  type CallThought,
   type CallTurn,
   isSkillsOn,
   THURSDAY_KEYS,
@@ -35,7 +41,11 @@ export async function writeCallSkillsOn(on: boolean) {
   await writeConfig(THURSDAY_KEYS.skills, on ? "on" : "off");
 }
 
-export async function insertCall(input: { provider: string; model: string }) {
+export async function insertCall(input: {
+  provider: string;
+  model: string;
+  backendModel: string;
+}) {
   const [call] = await database
     .insert(callTable)
     .values({ id: crypto.randomUUID(), ...input })
@@ -43,11 +53,23 @@ export async function insertCall(input: { provider: string; model: string }) {
   return call.id;
 }
 
-/** Ends the call; false if it already ended, so end-of-call work runs once. */
-export async function endCall(id: string): Promise<boolean> {
+/**
+ * Ends the call; false if it already ended, so end-of-call work runs once.
+ * `close` is what the provider confirmed on `session.closed`; without it the
+ * row keeps null seconds, which reads as "never confirmed", not as zero.
+ */
+export async function endCall(
+  id: string,
+  close?: LiveClose | null,
+): Promise<boolean> {
   const ended = await database
     .update(callTable)
-    .set({ endedAt: new Date() })
+    .set({
+      endedAt: new Date(),
+      ...(close
+        ? { endedReason: close.reason, seconds: close.seconds ?? null }
+        : {}),
+    })
     .where(and(eq(callTable.id, id), isNull(callTable.endedAt)))
     .returning({ id: callTable.id });
   return ended.length > 0;
@@ -61,14 +83,28 @@ export async function saveTurns(callId: string, turns: CallTurn[]) {
   for (const turn of turns) {
     await database
       .insert(callMessageTable)
-      .values({ callId, ...turn })
+      .values({ callId, ...turn, fragments: turn.fragments ?? null })
       .onConflictDoUpdate({
         target: [callMessageTable.callId, callMessageTable.id],
-        set: { text: turn.text, role: turn.role, tool: turn.tool ?? null },
+        set: {
+          text: turn.text,
+          role: turn.role,
+          tool: turn.tool ?? null,
+          // A late fragment revises the group; the originals go with it.
+          fragments: turn.fragments ?? null,
+        },
       });
   }
 }
 
+/** A summary part arrives once, whole; a repeat keeps the first. */
+export async function saveThought(callId: string, thought: CallThought) {
+  await database
+    .insert(callThoughtTable)
+    .values({ callId, ...thought })
+    .onConflictDoNothing();
+}
+
 export type CallGroup = {
   callId: string;
   startedAt: Date;
@@ -120,27 +156,6 @@ export async function listRecentTurns(limit: number): Promise<CallGroup[]> {
     .map((group) => ({ ...group, turns: group.turns.reverse() }));
 }
 
-/** The last spoken turns of one call in order, without tool turns. */
-export async function listCallTurns(
-  callId: string,
-  limit: number,
-): Promise<{ role: "user" | "assistant"; text: string }[]> {
-  const rows = await database
-    .select({ role: callMessageTable.role, text: callMessageTable.text })
-    .from(callMessageTable)
-    .where(
-      and(
-        eq(callMessageTable.callId, callId),
-        inArray(callMessageTable.role, ["user", "assistant"]),
-      ),
-    )
-    .orderBy(desc(callMessageTable.seq))
-    .limit(limit);
-  return rows
-    .reverse()
-    .map((row) => ({ role: row.role as "user" | "assistant", text: row.text }));
-}
-
 /**
  * One page of a call, every turn in order, tool turns included; null when the
  * call is gone. Tool turns keep their name and nothing else is read by the
@@ -202,7 +217,7 @@ export async function isAnyCallLive() {
 
 /**
  * Deletes an ended call and its turns (call_message cascades). A live call is
- * refused: its tab keeps writing turns against the row. Tasks keep a dangling
+ * refused: its tab keeps writing turns against the row. Threads keep a dangling
  * `callId`, which reads as "not on the line".
  */
 export async function deleteCall(id: string): Promise<boolean> {
@@ -238,8 +253,11 @@ export async function listCallHistory(options: {
       id: callTable.id,
       provider: callTable.provider,
       model: callTable.model,
+      backendModel: callTable.backendModel,
       startedAt: callTable.startedAt,
       endedAt: callTable.endedAt,
+      endedReason: callTable.endedReason,
+      seconds: callTable.seconds,
     })
     .from(callTable)
     .innerJoin(callMessageTable, eq(callMessageTable.callId, callTable.id))
@@ -260,6 +278,7 @@ export async function listCallHistory(options: {
       tool: callMessageTable.tool,
       text: callMessageTable.text,
       seq: callMessageTable.seq,
+      fragments: callMessageTable.fragments,
       at: callMessageTable.at,
     })
     .from(callMessageTable)

package/features/thursday/thursday.schema.ts

@@ -1,46 +1,28 @@
 import z from "zod";
 import { ASCII_FACE } from "@/config";
-import {
-  type SpeachModelProviderId,
-  speachModelRefSchema,
-} from "@/features/ai/model.schema";
-import { botIconSchema, type TaskStatus } from "@/features/bot/bot.schema";
+import { LiveSettingsSchema } from "@/features/ai/live.schema";
+import { botIconSchema, type ThreadStatus } from "@/features/bot/bot.schema";
 import { ASCII_CHARSETS, FACE_KINDS } from "@/features/thursday/face.const";
 import type { DateLike } from "@/lib/date-like";
-import { COMMON_VALIDATE } from "@/lib/limits";
-import type { RealtimeCredential } from "@/lib/realtime/realtime.schema";
-import type { RealtimeSessionSetup } from "@/lib/realtime/realtime.session";
+import { LiveFragmentSchema } from "@/lib/live/live.schema";
 
 // Shared by server and browser: nothing here may touch the DB.
 
 /** The payload openCallAction parses. Browser-only settings live in thursday.store. */
-export const ThursdaySettingsSchema = z.object({
-  systemPrompt: z.string().max(COMMON_VALIDATE.prompt.max).nullish(),
-  /** null until picked; the server then falls back to a provider with a key. */
-  model: speachModelRefSchema.nullish(),
+export const ThursdaySettingsSchema = LiveSettingsSchema.extend({
   /** `navigator.language` (e.g. "ko-KR"). Only the first call's opening line uses it. */
   locale: z.string().max(35).nullish(),
 });
 
 export type ThursdaySettings = z.infer<typeof ThursdaySettingsSchema>;
 
-/**
- * What the browser receives to open a call. `credential` is used to connect;
- * `session` is sent as `session.update` after connecting (nothing is baked
- * into the secret).
- */
+/** The browser receives the SDP answer, the row to save turns to, and the opening. */
 export type CallHandshake = {
   /** The row every saved turn hangs off. Exists before the connection. */
   callId: string;
-  provider: SpeachModelProviderId;
-  credential: RealtimeCredential;
-  /** Sent as `session.update` once open; anything absent is the provider default. */
-  session: RealtimeSessionSetup;
-  /**
-   * A system item to inject as soon as the line opens so the model speaks
-   * first. Instructions alone do not make a realtime model open the conversation.
-   */
-  opening: string | null;
+  sdp: string;
+  /** Trusted instructions sent after session.started, so she speaks first. */
+  opening: string;
 };
 
 /**
@@ -70,7 +52,7 @@ export const FACE_DEFAULT: ThursdayFace = ThursdayFaceSchema.parse({});
 /**
  * Config keys (features/config config.query) the call's server-side settings
  * live under. Everything else about the call is the browser's (thursday.store);
- * these two places build the tool set, so they cannot be.
+ * these are read where the prompts and the tool set are built, so they cannot be.
  */
 export const THURSDAY_KEYS = {
   /** "on" hands the call `load_skill`; anything else, unset included, is off. */
@@ -155,21 +137,31 @@ export const CallTurnSchema = z.object({
   text: z.string(),
   /** Position in the conversation (call_message.seq). */
   seq: z.number().int().min(0),
+  /** Null on legacy rows and tool calls. Display groups can be revised. */
+  fragments: z.array(LiveFragmentSchema).nullish(),
 });
 
 export type CallTurn = z.infer<typeof CallTurnSchema>;
 
+/** One reasoning summary part of the backend (call_thought). */
+export const CallThoughtSchema = z.object({
+  id: z.string().min(1),
+  text: z.string(),
+  seq: z.number().int().min(0),
+});
+
+export type CallThought = z.infer<typeof CallThoughtSchema>;
+
 export type CallStatus =
   | "idle"
   | "connecting"
+  | "ending"
   | "listening"
   | "speaking"
   /** A tool is running. */
   | "working"
   /** Handing work to a background bot. */
   | "delegating";
-// No "ending" status: session.close() is synchronous, so it would be
-// overwritten by idle in the same batch and never render.
 
 /** The statuses a live call moves between. */
 export type LiveStatus = Extract<
@@ -182,15 +174,20 @@ export type CallRecord = {
   id: string;
   provider: string;
   model: string;
+  /** The Responses model that held the tools; null on rows written before Live. */
+  backendModel: string | null;
   startedAt: DateLike;
   /** null when the hang-up was never recorded. */
   endedAt: DateLike | null;
+  /** What the provider said on close, and the active seconds it billed. Null when unconfirmed. */
+  endedReason: string | null;
+  seconds: number | null;
   turns: (CallTurn & { at: DateLike })[];
   /** Jobs this call opened, as they stand now; the log draws each under the line that opened it. */
   jobs: {
     id: string;
     label: string;
-    status: TaskStatus;
+    status: ThreadStatus;
     outcome: string | null;
   }[];
 };

package/features/thursday/thursday.store.ts

@@ -2,6 +2,7 @@
 
 import { create } from "zustand";
 import { persist } from "zustand/middleware";
+import { LIVE_DEFAULTS, migrateLiveSettings } from "@/features/ai/live.schema";
 import {
   CALL_BACK_DEFAULT,
   type CallBack,
@@ -43,8 +44,7 @@ type ThursdayStore = Stored & {
 };
 
 const EMPTY: Stored = {
-  systemPrompt: null,
-  model: null,
+  ...LIVE_DEFAULTS,
   wake: WAKE_DEFAULT,
   hotkey: HOTKEY_DEFAULT,
   callBack: CALL_BACK_DEFAULT,
@@ -59,10 +59,12 @@ export const useThursdayStore = create<ThursdayStore>()(
     }),
     {
       name: "thursday.settings",
-      // Parse on the way out so a hand-edited value cannot reach issuance.
+      // Parsed on the way in so a hand-edited value cannot reach a call. Live
+      // fields recover one by one (migrateLiveSettings), the rest by `.catch` above.
       merge: (persisted, current) => {
-        const parsed = StoredSchema.safeParse(persisted);
-        return { ...current, ...(parsed.success ? parsed.data : EMPTY) };
+        const parsed = StoredSchema.safeParse(migrateLiveSettings(persisted));
+        const restored = parsed.success ? parsed.data : EMPTY;
+        return { ...current, ...restored };
       },
     },
   ),
@@ -70,9 +72,11 @@ export const useThursdayStore = create<ThursdayStore>()(
 
 /** What openCallAction needs and nothing else. */
 export const thursdaySettings = (): ThursdaySettings => {
-  const { systemPrompt, model } = useThursdayStore.getState();
   // Not stored: a fact of this browser, read when the call opens.
   const locale =
     typeof navigator === "undefined" ? null : (navigator.language ?? null);
-  return { systemPrompt, model, locale };
+  return ThursdaySettingsSchema.parse({
+    ...useThursdayStore.getState(),
+    locale,
+  });
 };

package/features/thursday/tool-call.ts

@@ -1,17 +1,17 @@
 "use client";
 
 import { queryKey } from "@/app/api/query-key";
+import type { LiveToolCall } from "@/lib/live/live.session";
 import { type Result, unwrapResult } from "@/lib/protocol/result";
-import type { RealtimeToolCall } from "@/lib/realtime/realtime.session";
 import { errorToString } from "@/lib/utils";
 
 /**
- * Runs a tool the realtime model called on the server and returns the string
+ * Runs a tool the Live backend called on the server and returns the string
  * for the model. Never throws: every failure comes back as one readable line.
  */
 export async function runRemoteTool(
   callId: string,
-  call: RealtimeToolCall,
+  call: LiveToolCall,
   /** Aborted when the call ends, so a running tool stops with it (route). */
   signal?: AbortSignal,
 ): Promise<string> {

package/features/thursday/tool-line.ts

@@ -60,10 +60,12 @@ function fromArgs(name: string, args: Record<string, unknown>): string | null {
     const bot = typeof args.bot === "string" ? args.bot.trim() : "";
     return bot ? `Handing this to ${bot}` : "Handing this over";
   }
-  if (name === TOOL_NAMES.task) {
-    const label = typeof args.task === "string" ? args.task.trim() : "";
+  if (name === TOOL_NAMES.thread) {
+    const label = typeof args.thread === "string" ? args.thread.trim() : "";
     if (args.action === "answer") return "Passing that back";
     if (args.action === "cancel") return "Stopping that";
+    if (args.action === "open")
+      return label ? `Opening ${label}` : "Opening that";
     return label ? `Checking on ${label}` : "Checking the jobs";
   }
   return null;
@@ -103,7 +105,7 @@ export function toolLine(name: string, args?: string): string | null {
  * face instead of a glyph: who it went to is a face everywhere else in the app.
  */
 export function toolBot(name: string, args?: string): string | null {
-  if (name !== TOOL_NAMES.delegate && name !== TOOL_NAMES.ask_bot) return null;
+  if (name !== TOOL_NAMES.delegate) return null;
   const bot = parseArgs(args)?.bot;
   return typeof bot === "string" && bot.trim() ? bot.trim() : null;
 }