@alexkroman1/aai-cli 13.2.0 → 14.0.0

package/dist/templates/solo-rpg/agent.test.ts

@@ -1,6 +1,6 @@
 import type { ToolContext, ToolDef, ToolInputSchema } from "@alexkroman1/aai";
 import { isToolFailure } from "@alexkroman1/aai";
-import { createToolContext, ok } from "@alexkroman1/aai/testing";
+import { createToolContext, expectToolOk } from "@alexkroman1/aai/testing";
 import { describe, expect, test, vi } from "vitest";
 import {
   applyConsequences,
@@ -24,11 +24,11 @@ import updateState from "./tools/update_state.ts";
 
 // ── Test doubles ─────────────────────────────────────────────────────────────
 
-/** `send` is a spy rather than the recorder `createToolContext` installs,
- *  because this suite asserts call counts on it. Each call gets its own slot
- *  store, which is what makes two contexts two games. */
+/** Each call gets its own slot store, which is what makes two contexts two
+ *  games. `send` is the recorder `createToolContext` installs — no test here
+ *  asserts on it, and overriding it would only throw the recording away. */
 function makeCtx(): ToolContext {
-  return createToolContext({ send: vi.fn() });
+  return createToolContext();
 }
 
 const SETUP_ARGS = {
@@ -288,7 +288,7 @@ describe("burn_momentum", () => {
     const ctx = makeCtx();
     seedRolledState(8, ctx); // 8 beats both dice (3, 5)
 
-    const result = ok<Record<string, unknown>>(await callNoArgs(burnMomentum, ctx));
+    const result = expectToolOk<Record<string, unknown>>(await callNoArgs(burnMomentum, ctx));
     expect(result.burned).toBe(true);
     expect(result.newResultCode).toBe("STRONG_HIT");
 
@@ -302,7 +302,7 @@ describe("burn_momentum", () => {
   test("momentum beating only one die upgrades a MISS to WEAK_HIT", async () => {
     const ctx = makeCtx();
     seedRolledState(4, ctx); // beats 3, not 5
-    const result = ok<{ newResultCode: string }>(await callNoArgs(burnMomentum, ctx));
+    const result = expectToolOk<{ newResultCode: string }>(await callNoArgs(burnMomentum, ctx));
     expect(result.newResultCode).toBe("WEAK_HIT");
   });
 
@@ -528,7 +528,7 @@ describe("update_state", () => {
     state.clocks[0]!.filled = 3; // 3 of 4
     seedPlaying(ctx, state);
 
-    const result = ok<{ clockEvents: { clock: string; trigger: string }[] }>(
+    const result = expectToolOk<{ clockEvents: { clock: string; trigger: string }[] }>(
       await updateState.execute({ advanceClockName: "Doom" }, ctx),
     );
     expect(result.clockEvents).toEqual([{ clock: "Doom", trigger: "The doom arrives" }]);
@@ -542,7 +542,7 @@ describe("update_state", () => {
     }
     seedPlaying(ctx, state);
 
-    const result = ok<{ warnings?: string[] }>(
+    const result = expectToolOk<{ warnings?: string[] }>(
       await updateState.execute({ addNpcName: "One Too Many" }, ctx),
     );
     expect(result.warnings?.[0]).toMatch(/NPC limit/);
@@ -609,7 +609,7 @@ describe("the story flow", () => {
     expect(created.state).toBe("playing.awaitingRoll");
     expect(created.instruction).toMatch(/action_roll/);
 
-    ok(
+    expectToolOk(
       await actionRoll.execute(
         { move: "clash", stat: "iron", position: "risky", effect: "standard", purpose: "swing" },
         ctx,
@@ -618,7 +618,7 @@ describe("the story flow", () => {
     expect(storyFlow.position(ctx).state).toBe("playing.rollResolved");
 
     // Moving the scene on SPENDS the roll: the burn window is closed.
-    ok(await updateState.execute({ location: "The Bridge" }, ctx));
+    expectToolOk(await updateState.execute({ location: "The Bridge" }, ctx));
     expect(storyFlow.position(ctx).state).toBe("playing.awaitingRoll");
     expect(isToolFailure(await callNoArgs(burnMomentum, ctx))).toBe(true);
   });
@@ -644,7 +644,7 @@ describe("the story flow", () => {
     // act on it, so a player could keep rolling after both tracks emptied. The
     // WRITE is `gameSlot`'s `after` hook; this tool no longer calls it, which
     // is the point of moving it there.
-    ok(await updateState.execute({ health: 0, spirit: 0 }, ctx));
+    expectToolOk(await updateState.execute({ health: 0, spirit: 0 }, ctx));
     const at = storyFlow.position(ctx);
     expect(at.state).toBe("gameOver");
     expect(at.done).toBe(true);

package/dist/templates/solo-rpg/client.tsx

@@ -1,6 +1,6 @@
 import "@alexkroman1/aai-ui/styles.css";
 import type { DeepReadonly } from "@alexkroman1/aai";
-import { client, useAgentState } from "@alexkroman1/aai-ui";
+import { mountClient, useAgentState } from "@alexkroman1/aai-ui";
 import type { ReactNode } from "react";
 import {
   type Clock,
@@ -782,7 +782,7 @@ function Sidebar() {
 
 // ── App ──────────────────────────────────────────────────────────────────────
 
-client({
+mountClient({
   name: "Solo RPG",
   icon: (
     <span style={{ fontSize: "28px", color: C.accent }}>
@@ -805,7 +805,7 @@ client({
 });
 
 // No `onSessionId`/`resumeSessionId` here any more, and their removal is a FIX
-// rather than a simplification. `createSessionCore` remembers the id in
+// rather than a simplification. `createBrowserSession` remembers the id in
 // `sessionStorage` by default now — see `session-resume-store.ts`, whose doc
 // names this template as the one client of fourteen that had wired it by hand.
 // What it had wired was `localStorage`, which is the wrong store for a pointer

package/dist/templates/spoken-summary/agent.test.ts

@@ -17,9 +17,9 @@
  * its return value, and audio in one is megabytes replayed on every resume.
  */
 
-import { readUpload, uploadInfo } from "@alexkroman1/aai/step";
+import { stepReadUpload, stepUploadInfo } from "@alexkroman1/aai/step";
 import { FatalError, RetryableError } from "@alexkroman1/aai/step-errors";
-import { createWorkflowCtx, stubGatewayRoute } from "@alexkroman1/aai/testing";
+import { createWorkflowContext, stubGatewayRoute } from "@alexkroman1/aai/testing";
 import {
   installStubGateway,
   installStubReporter,
@@ -55,13 +55,22 @@ describe("the declaration", () => {
   test("is a workflow app with the one workflow the page starts by name", () => {
     // The page calls `api.start("spokenSummary", …)`, so a rename here is a
     // runtime 400 rather than a compile error. This is what pins it.
-    expect(Object.keys(agentDef.workflows ?? {})).toEqual(["spokenSummary"]);
+    // `toContain` rather than an exact key list: adding a second workflow is an
+    // invited edit and must not redden a test the author did not write. The
+    // NAME is still pinned, deliberately — the page starts a run by this
+    // string, so renaming the key is a runtime 400 rather than a compile
+    // error, and this pin is the only thing that says so. Rename it here and
+    // in `client.tsx` together.
+    expect(Object.keys(agentDef.workflows ?? {})).toContain("spokenSummary");
+    expect(agentDef.workflows?.spokenSummary).toBe(spokenSummary);
   });
 
-  test("declares no providers and exactly the one credential its steps read", () => {
+  test("declares the credential its steps read, so a deploy checks for it", () => {
     // A workflow app has no session, so nothing else in its config could name
     // one — and one AssemblyAI key covers transcription, the model and the voice.
-    expect(agentDef.requiredEnv).toEqual(["ASSEMBLYAI_API_KEY"]);
+    // `toContain`, so adding a step that reads a second credential and
+    // declaring it here does not fail this test.
+    expect(agentDef.requiredEnv).toContain("ASSEMBLYAI_API_KEY");
   });
 
   test("takes the recording as an UPLOAD, which is what makes the form a file picker", () => {
@@ -206,14 +215,14 @@ describe("speaking", () => {
 
     const { audio } = await speak("Hello.");
 
-    await expect(uploadInfo(audio)).resolves.toMatchObject({
+    await expect(stepUploadInfo(audio)).resolves.toMatchObject({
       name: "summary.wav",
       // The byte route serves this as `Content-Type`, and a browser will not
       // play inline a file it was handed as octet-stream.
       type: "audio/wav",
       size: 44 + 4000,
     });
-    const { bytes } = await readUpload(audio, { end: 12 });
+    const { bytes } = await stepReadUpload(audio, { end: 12 });
     expect(String.fromCharCode(...bytes.subarray(0, 4))).toBe("RIFF");
     expect(String.fromCharCode(...bytes.subarray(8, 12))).toBe("WAVE");
   });
@@ -283,7 +292,7 @@ describe("the whole run", () => {
     installStubReporter();
     installStubSpeech();
 
-    const summary = await spokenSummaryFlow({ recording: UPLOAD_ID }, createWorkflowCtx());
+    const summary = await spokenSummaryFlow({ recording: UPLOAD_ID }, createWorkflowContext());
 
     expect(summary).toEqual({
       source: "standup.wav",
@@ -305,7 +314,7 @@ describe("the whole run", () => {
     installStubReporter();
     const speech = installStubSpeech();
 
-    await spokenSummaryFlow({ recording: UPLOAD_ID, voice: "michael" }, createWorkflowCtx());
+    await spokenSummaryFlow({ recording: UPLOAD_ID, voice: "michael" }, createWorkflowContext());
 
     expect(speech.calls[0]).toMatchObject({ text: "Spoken.", voice: "michael" });
   });
@@ -315,9 +324,9 @@ describe("the whole run", () => {
     installStubReporter();
     installStubSpeech();
 
-    await expect(spokenSummaryFlow({ recording: UPLOAD_ID }, createWorkflowCtx())).rejects.toThrow(
-      "corrupt audio",
-    );
+    await expect(
+      spokenSummaryFlow({ recording: UPLOAD_ID }, createWorkflowContext()),
+    ).rejects.toThrow("corrupt audio");
   });
 });
 

package/dist/templates/spoken-summary/agent.ts

@@ -24,7 +24,7 @@
  *   event stream wired into a live pipeline's playback, with a turn tracker and
  *   barge-in behind it, and a step has no turn to be part of and has to return
  *   a VALUE.
- * - **`writeUpload`** (same subpath) puts that value where a browser can reach
+ * - **`stepWriteUpload`** (same subpath) puts that value where a browser can reach
  *   it. A run's OUTPUT is read back as JSON, so audio cannot travel in one —
  *   the same rule that keeps a recording's bytes out of a run's INPUT, arriving
  *   at the other end of the run.
@@ -54,7 +54,7 @@
  * `POST /workflows/uploads` (the browser does this for you: `uploads` below is
  * what makes `<WorkflowFields>` render a file picker, and `useWorkflowSubmit`
  * stores the file before starting the run), the input carries the returned id,
- * and the step that needs the bytes streams them out with `readUpload`.
+ * and the step that needs the bytes streams them out with `stepReadUpload`.
  *
  * ## It is scriptable, which is the other half of having an API
  *
@@ -140,7 +140,7 @@ export const spokenSummary: WorkflowDef<typeof spokenSummaryInput, SpokenSummary
   input: spokenSummaryInput,
   // The one line that makes the form take a file: `<WorkflowFields>` renders a
   // picker for this property, `useWorkflowSubmit` stores the chosen file, and
-  // the step that transcribes it reads it back with `readUpload`.
+  // the step that transcribes it reads it back with `stepReadUpload`.
   uploads: ["recording"],
   run: spokenSummaryFlow,
 });

package/dist/templates/spoken-summary/client.tsx

@@ -37,14 +37,15 @@
  * in React state — so a refresh lost it while the recording carried on being
  * transcribed, summarized and spoken. The bytes were already stored, so the
  * expensive half had happened; what an empty form invites is somebody uploading
- * the recording again and paying for all four legs twice. `key` is the handle
- * that survives a reload, `recover: true` is what reads it back, and the upload
- * half is already the SDK's — picking the same file again sends only the windows
- * that did not land.
+ * the recording again and paying for all four legs twice. Both halves are the
+ * SDK's now and this page writes neither: `useWorkflowSubmit` records the run
+ * under a correlation KEY it keeps for this page and asks for it again on the
+ * next load, and picking the same file again sends only the windows that did
+ * not land.
  *
- * **The key is `useRunKey()`** — opaque, and in `sessionStorage`, which is the
- * same lifetime as that upload recall, so both halves of a reload make the same
- * promise. What that rules out is a `?key=` parameter, and it is worth being
+ * **That key is `useRunKey()`'s** — opaque, and in `sessionStorage`, which is
+ * the same lifetime as the upload recall, so both halves of a reload make the
+ * same promise. What it rules out is a `?key=` parameter, and it is worth being
  * plain about the trade because this template exists to produce something
  * sendable: a summary you can listen to is exactly the sort of thing somebody
  * forwards, and a URL is how people forward things. But there is no per-user
@@ -57,9 +58,9 @@
  * the recording would be worse again: two people summarizing one file would
  * recover each other's runs.
  *
- * A real app with accounts passes the account's own id instead, and then a
- * summary follows the person to another device — a promise only a login can
- * keep.
+ * A real app with accounts passes the account's own id as `key` instead, and
+ * then a summary follows the person to another device — a promise only a login
+ * can keep.
  */
 
 import "@alexkroman1/aai-ui/styles.css";
@@ -68,18 +69,18 @@ import "@alexkroman1/aai-ui/styles.css";
 // `workflows/summarize.ts` already declares.
 import { formatDuration } from "@alexkroman1/aai/utils";
 import {
+  BulletList,
   createWorkflowApi,
+  Facts,
   Form,
-  page,
+  mountPage,
   SubmitButton,
   UploadProgressBar,
   useDownloadUrl,
-  useRunKey,
   useWorkflowSubmit,
   WorkflowFields,
   WorkflowProgress,
 } from "@alexkroman1/aai-ui";
-import { useState } from "react";
 import type { spokenSummary } from "./agent.ts";
 
 /**
@@ -128,20 +129,11 @@ function captionsUrl(text: string, durationMs: number): string {
 }
 
 export function App() {
-  // This tab's handle on its own summaries, in the store the upload recall uses
-  // — see the module doc for why a `?key=` is the wrong trade here.
-  const key = useRunKey();
-  // Did THIS load start the run? A reload cannot have, and that is the only way
-  // the page can tell "working on what you just sent" from "picking up where
-  // you left off" — the hook reports the run, not who asked for it.
-  const [startedHere, setStartedHere] = useState(false);
   // The generic is what makes `run.status === "completed"` narrow to a TYPED
-  // `run.output` instead of `unknown`. Neither half of the recovery is useful
-  // alone: without `key` there is nothing to find the run by, and without
-  // `recover` the key is only ever written.
-  const { submitForm, run, pending, upload, pauseUpload, resumeUpload, error } = useWorkflowSubmit<
-    typeof spokenSummary
-  >(WORKFLOW, { api, key, recover: true });
+  // `run.output` instead of `unknown`. The reload is the hook's own doing — see
+  // the module doc for why the key it mints is the right one for this page.
+  const { submitForm, run, pending, upload, pauseUpload, resumeUpload, error, startedHere } =
+    useWorkflowSubmit<typeof spokenSummary>(WORKFLOW, { api });
   const output = run?.status === "completed" ? run.output : undefined;
   // `useDownloadUrl` is the SDK's: the byte route takes the agent's bearer, so the
   // bytes have to be FETCHED and handed to the element as an object URL — and the
@@ -157,14 +149,7 @@ export function App() {
         </p>
       </header>
 
-      <Form
-        onSubmit={(values) => {
-          setStartedHere(true);
-          return submitForm(values);
-        }}
-        error={error}
-        className="flex flex-col gap-4"
-      >
+      <Form onSubmit={(values) => submitForm(values)} error={error} className="flex flex-col gap-4">
         {/* Every control, from the workflow's own input schema. See the module doc. */}
         <WorkflowFields workflow={WORKFLOW} />
         <SubmitButton pending={pending} pendingLabel="Working…">
@@ -184,25 +169,27 @@ export function App() {
           nothing for `<WorkflowProgress>` to read. */}
       <UploadProgressBar upload={upload} onPause={pauseUpload} onResume={resumeUpload} />
 
-      {/* What the run itself says, from `report()` in the workflow's steps. */}
+      {/* What the run itself says, from `stepReport()` in the workflow's steps. */}
       <WorkflowProgress runId={run?.runId} api={api} />
 
-      {run?.status === "failed" && <p className="text-red-600">That one failed: {run.error}</p>}
+      {/* `role="alert"`, the same contract `<Form>` gives the submit error: this
+          is the outcome the reader waited minutes for. */}
+      {run?.status === "failed" && (
+        <p role="alert" className="text-red-600">
+          That one failed: {run.error}
+        </p>
+      )}
 
       {output !== undefined && (
         <article className="flex flex-col gap-5">
           <div className="flex flex-col gap-1">
             <h2 className="text-xl">{output.headline}</h2>
-            <p className="text-sm opacity-70">
-              {output.source} · {formatDuration(output.durationMs)} · {output.words} words
-            </p>
+            <Facts
+              items={[output.source, formatDuration(output.durationMs), `${output.words} words`]}
+            />
           </div>
 
-          <ul className="flex list-disc flex-col gap-1 pl-5">
-            {output.points.map((point) => (
-              <li key={point}>{point}</li>
-            ))}
-          </ul>
+          <BulletList items={output.points} />
 
           <section className="flex flex-col gap-2">
             <h3 className="text-sm font-medium opacity-70">
@@ -210,11 +197,13 @@ export function App() {
             </h3>
             {audio.pending && <p className="text-sm opacity-70">Fetching the audio…</p>}
             {audio.error !== undefined && (
-              <p className="text-red-600">Could not load the audio: {audio.error}</p>
+              <p role="alert" className="text-red-600">
+                Could not load the audio: {audio.error}
+              </p>
             )}
             {audio.url !== undefined && (
               <>
-                <audio controls src={audio.url} className="w-full">
+                <audio aria-label="Summary read aloud" controls src={audio.url} className="w-full">
                   {/* A real caption track, not a suppression: the summary was
                       written before it was spoken, so the words are already
                       here and one cue spanning the clip is an honest
@@ -248,4 +237,4 @@ export function App() {
   );
 }
 
-page({ name: "Spoken Summary", component: App });
+mountPage({ name: "Spoken Summary", component: App });

package/dist/templates/spoken-summary/workflows/summarize.ts

@@ -18,7 +18,7 @@
  * - **`stepSpeak`** synthesizes from inside a step. The session TTS surface
  *   cannot: a `TtsSession` is an event stream wired into a live pipeline's
  *   playback, and a step has no turn to be part of and has to return a VALUE.
- * - **`writeUpload`** puts that value somewhere. A run's OUTPUT is read back as
+ * - **`stepWriteUpload`** puts that value somewhere. A run's OUTPUT is read back as
  *   JSON, so audio cannot travel in one — the same rule that keeps a
  *   recording's bytes out of a run's INPUT, arriving at the other end of the
  *   run. The bytes go to the store, the output carries the id, and the page
@@ -49,9 +49,9 @@
  * expensive one.
  */
 
-import type { WorkflowCtx } from "@alexkroman1/aai";
-import { report, stepSpeak, TRANSCRIBE_API, writeUpload } from "@alexkroman1/aai/step";
-import { stepGenerateJsonClassified } from "@alexkroman1/aai/step-errors";
+import type { WorkflowContext } from "@alexkroman1/aai";
+import { stepReport, stepSpeak, stepWriteUpload, TRANSCRIBE_API } from "@alexkroman1/aai/step";
+import { stepGenerateJsonOrFail } from "@alexkroman1/aai/step-errors";
 import { countWords, omitUndefined } from "@alexkroman1/aai/utils";
 // ERASED at build time, so the body can name the schema's own output type without
 // a runtime cycle back through `agent.ts` — the same mechanism `client.tsx` uses
@@ -128,7 +128,7 @@ export type SpokenSummary = {
 /** Transcribe a recording, summarize it, and read the summary back. */
 export async function spokenSummaryFlow(
   input: WorkflowInputOf<typeof spokenSummary>,
-  ctx: WorkflowCtx,
+  ctx: WorkflowContext,
 ): Promise<SpokenSummary> {
   const transcript = await transcribe(input.recording, ctx);
   const summary = await ctx.step("summarize", () => summarize(transcript.text));
@@ -157,7 +157,7 @@ export async function spokenSummaryFlow(
  * re-derives exactly the same sequence. It takes the `ctx` for that reason: a
  * helper that reaches the journal has to be handed the handle.
  */
-async function transcribe(recording: string, ctx: WorkflowCtx): Promise<Transcript> {
+async function transcribe(recording: string, ctx: WorkflowContext): Promise<Transcript> {
   // `maxAttempts: 6` was `uploadToProvider.maxRetries = 5` — five retries after
   // the first attempt. It is the one step here worth extra patience: it streams
   // the whole recording, so a transient failure is expensive to reach again.
@@ -187,8 +187,8 @@ async function transcribe(recording: string, ctx: WorkflowCtx): Promise<Transcri
 export async function summarize(
   text: string,
 ): Promise<{ headline: string; points: string[]; spoken: string }> {
-  await report("Summarizing the transcript.");
-  const reply = await stepGenerateJsonClassified(
+  await stepReport("Summarizing the transcript.");
+  const reply = await stepGenerateJsonOrFail(
     "Summarize this transcript of a recording.\n\n" +
       "Answer with JSON only, in this shape:\n" +
       `{"headline": "...", "points": ["..."], "spoken": "..."}\n\n` +
@@ -204,7 +204,7 @@ export async function summarize(
       system: "You summarize recordings. You answer with JSON and nothing else.",
       schema: SummaryReply,
     },
-    // The `Classified` caller is `stepGenerateJson` plus `throwStepError`, which
+    // The `OrFail` caller is `stepGenerateJson` plus `throwStepError`, which
     // reads the gateway's own status: a 429 is worth another attempt and a 400
     // is not, and that is what tells the DevKit which.
   );
@@ -226,7 +226,7 @@ export async function speak(
   voice?: string,
 ): Promise<{ audio: string; durationMs: number }> {
   const spoken = await stepSpeak(script, omitUndefined({ voice }));
-  const stored = await writeUpload(spoken.audio, {
+  const stored = await stepWriteUpload(spoken.audio, {
     // Named, because this is what a person sees on the download link rather
     // than an opaque id — and typed, because the byte route serves the type it
     // was given and a browser will not play a file it was handed as bytes.
@@ -234,7 +234,7 @@ export async function speak(
     type: "audio/wav",
   });
 
-  await report(
+  await stepReport(
     `Recorded a ${Math.round(spoken.durationMs / 1000)}s summary in ${spoken.voice}'s voice.`,
   );
   return { audio: stored.id, durationMs: spoken.durationMs };

package/dist/templates/spoken-summary/workflows/transcribe.ts

@@ -12,7 +12,7 @@
  *
  * **Every one of them is four lines, because the SDK owns the endpoint.**
  * `stepTranscribeUpload` / `stepTranscribeSubmit` / `stepTranscribePoll` on
- * `@alexkroman1/aai/step` — reached here through their `*Classified` callers on
+ * `@alexkroman1/aai/step` — reached here through their `*OrFail` callers on
  * `@alexkroman1/aai/step-errors` — carry the URL, the raw-key auth, the windowed
  * streaming upload, the PLURAL `speech_models` field and the failure
  * classification — all of which this file used to spell out, and all of which
@@ -40,11 +40,11 @@
  * the one leg that should be as boring as possible.
  */
 
-import { report, uploadInfo } from "@alexkroman1/aai/step";
+import { stepReport, stepUploadInfo } from "@alexkroman1/aai/step";
 import {
-  stepTranscribePollClassified,
-  stepTranscribeSubmitClassified,
-  stepTranscribeUploadClassified,
+  stepTranscribePollOrFail,
+  stepTranscribeSubmitOrFail,
+  stepTranscribeUploadOrFail,
 } from "@alexkroman1/aai/step-errors";
 import { countWords, formatBytes } from "@alexkroman1/aai/utils";
 
@@ -85,24 +85,24 @@ export type Transcript = {
  * expires before the next step runs; that costs one fresh upload, once, instead
  * of five.
  *
- * The `Classified` callers on `@alexkroman1/aai/step-errors` are the SDK's own
+ * The `OrFail` callers on `@alexkroman1/aai/step-errors` are the SDK's own
  * `stepTranscribe*` plus `throwStepError` and nothing else, which is what turns
  * the SDK's `TranscribeError` into the DevKit's verdict — a missing key and a
  * 400 stop, a 429 waits as long as the service asked. Every step here ends the
  * same way for the same reason.
  */
 export async function uploadToProvider(uploadId: string): Promise<{ audioUrl: string }> {
-  const stored = await uploadInfo(uploadId);
-  await report(
+  const stored = await stepUploadInfo(uploadId);
+  await stepReport(
     `Uploading ${stored.name || uploadId} (${formatBytes(stored.size)}) for transcription.`,
   );
-  return await stepTranscribeUploadClassified(uploadId);
+  return await stepTranscribeUploadOrFail(uploadId);
 }
 
 /** Create the transcription job, and answer with the id that outlives this run. */
 export async function createJob(audioUrl: string): Promise<{ id: string }> {
-  const job = await stepTranscribeSubmitClassified(audioUrl);
-  await report(`Transcribing — job ${job.id}.`);
+  const job = await stepTranscribeSubmitOrFail(audioUrl);
+  await stepReport(`Transcribing — job ${job.id}.`);
   return job;
 }
 
@@ -119,11 +119,11 @@ export async function pollTranscript(
   uploadId: string,
   id: string,
 ): Promise<{ done: false } | { done: true; transcript: Transcript }> {
-  const progress = await stepTranscribePollClassified(id);
+  const progress = await stepTranscribePollOrFail(id);
   if (!progress.done) return { done: false };
 
-  const stored = await uploadInfo(uploadId);
-  await report(`Transcribed ${countWords(progress.transcript.text)} words.`);
+  const stored = await stepUploadInfo(uploadId);
+  await stepReport(`Transcribed ${countWords(progress.transcript.text)} words.`);
   return {
     done: true,
     transcript: {

package/dist/templates/support-line/client.tsx

@@ -1,5 +1,6 @@
+import { plural } from "@alexkroman1/aai/utils";
 import "@alexkroman1/aai-ui/styles.css";
-import { AutoScroll, client, useAgentState } from "@alexkroman1/aai-ui";
+import { AutoScroll, mountClient, useAgentState } from "@alexkroman1/aai-ui";
 import { PRODUCT, supportProjection } from "./shared.ts";
 
 /**
@@ -19,7 +20,7 @@ function TraceSidebar() {
       <div>
         <h3 className="text-sm font-bold uppercase tracking-wide opacity-60">{support.product}</h3>
         <p className="text-xs opacity-50">
-          {support.asked.length} question{support.asked.length === 1 ? "" : "s"} this call
+          {support.asked.length} {plural(support.asked.length, "question")} this call
           {support.ticket ? ` · ticket ${support.ticket}` : ""}
         </p>
       </div>
@@ -97,7 +98,7 @@ function TraceSidebar() {
   );
 }
 
-client({
+mountClient({
   // Derived, not typed twice: `PRODUCT` comes off `knowledge.json`, which is
   // what `agent.ts` names the agent and greets with. A knowledge base swapped
   // for another product otherwise leaves the browser tab advertising the old

package/dist/templates/support-line/prompts.ts

@@ -40,8 +40,6 @@ export const binaryScore = z.object({
   reason: z.string().max(200).describe("One short sentence of justification"),
 });
 
-export type BinaryScore = z.infer<typeof binaryScore>;
-
 /** Their `retrieval_grader`: deliberately NOT a stringent test. */
 export const DOC_GRADER_SYSTEM = [
   "You are a grader assessing whether a retrieved support document is relevant",