thursday-agent 0.10.0 → 0.12.0

package/features/thursday/thursday.text.ts

@@ -13,7 +13,11 @@ import {
 } from "ai";
 import { ZodError, z } from "zod";
 import { TEXT_CALL } from "@/config";
-import { LIVE_PROVIDER } from "@/features/ai/live.schema";
+import {
+  LIVE_PROVIDER,
+  type LiveSettings,
+  LiveSettingsSchema,
+} from "@/features/ai/live.schema";
 import { loadTools } from "@/features/ai/load-tools";
 import { getTextModel, modelErrorToString } from "@/features/ai/model";
 import {
@@ -38,8 +42,6 @@ import {
   TEXT_CALL_PROVIDERS,
   type TextCallHandshake,
   type TextCallProvider,
-  type ThursdaySettings,
-  ThursdaySettingsSchema,
   textCallRunsOn,
 } from "./thursday.schema";
 import { toolLine } from "./tool-line";
@@ -70,7 +72,7 @@ export async function readTextCallProvider(): Promise<TextCallProvider | null> {
  * in, else the OpenAI key, on the call's own backend model.
  */
 async function runsOnOf(
-  settings: ThursdaySettings,
+  settings: LiveSettings,
   picked: TextModelRef | null | undefined,
 ): Promise<TextModelRef> {
   if (picked) return picked;
@@ -81,7 +83,7 @@ async function runsOnOf(
 
 /** The row a call in writing is kept under, and what stood open as it began. */
 export async function openTextCall(
-  settings: ThursdaySettings,
+  settings: LiveSettings,
   picked?: TextModelRef | null,
 ): Promise<TextCallHandshake> {
   const ref = await runsOnOf(settings, picked);
@@ -98,7 +100,7 @@ export async function openTextCall(
 
 const BodySchema = z.object({
   callId: z.string().min(1),
-  settings: ThursdaySettingsSchema,
+  settings: LiveSettingsSchema,
   /** What stood open as the call opened (ai/prompts/call-standing), as the page was handed it. */
   standing: z.string().nullish(),
   /** The model picked on the write line; absent, the rule decides (runsOnOf). */
@@ -149,7 +151,7 @@ export async function streamTextCall(
  */
 export async function answerInWriting(input: {
   callId: string;
-  settings: ThursdaySettings;
+  settings: LiveSettings;
   standing: string | null;
   messages: ModelMessage[];
   said: string | null;
@@ -246,7 +248,7 @@ const standingHead = (standing: string | null | undefined): ModelMessage[] =>
 /** What a turn runs on, whoever holds the conversation: the model, her prompt, her tools. */
 async function loadRun(
   callId: string,
-  settings: ThursdaySettings,
+  settings: LiveSettings,
   picked?: TextModelRef | null,
 ) {
   const ref = await runsOnOf(settings, picked);

package/features/thursday/tool-line.ts

@@ -172,13 +172,15 @@ const ON_A_THREAD = new Set<string>([
  * The bot a call's tool reaches, so its row wears that bot's face rather than a glyph —
  * who work went to is a face everywhere else in the app. The one work is handed to, else
  * the bot of the thread the tool names, found as the server finds a thread (thread.query
- * resolveThread): its id, else its label. An answer goes to the bot that asked; "all", and
- * a thread the page does not hold, reach nobody in particular.
+ * resolveThread): its id, else its label. An answer goes to the bot that asked; "all"
+ * reaches nobody in particular. A thread the page does not hold — stopped and read, or
+ * finished longer ago than the inbox keeps — is named by the tool's answer once it is back.
  */
 export function toolBot(
   name: string,
   args?: string,
   threads?: Thread[],
+  output?: string,
 ): string | null {
   const parsed = parseArgs(args);
   if (!parsed) return null;
@@ -186,19 +188,28 @@ export function toolBot(
     return typeof parsed.bot === "string" && parsed.bot.trim()
       ? parsed.bot.trim()
       : null;
-  if (!ON_A_THREAD.has(name) || !threads) return null;
+  if (!ON_A_THREAD.has(name)) return null;
   const ref = typeof parsed.thread === "string" ? parsed.thread.trim() : "";
   if (!ref || ref.toLowerCase() === "all") return null;
   const lower = ref.toLowerCase();
   const thread =
-    threads.find((one) => one.id === ref) ??
-    threads.find((one) => one.label.toLowerCase() === lower);
-  if (!thread) return null;
+    threads?.find((one) => one.id === ref) ??
+    threads?.find((one) => one.label.toLowerCase() === lower);
+  if (!thread) return answeredBy(output);
   return name === TOOL_NAMES.thread_answer
     ? (thread.room.questions[0]?.bot ?? thread.bot)
     : thread.bot;
 }
 
+/** Whom a thread tool's answer says it reached (load-tools): `bot`, or the bot that took it as its answer. */
+function answeredBy(output?: string): string | null {
+  const said = parseArgs(output);
+  if (!said) return null;
+  if (typeof said.bot === "string" && said.bot.trim()) return said.bot.trim();
+  const answered = said.answered as { bot?: unknown } | null | undefined;
+  return typeof answered?.bot === "string" ? answered.bot : null;
+}
+
 /**
  * The label a thread was started under, or null for any other turn. It is
  * how a job is found again from the line that opened it — in her prompt and in

package/features/thursday/use-call-ring.ts

@@ -6,7 +6,6 @@ import type { Thread } from "@/features/bot/bot.schema";
 import { ringingThreads } from "@/features/bot/thread.store";
 import { toDate } from "@/lib/date-like";
 import { createRing } from "@/lib/live/ring";
-import { createProbe } from "@/lib/probe";
 import type { CallBack } from "./thursday.schema";
 import { useThursdayStore } from "./thursday.store";
 
@@ -51,7 +50,6 @@ export function useCallRing({
   /** A call in writing holds the screen (use-text-call): nothing rings meanwhile. */
   writing: boolean;
 }) {
-  const probe = useRef(createProbe("page")).current;
   /**
    * The call-back rings only for threads that changed after this: the last call's
    * end, the last ring, or the page opening.
@@ -84,7 +82,6 @@ export function useCallRing({
     );
     if (!fresh.length) return;
 
-    probe("ring", { threads: fresh.map((thread) => thread.id) });
     ringAfter.current = Date.now();
     // Work that is new to it rings again, even if it had rung out
     setRangOutAt(null);
@@ -92,7 +89,7 @@ export function useCallRing({
       ...ids,
       ...fresh.map((thread) => thread.id).filter((id) => !ids.includes(id)),
     ]);
-  }, [threads, callBack, resting, writing, probe]);
+  }, [threads, callBack, resting, writing]);
 
   // Writing to her answers a ring as calling her does, and what came up while they wrote
   // was that call's to tell: nothing from before its end rings afterwards
@@ -110,7 +107,6 @@ export function useCallRing({
    * A thread added to a ring already going does not restart the clock.
    */
   const decline = useCallback(() => {
-    probe("ring.declined");
     setRingingFor([]);
     setRangOutAt(null);
   }, []);

package/features/thursday/use-text-call.ts

@@ -267,34 +267,50 @@ export function useTextCall(): TextCall {
   // pages a search read stay through her answer, until the next words are sent, as on a
   // spoken call
   const lastTool = [...parts].reverse().find(isToolUIPart);
-  const used = useMemo((): ActivityLine | null => {
-    if (!lastTool) return null;
-    const name = getToolName(lastTool);
-    // A provider's own search names what it looked for in its answer, not in what it was asked
-    const asked = (lastTool.output as { action?: { query?: unknown } } | null)
-      ?.action?.query;
-    const args = JSON.stringify({
-      ...(typeof asked === "string" ? { query: asked } : {}),
-      ...(lastTool.input ?? {}),
-    });
-    const done =
-      lastTool.state === "output-available" ||
-      lastTool.state === "output-error";
-    const sources =
+  // The part is copied with every piece of the stream, and its arguments arrive a few
+  // characters a piece: the line is a new object only when what it draws changes, or
+  // every piece redraws the call screen several times over
+  const id = lastTool?.toolCallId ?? null;
+  const name = lastTool ? getToolName(lastTool) : null;
+  const done =
+    lastTool?.state === "output-available" ||
+    lastTool?.state === "output-error";
+  const output = lastTool?.output;
+  const sources = useMemo(
+    () =>
       done && name === TOOL_NAMES.web_search
-        ? searchSourcesOf(JSON.stringify(lastTool.output ?? null))
-        : [];
-    if (last?.type === "text" && !sources.length) return null;
-    const bot = toolBot(name, args, inbox.current);
+        ? searchSourcesOf(JSON.stringify(output ?? null))
+        : [],
+    [done, name, output],
+  );
+  // A provider's own search names what it looked for in its answer, not in what it was asked
+  const asked = (output as { action?: { query?: unknown } } | null | undefined)
+    ?.action?.query;
+  const args = JSON.stringify({
+    ...(typeof asked === "string" ? { query: asked } : {}),
+    ...(lastTool?.input ?? {}),
+  });
+  const bot = name
+    ? toolBot(
+        name,
+        args,
+        inbox.current,
+        output === undefined ? undefined : JSON.stringify(output),
+      )
+    : null;
+  const drawn = name ? toolLine(name, args, bot) : null;
+  const answered = last?.type === "text";
+  const used = useMemo((): ActivityLine | null => {
+    if (!id || !name || (answered && !sources.length)) return null;
     return {
-      id: lastTool.toolCallId,
+      id,
       name,
-      line: toolLine(name, args, bot),
+      line: drawn,
       bot,
       done,
       ...(sources.length ? { sources } : {}),
     };
-  }, [lastTool, last?.type]);
+  }, [id, name, drawn, bot, done, sources, answered]);
   const [lingered, setLingered] = useState<string | null>(null);
   const usedId = used?.done && !used.sources ? used.id : null;
   useEffect(() => {

package/features/thursday/use-thursday.ts

@@ -4,13 +4,7 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { useAppEvent } from "@/app/api/events/app-event.client";
 import { queryKey } from "@/app/api/query-key";
 import { toast } from "@/components/ui/toast";
-import {
-  CALL_END,
-  CALL_ENDED_MS,
-  CALL_IDLE,
-  CALL_NUDGE,
-  CALL_RELAY,
-} from "@/config";
+import { CALL_END, CALL_ENDED_MS, CALL_IDLE, CALL_RELAY } from "@/config";
 import { TOOL_NAMES } from "@/features/ai/tools/tool-name";
 import { acceptThreadRelaysAction } from "@/features/bot/bot.action";
 import type { Bot, Thread } from "@/features/bot/bot.schema";
@@ -32,7 +26,6 @@ import {
   createAudioTap,
   SPECTRUM_BANDS,
 } from "@/lib/live/live.tap";
-import { createProbe } from "@/lib/probe";
 import { type Result, unwrapResult } from "@/lib/protocol/result";
 import {
   revalidate,
@@ -216,8 +209,6 @@ export function useThursday(
   const onLine = useRef<string[]>([]);
   /** That update's relay rows, accepted once she has voiced it. */
   const onLineRows = useRef<number[]>([]);
-  /** The experiment's timer (config CALL_NUDGE): a backend turn the page starts itself. */
-  const nudge = useRef<ReturnType<typeof setTimeout> | null>(null);
   /** When her voice was last heard, for letting a goodbye finish (CALL_END). */
   const voiced = useRef(0);
   /** The hang-up waiting on her goodbye once the backend called end_call. */
@@ -267,12 +258,22 @@ export function useThursday(
     });
   }, []);
 
+  /** The tool's answer is back: a thread the page does not hold is named by it (toolBot). */
+  const nameTool = useCallback((call: LiveToolCall, output: string) => {
+    const bot = toolBot(call.name, call.arguments, latest.current, output);
+    if (!bot) return;
+    setTool((open) =>
+      open?.id === call.id && open.bot !== bot
+        ? { ...open, bot, line: toolLine(call.name, call.arguments, bot) }
+        : open,
+    );
+  }, []);
+
   /**
    * A relay takes the tool line and runs there like a tool does: while it goes in,
    * and while she voices it. Her voice finishing it is what stops the motion
    * (doneReading); after that it stays long enough to read.
    */
-  const probe = useRef(createProbe("page")).current;
   const showRelay = useCallback((run: ActivityLine) => {
     if (linger.current) clearTimeout(linger.current);
     relayOpen.current = true;
@@ -295,7 +296,6 @@ export function useThursday(
   /** The relayed update was voiced, or waited on long enough: the next can go in. */
   const doneReading = useCallback(() => {
     if (reading.current.giveUp) clearTimeout(reading.current.giveUp);
-    probe("read.done", { spoke: reading.current.spoke, keys: onLine.current });
     // Her voice started and stopped on it: carried, and only now are its rows accepted.
     // Live's acknowledgement says the text arrived, not that anyone heard it
     if (reading.current.spoke) {
@@ -419,13 +419,6 @@ export function useThursday(
     }
     // Finished work is good news before she says it (an item's key opens with what it is)
     if (first.key.startsWith("done:")) setFaceWord(finished());
-    probe("relay.out", {
-      kind: first.kind,
-      keys: due.map((item) => item.key),
-      waiting: open.length - due.length,
-      quietMs: Date.now() - heard.current,
-      rung,
-    });
     readAloud();
     onLine.current = due.map((item) => item.key);
     onLineRows.current = due.flatMap((item) => item.relayIds);
@@ -439,7 +432,6 @@ export function useThursday(
           : `[${lines.length} updates.]\n\n${lines.join("\n\n")}`,
       )
       .then((delivered) => {
-        probe("relay.acked", { delivered });
         // Refused: nothing to wait for her voice on
         if (!delivered) {
           onLineRows.current = [];
@@ -572,12 +564,6 @@ export function useThursday(
     async (why: CallEnd | null = null) => {
       if (ending.current) return;
       ending.current = true;
-      probe("hangup", {
-        why,
-        call: callId.current,
-        unvoiced: [...unvoiced.current],
-        reading: reading.current.on,
-      });
       if (leaving.current) clearInterval(leaving.current);
       leaving.current = null;
       attempt.current += 1;
@@ -665,7 +651,6 @@ export function useThursday(
   const leave = useCallback(() => {
     if (leaving.current) return;
     const asked = Date.now();
-    probe("end_call", { sinceVoiceMs: asked - voiced.current });
     leaving.current = setInterval(() => {
       const now = Date.now();
       // A goodbye heard just before the backend ended the call counts as said
@@ -703,7 +688,6 @@ export function useThursday(
   const call = useCallback(async () => {
     // Every way in answers a ringing call-back: the face, the wake word, the hotkey
     const calledBack = ring.isRinging;
-    probe("call", { calledBack, ringingFor: ring.ringingFor });
     // Guard with a ref, not `status`: three entry points (face, wake word,
     // hotkey) can fire in one frame and both see a stale "idle", opening two sessions
     if (opening.current || ending.current) return;
@@ -831,8 +815,6 @@ export function useThursday(
               if (word) setFaceWord({ text: word, at: Date.now() });
               return reply;
             }
-            const began = Date.now();
-            probe("tool.run", { name: call.name, id: call.id });
             showTool(call);
             // Exa's search, while its key is set (load-tools): its pages come back with
             // the answer and stay on the line the way the hosted search's do
@@ -846,6 +828,7 @@ export function useThursday(
                 settings.webSearch,
                 stop.signal,
               );
+              nameTool(call, output);
               if (searching)
                 kept = keepSearch({
                   id: call.id,
@@ -857,7 +840,6 @@ export function useThursday(
                 });
               return output;
             } finally {
-              probe("tool.done", { id: call.id, ms: Date.now() - began });
               if (!kept) hideTool(call.id);
             }
           },
@@ -946,19 +928,6 @@ export function useThursday(
                   .slice(-KEEP_MESSAGES),
               );
             }
-            // The experiment (config CALL_NUDGE): their words have settled, and if the voice
-            // hands nothing over in a moment the page starts the backend turn itself
-            if (CALL_NUDGE.on && turn.done && turn.role === "user" && words) {
-              if (nudge.current) clearTimeout(nudge.current);
-              const spoke = stirred.current;
-              nudge.current = setTimeout(() => {
-                nudge.current = null;
-                // they went on talking, or the backend has the turn already
-                if (stirred.current !== spoke || thinking.current !== null)
-                  return;
-                probe("nudge", { sent: session.current?.nudge() ?? false });
-              }, CALL_NUDGE.waitMs);
-            }
             if (turn.done) {
               persist(saving, () =>
                 saveTurnsAction(line.callId, [
@@ -1076,6 +1045,7 @@ export function useThursday(
     status,
     hangUp,
     showTool,
+    nameTool,
     hideTool,
     showFace,
     wearFace,

package/features/workspace/workspace.ts

@@ -207,11 +207,13 @@ export const jobShellEnv = (
 });
 
 /**
- * A bot's artifacts folder in its shell, for a script that delivers a file
- * rather than a model typing the path (skills/interactive-page scripts/page.mjs).
+ * What a bot's scripts find in its shell rather than a model typing the path.
  */
 export const botShellEnv = (bot: string): Record<string, string> => ({
+  // Where a script delivers a file (skills/interactive-page scripts/page.mjs)
   THURSDAY_ARTIFACTS: botArtifacts(bot),
+  // The shipped skills: a kit script in a bot's folder imports the shared ones from here
+  THURSDAY_SKILLS: join(APP_DIR, PATHS.skills.default),
 });
 
 /** A participant's browser belongs to the job and its canonical bot name, across every caller. */

package/guide/bots.md

@@ -10,8 +10,11 @@ switched on; any of them can be switched off there, and added later from the sam
 
 Every bot has the same kit: a shell on this computer, a real browser of its own or the one
 the user is already signed into, their files, the web, whatever skills and connected services
-are installed, and the other bots. A ready-made bot may also arrive with written methods of
-its own for its subject, which no other bot sees.
+are installed, and the other bots. A ready-made bot may also arrive with written methods and
+scripts of its own for its subject, which no other bot sees: Insta studies accounts that do well
+in a niche, builds posts the same way and reads messages without opening them (an opened thread
+shows as seen); Analyst fetches published series and draws them; Marketer keeps one brief per
+product in its memory and works from it.
 
 ## A job is a thread
 
@@ -75,6 +78,13 @@ of itself. Asking her on a call to show a result opens that file on the screen.
 stay under **Settings › Files**, one shelf per bot. Its second tab, **All files**, is the
 whole folder, for looking around rather than for the results.
 
+Asked to explain something simply, **Tutor** makes a picture book: a picture and a line
+or two a page, turned by swiping, the arrow keys, or tapping the right or left of the page. The
+same book can be a PDF, or a video that reads itself aloud (landscape, or portrait when asked);
+when the request does not say which, it asks first. It remembers what the user already
+knows and how they liked being taught. The video needs a speech model in **Settings › Models**, and a drawn
+picture an image model; without one it asks for it and stops.
+
 A bot keeps its own memory — what a job taught it, how the user asked it to work — in its own
 folder, listed on its page in Settings › Bots.
 

package/guide/calls.md

@@ -11,7 +11,8 @@ Three ways in, and any of them also answers a call she placed:
 
 She speaks first. From the second call on she is told, as the call opens, when the last one
 was and how it ended, so she can greet as someone who remembers it; a call she places herself
-opens on why she called instead.
+opens on why she called instead. She speaks the language the user speaks and switches when they
+do; the browser's language plays no part, so the very first greeting is in whatever she picks.
 
 The wake phrase and the shortcut are in **Settings › Thursday › Starting a call**, where
 either can be switched on or off, or rewritten. The first-run setup offers the wake phrase
@@ -42,14 +43,16 @@ in **Settings › Thursday**. With nothing to run on it says so and sends nothin
 **Settings › API keys**. **Esc** ends it — saying goodbye does not, since there is no
 line for her to drop — and so does starting a spoken call: tapping her face in the middle of
 one ends the written call and places a spoken one. When a turn breaks — a plan's limit, a
-refused key — her face says ERROR and the provider's own words show in red under the line;
-writing again tries again, and Esc still ends it. When an OpenAI key is set and was not what
-broke, a blue button sends the same words again on that key; it never switches by itself,
-since what a turn costs changes with what it runs on. It is kept with
+refused key — her face says ERROR and the provider's own words show in red under the line,
+over a blue **Send it again** and the way to **API keys**; writing again tries again too, and
+Esc still ends it. When an OpenAI key is set and was not what broke, the button sends the same
+words again on that key instead; it never switches by itself, since what a turn costs changes
+with what it runs on. It is kept with
 the other calls, marked *in writing*, and she reads it back on the next call like any other.
 During a spoken call the line writes to bots only — but a file put down then (dropped on the
 window, pasted, or picked with the paperclip) is one she is told about as it lands: its chip
-says *she knows it is here*, and what to do with it can simply be said.
+says *she knows it is here*, and what to do with it can simply be said. A line left open with
+nothing in it closes when a spoken call picks up; one holding words or files stays.
 
 ## What she does on the line, and what goes to a bot
 

package/guide/setup.md

@@ -17,7 +17,10 @@ said about it (a mistyped key, one that was deleted). Bots can run on that same
 key. The screen puts the two easy ways next: a GPT Subscription sign-in (bots run on the
 ChatGPT plan, no key), and the Vercel AI Gateway, one key for every model and the one the app
 recommends. Under them every other provider is a mark to tap and paste a key into: Anthropic,
-Google, xAI, Mistral, DeepSeek, Groq, Cerebras, Together, Fireworks, DeepInfra, Cohere.
+Google, xAI, Mistral, DeepSeek, Groq, Cerebras, Together, Fireworks, DeepInfra, Cohere. The box
+a key goes in shows how that provider's keys begin (`sk-ant-…` for Anthropic) where it is known,
+with a link to the page that makes one; **Remove**, on a key already set, is the red word at the
+far left.
 
 A search key (Exa) is optional. With it, calls and bots both search through Exa, which is
 cheaper per search and comes with free credits every month. Without it, a call uses OpenAI's

package/lib/live/live.session.ts

@@ -1,6 +1,5 @@
 import { LIVE_CALL } from "@/config";
 import { logger } from "@/lib/logger";
-import { briefLiveEvent, createProbe } from "@/lib/probe";
 import { errorToString } from "@/lib/utils";
 import {
   LIVE_HOSTED_TOOLS,
@@ -9,8 +8,6 @@ import {
 } from "./live.schema";
 import { createWebRtcTransport } from "./live.transport";
 
-const probe = createProbe("live");
-
 /** A revisable display group, independent of audio playback and backend responses. */
 export type LiveTurn = {
   id: string;
@@ -313,12 +310,6 @@ export const createLiveSession = ({ initialize, audio, on }: LiveOptions) => {
       return;
     const [next] = appends;
     pendingAppend = crypto.randomUUID();
-    probe("out", {
-      type: `session.${next.kind}.append`,
-      client: pendingAppend,
-      head: next.chunks[0].slice(0, 80),
-      chunksLeft: next.chunks.length,
-    });
     transport.send({
       type: `session.${next.kind}.append`,
       event_id: pendingAppend,
@@ -405,7 +396,6 @@ export const createLiveSession = ({ initialize, audio, on }: LiveOptions) => {
       return;
     response.continued = true;
     await Promise.all(response.calls.values());
-    probe("out", { type: "response.create", closing, closed });
     if (!closing && !closed) {
       continuedAt = performance.now();
       transport.send({
@@ -422,8 +412,6 @@ export const createLiveSession = ({ initialize, audio, on }: LiveOptions) => {
       events.add(event.event_id);
     }
     timeline = Math.max(timeline, event.offset_ms ?? 0, event.end_ms ?? 0);
-    if (!event.type.endsWith(".delta") && !event.event?.type.endsWith(".delta"))
-      probe("in", briefLiveEvent(event));
     switch (event.type) {
       case "session.started":
         started = true;
@@ -576,12 +564,6 @@ export const createLiveSession = ({ initialize, audio, on }: LiveOptions) => {
             .catch((cause) => `Error: ${errorToString(cause)}`)
             .then((output) => {
               tools.delete(item.call_id);
-              probe("out", {
-                type: "function_call_output",
-                name: item.name,
-                call: item.call_id,
-                size: output.length,
-              });
               if (!closed && !closing)
                 transport.send({
                   type: "response.item.create",
@@ -690,7 +672,6 @@ export const createLiveSession = ({ initialize, audio, on }: LiveOptions) => {
         cleanup();
       }, LIVE_CALL.closeMs);
       audio.element.muted = true;
-      probe("out", { type: "session.close" });
       transport.send({ type: "session.close", event_id: crypto.randomUUID() });
       return closePromise;
     },
@@ -708,25 +689,5 @@ export const createLiveSession = ({ initialize, audio, on }: LiveOptions) => {
         appendNext();
       });
     },
-    /**
-     * Starts a backend turn the voice did not hand over: the same `response.create` that
-     * continues delegated work, sent with nothing pending. Does nothing while the backend
-     * already holds the turn, or once the call is closing. False when it was not sent.
-     */
-    nudge(): boolean {
-      const busy =
-        [...responses.values()].some((response) => !response.terminal) ||
-        tools.size > 0 ||
-        performance.now() - continuedAt < CONTINUE_GAP_MS;
-      if (closed || closing || busy) return false;
-      probe("out", { type: "response.create", nudge: true });
-      continuedAt = performance.now();
-      transport.send({
-        type: "response.create",
-        event_id: crypto.randomUUID(),
-      });
-      activity();
-      return true;
-    },
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thursday-agent",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "A voice agent that runs on your own machine — talk to her, she hands the slow work to bots with a shell, a browser and skills.",
   "license": "MIT",
   "keywords": [