@alexkroman1/aai-cli 13.0.0 → 13.2.0

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

@@ -48,6 +48,7 @@
 // exercised. `run.slept` below is the other half of that admission written as
 // an assertion. `aai-cli`'s `dev-workflow.scenario.test.ts` is the tier that
 // really suspends and resumes a run.
+import { stubGatewayRoute } from "@alexkroman1/aai/testing";
 import {
   installStubSpeech,
   installStubTranscribe,
@@ -115,23 +116,30 @@ function publish(bytes: Uint8Array, name: string, type: string) {
  *
  * ONE fake, because publishing a `stepFetch` REPLACES — a flow that transcribes
  * AND calls a model cannot install two, which is exactly what `otherwise` is
- * for. The transcription half is the SDK's own fake rather than this file's
- * hand-typed wire: it routes off the SDK's endpoint constants, so a case cannot
- * pass because the fake and the step agree on a typo.
+ * for. BOTH halves are the SDK's own fakes rather than this file's hand-typed
+ * wire, and it is the same argument twice: each routes off the SDK's own
+ * endpoint constant, so a case cannot pass because the fake and the step agree
+ * on a typo. The predicate here used to be `url.includes("llm-gateway")` — a
+ * HOST, which the default gateway happens to carry and a `gatewayUrl` pointed
+ * anywhere else does not, so the fake would have gone on answering the
+ * transcription 404 to a model call it no longer recognised.
+ *
+ * The reader also hands back DECODED calls, which is why the case below asks
+ * `model.calls[0].prompt` what the model was SHOWN: off a raw request body that
+ * is the whole serialized request, `model` and `reasoning_effort` included.
  */
 function scriptProvider(options: { text?: string; pendingPolls?: number } = {}) {
-  return installStubTranscribe({
+  const model = stubGatewayRoute(JSON.stringify(REPLY));
+  const provider = installStubTranscribe({
     text: options.text ?? TRANSCRIPT,
     durationSec: 42,
     // Passed straight through rather than conditionally spread: the option
     // already admits `undefined`, and `guard-invariants` rule 2 counts the
     // spread.
     pendingPolls: options.pendingPolls,
-    otherwise: (request) =>
-      request.url.includes("llm-gateway")
-        ? { body: { choices: [{ message: { content: JSON.stringify(REPLY) } }] } }
-        : undefined,
+    otherwise: (request) => model.route(request),
   });
+  return { provider, model };
 }
 
 describeWorkflowEval(
@@ -144,7 +152,7 @@ describeWorkflowEval(
       // returned bytes, or an id nothing wrote, or two ids because the synthesis
       // and the store became two steps.
       const uploads = publish(new Uint8Array(64), "standup.wav", "audio/wav");
-      const provider = scriptProvider();
+      const { provider } = scriptProvider();
       const speech = installStubSpeech({ pcmBytes: 96_000 });
 
       const run = await app.run(spokenSummary, { recording: UPLOAD_ID });
@@ -207,7 +215,7 @@ describeWorkflowEval(
       // central prompt decision regressing — synthesize the bullet list and you
       // get a voice reading "one. two. three." with no connective tissue.
       publish(new Uint8Array(64), "standup.wav", "audio/wav");
-      const provider = scriptProvider();
+      const { model } = scriptProvider();
       const speech = installStubSpeech();
 
       const run = await app.run(spokenSummary, { recording: UPLOAD_ID, voice: "michael" });
@@ -226,9 +234,10 @@ describeWorkflowEval(
 
       // And the model was ASKED for both, over the transcript it was given. A
       // prompt that stopped asking for a script is how the field goes missing.
-      const prompt = String(provider.calls.find((call) => call.leg === "other")?.body ?? "");
-      expect(prompt).toContain("READ ALOUD");
-      expect(prompt).toContain("The launch is on for Tuesday the fourth");
+      const asked = model.calls[0];
+      if (asked === undefined) expect.fail("the run must have asked the model for a summary");
+      expect(asked.prompt).toContain("READ ALOUD");
+      expect(asked.prompt).toContain("The launch is on for Tuesday the fourth");
     });
 
     test("a recording with no speech stops before the model and the voice", async ({ app }) => {
@@ -237,7 +246,7 @@ describeWorkflowEval(
       // the run would go on to summarize no words and store half a second of
       // audio — a green run with an empty product.
       const uploads = publish(new Uint8Array(64), "silence.wav", "audio/wav");
-      const provider = scriptProvider({ text: "   " });
+      const { model } = scriptProvider({ text: "   " });
       const speech = installStubSpeech();
 
       const run = await app.run(spokenSummary, { recording: UPLOAD_ID });
@@ -247,7 +256,7 @@ describeWorkflowEval(
       expect(run.output).toBeUndefined();
       // Nothing was summarized and nothing was spoken, which is the half that
       // makes this more than an error-message assertion.
-      expect(provider.calls.filter((call) => call.leg === "other")).toEqual([]);
+      expect(model.calls).toEqual([]);
       expect(speech.calls).toEqual([]);
       expect(uploads.writes).toEqual([]);
       expect(run.reported).not.toContain("Summarizing the transcript.");
@@ -262,7 +271,7 @@ describeWorkflowEval(
       // them. A loop that re-submitted, or one that spun with no wait, both
       // produce a correct transcript and a wrong bill.
       publish(new Uint8Array(64), "standup.wav", "audio/wav");
-      const provider = scriptProvider({ pendingPolls: 2 });
+      const { provider } = scriptProvider({ pendingPolls: 2 });
       installStubSpeech();
 
       const run = await app.run(spokenSummary, { recording: UPLOAD_ID });

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

@@ -257,15 +257,20 @@ describe("the whole run", () => {
    * spec cannot pass because the fake and the step agree on a typo.
    */
   function stubProvider(reply: { headline: string; points: string[]; spoken: string }) {
+    // The model leg goes through `stubGatewayRoute` for the same reason, which
+    // this helper used to claim and not do: it hand-typed the completion
+    // envelope and recognised a model call by `llm-gateway`, the HOST. That is a
+    // property of one deployment rather than of the request — `stepGenerate`
+    // dials `${gatewayUrl ?? ASSEMBLYAI_LLM_GATEWAY_URL}/chat/completions`, so a
+    // caller pointing `gatewayUrl` at an OpenAI-compatible proxy of their own
+    // stops matching and the transcription fake answers a 404 to a model call.
+    const model = stubGatewayRoute(JSON.stringify(reply));
     return installStubTranscribe({
       audioUrl: "https://cdn/aai/1",
       jobIdPrefix: "t_",
       text: "we ship tuesday and two bugs are left",
       durationSec: 42,
-      otherwise: (request) =>
-        request.url.includes("llm-gateway")
-          ? { body: { choices: [{ message: { content: JSON.stringify(reply) } }] } }
-          : undefined,
+      otherwise: (request) => model.route(request),
     });
   }
 

package/dist/templates/support-line/agent.eval.test.ts

@@ -27,7 +27,13 @@
 
 /** The def a DEPLOYED agent runs — see `agent.test.ts` on why the glob is here. */
 import agentDef from "virtual:aai/agent";
-import { type EvalSession, toolResultIn } from "@alexkroman1/aai-runtime/eval";
+import {
+  describeToolCalls,
+  describeTurn,
+  type EvalSession,
+  statesIn,
+  toolResultIn,
+} from "@alexkroman1/aai-runtime/eval";
 import { describeEval } from "@alexkroman1/aai-runtime/eval/vitest";
 import { expect } from "vitest";
 import { z } from "zod";
@@ -71,13 +77,14 @@ const Lookup = z.object({
   error: z.string().optional(),
 });
 
-/** Every `syncState` frame, in stream order. */
+/**
+ * Every `syncState` frame, in stream order.
+ *
+ * `statesIn` reads an EVENT LIST rather than a session, which is what lets a
+ * case slice the stream first; the schema above is what it takes one for.
+ */
 function frames(session: EvalSession) {
-  return session
-    .events()
-    .flatMap((event) =>
-      event.type === "state.updated" ? [ProjectedSupport.parse(event.state)] : [],
-    );
+  return statesIn(session.events(), ProjectedSupport);
 }
 
 /**
@@ -109,10 +116,10 @@ describeEval(agentDef, (test) => {
       // The reply rides in the message, because the failure that matters here is
       // a turn that SPOKE without looking anything up — "let me check that for
       // you" and then nothing, or worse, a notice period from memory.
-      expect(
-        asked.length,
-        `tools called: [${turn.toolCalls.map((c) => c.name).join(", ")}]; said: ${turn.text}`,
-      ).toBe(1);
+      // `describeTurn` is that sentence, and it says the two things a
+      // hand-built one left out: "called no tools" rather than an empty
+      // bracket, and whether the reply was cancelled.
+      expect(asked.length, describeTurn(turn)).toBe(1);
 
       for (const payload of lookups(session)) {
         // Three legal outcomes, and the invariant that spans them: an answer the
@@ -142,13 +149,9 @@ describeEval(agentDef, (test) => {
       await session.say("Yes please, log that one — my callback number is 07700 900123.");
 
       const logged = session.toolCalls().find((call) => call.name === "log_ticket");
-      expect(
-        logged,
-        `tools called: ${session
-          .toolCalls()
-          .map((c) => c.name)
-          .join(", ")}`,
-      ).toBeDefined();
+      // The claim spans both turns, so the message does too: `describeToolCalls`
+      // over the session's own list, where `describeTurn` would describe one.
+      expect(logged, describeToolCalls(session.toolCalls())).toBeDefined();
       expect(logged?.result).toMatch(/TCK\d{4}/);
 
       const latest = frames(session).at(-1);
@@ -189,10 +192,7 @@ describeEval(agentDef, (test) => {
       const turn = await session.say("How much notice do I have to give to cancel my contract?");
 
       const [payload] = lookups(session);
-      expect(
-        payload,
-        `tools called: [${turn.toolCalls.map((c) => c.name).join(", ")}]; said: ${turn.text}`,
-      ).toBeDefined();
+      expect(payload, describeTurn(turn)).toBeDefined();
       // The whole verdict in the message: `grounded: undefined` on its own does
       // not say whether the lookup failed, or ran and refused.
       const verdict = JSON.stringify(payload);
@@ -238,10 +238,7 @@ describeEval(agentDef, (test) => {
       );
 
       const [payload] = lookups(session);
-      expect(
-        payload,
-        `tools called: [${turn.toolCalls.map((c) => c.name).join(", ")}]; said: ${turn.text}`,
-      ).toBeDefined();
+      expect(payload, describeTurn(turn)).toBeDefined();
       // Withheld, not softened: `answer: null` is the tool refusing to hand the
       // model something to read out, and the guidance is the exit the grading
       // apparatus needs — a support line that can only answer will answer wrong.

package/dist/templates/transcription-workflow/agent.test.ts

@@ -779,6 +779,16 @@ describe("transcribeSegment", () => {
     expect(decoded).toContain('name="audio"; filename="segment-0.wav"');
     // The WAV really rides in the part, header and all.
     expect(decoded).toContain("RIFF");
+    // And the header is CONTIGUOUS with its samples, which is what the two-chunk
+    // form (`[wavHeader(…), window]`) has to preserve and the only thing it could
+    // plausibly lose: the part's payload is exactly the 44 bytes plus the window,
+    // with nothing between them and nothing appended. A body that grew or shrank
+    // here is a file the endpoint decodes into confident nonsense rather than
+    // refusing.
+    const latin = new TextDecoder("latin1").decode(sent);
+    const from = latin.indexOf("RIFF");
+    const to = latin.lastIndexOf("\r\n--");
+    expect(to - from).toBe(44 + (SEGMENT.end - SEGMENT.start));
   });
 
   test("sends the DOWNSAMPLED window when the recording is heavier than 16 kHz mono", async () => {

package/dist/templates/transcription-workflow/workflows/normalize.ts

@@ -159,7 +159,16 @@ export async function normalizeRecording(uploadId: string): Promise<NormalizedRe
       const source = join(dir, "source");
       const converted = join(dir, "converted.wav");
 
-      await readUploadToFile(uploadId, source, { size: stored.size });
+      // NO `size`, though `stored.size` is right there — and that is the whole
+      // difference between this copy being one window at a time and being
+      // `STEP_FILE_READ_CONCURRENCY` of them. Passing `size` means "I am judging
+      // completeness myself", which is what a body polling a still-arriving
+      // upload needs and is the opposite of what happened above: this step has
+      // already called `requireCompleteUpload`, so the file IS whole and the
+      // windows may land in any order. Omitting it lets `readUploadToFile`
+      // establish that for itself and fan out. The cost is one metadata round
+      // trip, against the dozens of window reads it overlaps.
+      await readUploadToFile(uploadId, source);
 
       // What it WAS, for the progress line. Worth one ffprobe: "converted 41
       // minutes of aac" is a line that explains the run's shape, where

package/dist/templates/transcription-workflow/workflows/sync-api.ts

@@ -52,7 +52,10 @@ export function elapsed(ms: number): string {
  * `bytes` must be a whole file, header included — the endpoint decodes each
  * request independently, so a headerless tail is bytes it will refuse. Both
  * callers arrive at that differently: one re-attaches a header to a window it
- * read, the other is handed parts that already carry one.
+ * read, the other is handed parts that already carry one. A LIST is a whole
+ * file too: the segment caller passes `[wavHeader(...), window]` so the two are
+ * concatenated straight into the request body rather than into an intermediate
+ * buffer that doubles the segment's footprint.
  *
  * `stepTranscribeSyncClassified` — the SDK's own `stepTranscribeSync` plus
  * `throwStepError`, and nothing else — is the whole of what this adds to the SDK
@@ -68,7 +71,7 @@ export function elapsed(ms: number): string {
  *   log has in front of them.
  */
 export async function transcribeWav(
-  bytes: Uint8Array,
+  bytes: Uint8Array | readonly Uint8Array[],
   filename: string,
   label: string,
 ): Promise<string> {

package/dist/templates/transcription-workflow/workflows/transcribe.ts

@@ -66,12 +66,12 @@
 import type { WorkflowCtx } from "@alexkroman1/aai";
 import {
   emit,
-  encodeWav,
   mapConcurrent,
   readUpload,
   report,
   requireCompleteUpload,
   uploadInfo,
+  wavHeader,
 } from "@alexkroman1/aai/step";
 import { throwFatalStepError } from "@alexkroman1/aai/step-errors";
 import { countWords, formatDuration, plural } from "@alexkroman1/aai/utils";
@@ -358,13 +358,20 @@ export async function transcribeSegment(
   // answers better — and getting it wrong is a whole transcript in the wrong
   // language. Add one back only for a desk that really knows.
   //
-  // `encodeWav` is what makes a WINDOW decodable: the endpoint decodes each
+  // A HEADER is what makes a WINDOW decodable: the endpoint decodes each
   // request independently, so a slice of the middle of a recording is a headerless
   // tail until one is put back on it. The streaming flow needs no equivalent — its
   // parts were cut with a header each. The header is the SDK's rather than this
   // template's: a `WavFormat` is structurally a `PcmFormat`, and 22 lines of
   // `DataView` writes with a comment about which of the two declared lengths a
   // decoder trusts is not a thing worth a second copy of.
+  // It goes down as its own CHUNK rather than through `encodeWav`, which is a
+  // MEMORY decision and not a speed one: `encodeWav` allocates `44 + N` and
+  // copies the segment into it, and `multipartBody` then allocates the body and
+  // copies that again — so the audio was resident three times at the moment the
+  // request went out, on a fan-out whose width is set by exactly that peak (see
+  // `MAX_SEGMENT_CONCURRENCY`). Header and samples are contiguous on the wire
+  // either way; this holds `44 + N` once, ~3 MB per in-flight 16 kHz segment.
   // Down to 16 kHz mono BEFORE the header goes on, because the endpoint's budget
   // is 30 seconds of wall clock and that covers the upload. At 48 kHz stereo this
   // window is 17.66 MB and the same audio is 2.94 MB normalized — six times the
@@ -382,12 +389,12 @@ export async function transcribeSegment(
   // identical answer. BOTH flows can reach it, which is newer than it looks:
   // the check used to hang off the resampler, so a 12-bit recording already at
   // 16 kHz mono — light for both flows, and therefore converted by neither —
-  // sailed past it into an unclassified `RangeError` from `encodeWav`.
+  // sailed past it into an unclassified `RangeError` from the header writer.
   const light = fatalOnUnsupported(() => downsampleSegment(audio.bytes, format));
 
   const { value: text, ms } = await timed(() =>
     transcribeWav(
-      encodeWav(light.bytes, light.format),
+      [wavHeader(light.format, light.bytes.byteLength), light.bytes],
       `segment-${segment.index}.wav`,
       `Segment ${segment.index} (${formatDuration(segment.startMs)})`,
     ),

package/dist/templates/travel-concierge/agent.eval.test.ts

@@ -29,7 +29,15 @@
  * tools and read as a model that refuses to act.
  */
 import agentDef from "virtual:aai/agent";
-import { type EvalSession, type EvalTurn, lastStateIn } from "@alexkroman1/aai-runtime/eval";
+import {
+  callsIn,
+  describeTurn,
+  type EvalSession,
+  type EvalToolCall,
+  lastStateIn,
+  toolNames,
+  turnCalling,
+} from "@alexkroman1/aai-runtime/eval";
 import { describeEval } from "@alexkroman1/aai-runtime/eval/vitest";
 import { expect } from "vitest";
 import { z } from "zod";
@@ -76,33 +84,17 @@ function framesBeforeConfirm(session: EvalSession): z.infer<typeof ProjectedTrip
 const tripState = (session: EvalSession) => lastStateIn(session.events(), ProjectedTrip);
 
 /**
- * Drive a whole call, one caller line at a time, and hand back every turn.
+ * A call that really STAGED — it answered with the read-back rather than with a
+ * gate's refusal.
  *
- * The cases below assert about the turn a MECHANISM fired in rather than about
- * turn one, because how many turns a desk takes to get there is the model's
- * business and it moved when the desk gate landed: the flight desk's brief says
- * to search before quoting anything, so measured live this concierge now spends
- * its first turn on `to_flight_assistant` and `search_flights` and reads the
- * fare back before it stages. A case pinned to turn one is a flake with a
- * misleading name — the same argument `retail`'s eval carries.
+ * Passed to `turnCalling` as its `where`, so the turn a case reads is the one
+ * the MECHANISM fired in rather than turn one: how many turns a desk spends
+ * getting there is the model's business and it moved when the desk gate landed
+ * — the flight desk's brief says to search before quoting anything, so measured
+ * live this concierge spends its first turn on `to_flight_assistant` and
+ * `search_flights` and reads the fare back before it stages.
  */
-async function sayAll(session: EvalSession, lines: readonly string[]): Promise<EvalTurn[]> {
-  const turns: EvalTurn[] = [];
-  for (const line of lines) turns.push(await session.say(line));
-  return turns;
-}
-
-/** Every tool call of the call so far, flattened, in order. */
-const callsIn = (turns: readonly EvalTurn[]) => turns.flatMap((turn) => turn.toolCalls);
-
-/** The turn a named tool STAGED something in — the call that answered with the
- *  read-back rather than with a gate's refusal. */
-const stagingTurn = (turns: readonly EvalTurn[], tool: string) =>
-  turns.find((turn) =>
-    turn.toolCalls.some(
-      (call) => call.name === tool && /awaitingConfirmation/.test(call.result ?? ""),
-    ),
-  );
+const stagedSomething = (call: EvalToolCall) => /awaitingConfirmation/.test(call.result ?? "");
 
 describeEval(agentDef, (test) => {
   test(
@@ -112,28 +104,25 @@ describeEval(agentDef, (test) => {
       // a read-back: what is asserted below is that the turn which staged did
       // not also apply, so a line the model could read as consent ("correct",
       // "that's right") would be measuring the caller instead of the desk.
-      const turns = await sayAll(session, [
+      const turns = await session.sayAll([
         "Move my ticket to flight LX52, the Wednesday one.",
         "I want the Wednesday LX52 instead of the flight I'm on now.",
         "Put me on LX52 on Wednesday, please.",
       ]);
 
-      const staging = stagingTurn(turns, "update_ticket");
+      // A desk that talks its way through three turns without staging fails
+      // HERE — the failure this case caught while the flight desk's brief had
+      // the read-back before the staging — and `turnCalling`'s throw names
+      // every turn's tool list AND tells the two findings apart: no
+      // `update_ticket` at all, or calls that were all refused by the desk gate.
+      const staging = turnCalling(turns, "update_ticket", stagedSomething);
       const attempts = callsIn(turns).filter((call) => call.name === "update_ticket");
-      // Named with the whole call, tools AND text: "expected undefined to be
-      // defined" says nothing about a desk that talked its way through three
-      // turns without staging, which is exactly the failure this case caught
-      // while the flight desk's brief had the read-back before the staging.
-      expect(
-        staging,
-        turns
-          .map(
-            (turn, i) =>
-              `turn ${i + 1}: [${turn.toolCalls.map((c) => c.name).join(", ")}] said: ${turn.text}`,
-          )
-          .join("\n"),
-      ).toBeDefined();
-      const staged = staging?.toolCalls.find((call) => call.name === "update_ticket");
+      // The staging call itself, by INDEX, because what follows it in the same
+      // turn is the subject of the assertion below.
+      const stagedAt = staging.toolCalls.findIndex(
+        (call) => call.name === "update_ticket" && stagedSomething(call),
+      );
+      const staged = staging.toolCalls[stagedAt];
       // The tool answered with the read-back rather than with a receipt.
       expect(staged?.result).toMatch(/awaitingConfirmation/);
       // Any attempt that did NOT stage is the DESK GATE refusing:
@@ -154,14 +143,7 @@ describeEval(agentDef, (test) => {
       // refusal is the subject), and it then stages properly. That is a wasted
       // step rather than an unasked-for change, and folding the two together
       // would fail this case for the behaviour the next one proves is safe.
-      // Narrowed first: `indexOf` takes a value, and `staged` is optional — the
-      // rewrite Biome offers for `findIndex` over an identity is UNSAFE for
-      // exactly that reason, and the assertion above is what makes an absent
-      // staging call a failure rather than a slice from 0.
-      const stagedAt = staged === undefined ? -1 : (staging?.toolCalls.indexOf(staged) ?? -1);
-      expect(staging?.toolCalls.slice(stagedAt + 1).map((call) => call.name) ?? []).not.toContain(
-        "confirm_action",
-      );
+      expect(toolNames(staging.toolCalls.slice(stagedAt + 1))).not.toContain("confirm_action");
 
       const views = framesBeforeConfirm(session);
       const waiting = views.filter((view) => view.pending !== null);
@@ -212,7 +194,7 @@ describeEval(agentDef, (test) => {
       // it applies in is its own business — the flight desk's brief has it
       // search first — and saying yes repeatedly is what makes "once each"
       // below a claim about the MECHANISM rather than about the model's pacing.
-      await sayAll(session, [
+      await session.sayAll([
         "Move my ticket to flight LX52, the Wednesday one.",
         "Correct — LX52 on Wednesday. Please move my ticket to it.",
         "Yes, that's right — go ahead and change it.",
@@ -231,7 +213,7 @@ describeEval(agentDef, (test) => {
       );
       // Staged first, applied second, once each. Reversed — or a confirm with no
       // stage — is the regression this template's whole shape exists to prevent.
-      expect(effective.map((call) => call.name)).toEqual(["update_ticket", "confirm_action"]);
+      expect(toolNames(effective)).toEqual(["update_ticket", "confirm_action"]);
       // Everything else has to be a GATE refusing, and nothing else: the desk
       // gate turns away an `update_ticket` issued before
       // `to_flight_assistant`, and the confirmation gate turns away a
@@ -277,10 +259,9 @@ describeEval(agentDef, (test) => {
       // below and `indexOf` on a possibly-undefined find is worse than both.
       const handoffAt = turn.toolCalls.findIndex((call) => call.name === "to_hotel_assistant");
       const handoff = turn.toolCalls[handoffAt];
-      expect(
-        handoff,
-        `tools called: [${turn.toolCalls.map((c) => c.name).join(", ")}]; said: ${turn.text}`,
-      ).toBeDefined();
+      // `describeTurn` is the message a bare `toBeDefined()` failure leaves
+      // out: what this turn reached for, and what it said instead.
+      expect(handoff, describeTurn(turn)).toBeDefined();
       // The brief IS the tool result, which is the whole port of their
       // per-assistant prompt onto a session whose prompt is fixed at connect.
       expect(handoff?.result).toMatch(/hotel desk/);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexkroman1/aai-cli",
-  "version": "13.0.0",
+  "version": "13.2.0",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -52,9 +52,9 @@
     "p-timeout": "^7.0.1",
     "vite": "^8.2.2",
     "zod": "^4.5.4",
-    "@alexkroman1/aai": "13.0.0",
-    "@alexkroman1/aai-runtime": "13.0.0",
-    "@alexkroman1/aai-ui": "13.0.0"
+    "@alexkroman1/aai": "13.2.0",
+    "@alexkroman1/aai-runtime": "13.2.0",
+    "@alexkroman1/aai-ui": "13.2.0"
   },
   "devDependencies": {
     "playwright": "^1.62.1",