thursday-agent 0.5.0 → 0.7.0

package/features/thursday/components/voice-picker.tsx

@@ -0,0 +1,255 @@
+"use client";
+
+import { Check, ChevronDown, X } from "lucide-react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Button } from "@/components/ui/button";
+import { Input, inputClassName } from "@/components/ui/input";
+import { ShinyText } from "@/components/ui/shiny-text";
+import { toast } from "@/components/ui/toast";
+import {
+  LIVE_VOICE_NOTE,
+  LIVE_VOICES,
+  voiceSamplePath,
+} from "@/features/ai/live.schema";
+import { Face } from "@/features/thursday/components/face";
+import type { ThursdayFace } from "@/features/thursday/thursday.schema";
+import { createClipTap, SPECTRUM_BANDS } from "@/lib/live/live.tap";
+import { cn, errorToString } from "@/lib/utils";
+
+/**
+ * Choosing a voice by ear. A name plays its recorded line and her own face
+ * speaks it — the same component and the same bands a call moves her with, so
+ * what you hear and see here is what the call will be. Only Save writes, so
+ * hearing eleven voices stores none of them.
+ */
+
+const SILENT = new Array<number>(SPECTRUM_BANDS).fill(0);
+
+export function VoicePicker({
+  voice,
+  face,
+  onChange,
+}: {
+  /** The saved voice: what the next call opens with. */
+  voice: string;
+  face: ThursdayFace;
+  onChange: (voice: string) => void;
+}) {
+  const [open, setOpen] = useState(false);
+  const [heard, setHeard] = useState(voice);
+  const [playing, setPlaying] = useState(false);
+  const [typed, setTyped] = useState("");
+
+  const clip = useRef<HTMLAudioElement>(null);
+  // A tap belongs to the element it routes, which exists only while the picker is open.
+  const tap = useRef<{
+    element: HTMLAudioElement;
+    clip: ReturnType<typeof createClipTap>;
+  } | null>(null);
+  // Each play and each stop takes the next number; a failure reported for an
+  // earlier one changes nothing.
+  const plays = useRef(0);
+  // The face reads the spectrum once per animation frame, so what it reads is a
+  // ref, not state: a stable function, and silence when nothing is playing.
+  const sounding = useRef(false);
+  const spectrum = useCallback(
+    () => (tap.current && sounding.current ? tap.current.clip.read() : SILENT),
+    [],
+  );
+  const showPlaying = (on: boolean) => {
+    sounding.current = on;
+    setPlaying(on);
+  };
+
+  // The element goes when the picker closes; its graph goes with it.
+  useEffect(() => {
+    if (!open) return;
+    return () => {
+      const held = tap.current;
+      tap.current = null;
+      if (!held) return;
+      held.element.pause();
+      void held.clip.close();
+    };
+  }, [open]);
+
+  const failed = (play: number, cause: unknown) => {
+    if (play !== plays.current) return;
+    plays.current++;
+    showPlaying(false);
+    toast.add({
+      type: "error",
+      title: "Voice sample did not play",
+      description: errorToString(cause),
+    });
+  };
+
+  const stop = () => {
+    plays.current++;
+    const audio = clip.current;
+    if (audio) {
+      audio.pause();
+      audio.currentTime = 0;
+    }
+    showPlaying(false);
+  };
+
+  const audition = (next: string) => {
+    const audio = clip.current;
+    if (!audio) return;
+    if (playing && next === heard) {
+      stop();
+      return;
+    }
+    setHeard(next);
+    setTyped("");
+    // The graph is built inside the gesture that plays: an AudioContext made
+    // before one is refused. An element is routed once, so it keeps its tap.
+    if (tap.current?.element !== audio) {
+      void tap.current?.clip.close();
+      tap.current = { element: audio, clip: createClipTap(audio) };
+    }
+    void tap.current.clip.resume();
+    const play = ++plays.current;
+    audio.src = voiceSamplePath(next);
+    showPlaying(true);
+    void audio.play().catch((cause: unknown) => {
+      // A later click or a stop cut this one short; that play owns the state.
+      if (cause instanceof DOMException && cause.name === "AbortError") return;
+      failed(play, cause);
+    });
+  };
+
+  const close = () => {
+    stop();
+    setOpen(false);
+    setTyped("");
+    setHeard(voice);
+  };
+
+  const save = () => {
+    const picked = typed.trim() || heard;
+    stop();
+    setOpen(false);
+    setTyped("");
+    setHeard(picked);
+    if (picked !== voice) onChange(picked);
+  };
+
+  if (!open) {
+    return (
+      <button
+        type="button"
+        onClick={() => setOpen(true)}
+        aria-label="Voice"
+        className={cn(
+          inputClassName,
+          "flex items-center gap-2 text-left font-mono text-sm hover:border-ring",
+        )}
+      >
+        <span className="shrink-0">{voice}</span>
+        <span className="min-w-0 truncate text-[11px] text-muted-foreground">
+          {LIVE_VOICE_NOTE[voice as keyof typeof LIVE_VOICE_NOTE]}
+        </span>
+        <ChevronDown className="ml-auto size-3.5 shrink-0 text-muted-foreground" />
+      </button>
+    );
+  }
+
+  return (
+    <div className="@container space-y-2">
+      {/* Nothing here plays through the page's own speakers but this element. */}
+      <audio
+        ref={clip}
+        onEnded={() => showPlaying(false)}
+        // A clip that breaks after it starts fails here, not in play()
+        onError={(event) => {
+          if (!sounding.current) return;
+          failed(
+            plays.current,
+            event.currentTarget.error?.message || "The clip could not be read.",
+          );
+        }}
+      >
+        <track kind="captions" />
+      </audio>
+
+      <div className="rounded-xl border border-border/60 p-3">
+        <div className="mb-2 flex items-center gap-2">
+          <span className="font-mono text-[11px] text-muted-foreground">
+            click a name to hear it
+          </span>
+          <Button
+            variant="ghost"
+            size="icon-xs"
+            className="ml-auto"
+            aria-label="Close"
+            onClick={close}
+          >
+            <X />
+          </Button>
+        </div>
+
+        <div className="grid gap-4 @md:grid-cols-[11rem_minmax(0,1fr)]">
+          <div className="flex flex-col items-center gap-2">
+            <Face
+              look={face}
+              status={playing ? "speaking" : "idle"}
+              getSpectrum={spectrum}
+              size={176}
+              className="w-44"
+            />
+            <span className="text-sm font-medium">
+              {playing ? <ShinyText text={heard} /> : heard}
+            </span>
+            <span className="h-4 font-mono text-[11px] text-muted-foreground">
+              {LIVE_VOICE_NOTE[heard as keyof typeof LIVE_VOICE_NOTE]}
+            </span>
+          </div>
+
+          <div className="max-h-56 min-w-0 overflow-y-auto">
+            {LIVE_VOICES.map((name) => (
+              <button
+                type="button"
+                key={name}
+                onClick={() => audition(name)}
+                className={cn(
+                  "flex w-full items-center gap-2 rounded-md px-1.5 py-1.5 text-sm outline-none hover:bg-accent focus-visible:bg-accent",
+                  name === heard && "bg-accent text-accent-foreground",
+                )}
+              >
+                <span className="flex-1 text-left">
+                  {playing && name === heard ? <ShinyText text={name} /> : name}
+                </span>
+                <span className="shrink truncate font-mono text-[11px] text-muted-foreground">
+                  {LIVE_VOICE_NOTE[name]}
+                </span>
+                <Check
+                  className={cn(
+                    "size-3.5 shrink-0",
+                    name === voice ? "opacity-100" : "opacity-0",
+                  )}
+                />
+              </button>
+            ))}
+          </div>
+        </div>
+      </div>
+
+      {/* A voice id that is not on the list still runs; it simply has no clip. */}
+      <div className="flex gap-2">
+        <Input
+          value={typed}
+          onChange={(event) => setTyped(event.target.value)}
+          placeholder="another voice id"
+          aria-label="Another voice id"
+          spellCheck={false}
+          className="font-mono text-sm"
+        />
+        <Button className="shrink-0" onClick={save}>
+          Save
+        </Button>
+      </div>
+    </div>
+  );
+}

package/features/thursday/face.store.ts

@@ -40,6 +40,11 @@ export function setThursdayFace(next: ThursdayFace) {
   announce();
 }
 
+/** The face as it is now, for code outside React. */
+export function thursdayFace(): ThursdayFace {
+  return face;
+}
+
 export function useThursdayFace(): ThursdayFace {
   return useSyncExternalStore(
     (listener) => {

package/features/thursday/thursday.action.ts

@@ -2,65 +2,50 @@
 
 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`
- * (`end_call`) are included: the model must see them and the page intercepts them.
+ * (`end_call`, `emote`) are included: the model must see them and the page intercepts them.
  */
-async function loadToolManifest(): Promise<ToolManifest[]> {
-  const tools = await loadTools({ target: "thursday" });
+async function loadToolManifest(faceWords: boolean): Promise<ToolManifest[]> {
+  const tools = await loadTools({ target: "thursday", faceWords });
 
   return Object.entries(tools).map(([name, definition]) => {
     const { $schema, ...parameters } = asSchema(definition.inputSchema)
@@ -78,47 +63,65 @@ 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),
-      loadToolManifest(),
+    // Assembled per call, never cached: both prompts read what earlier calls stored.
+    const [voice, backend, tools, reasoning] = await Promise.all([
+      loadLivePrompt({
+        voicePrompt: thursday.voicePrompt,
+        locale: thursday.locale,
+        calledBack: z.boolean().default(false).parse(calledBack),
+      }),
+      loadThursdayPrompt(thursday.backendPrompt),
+      loadToolManifest(thursday.faceWords ?? false),
+      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,
+      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 +135,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 +185,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)