@alexkroman1/aai-cli 6.11.0 → 7.0.0

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

@@ -312,34 +312,3 @@ export function planSegments(format: WavFormat): Segment[] {
   }
   return segments;
 }
-
-/**
- * Put a canonical 44-byte WAV header in front of a slice of samples.
- *
- * A byte range of a WAV is raw PCM with no header, and the sync endpoint reads
- * the rate and channel count out of one. Sending `audio/pcm` with a `config`
- * part instead would work equally well; a header keeps the two parts of the
- * request from being able to disagree.
- */
-export function wavWithHeader(format: WavFormat, samples: Uint8Array): Uint8Array<ArrayBuffer> {
-  const out = new Uint8Array(44 + samples.length);
-  const view = new DataView(out.buffer);
-  const write = (at: number, text: string) => {
-    for (let i = 0; i < text.length; i++) view.setUint8(at + i, text.charCodeAt(i));
-  };
-
-  write(0, "RIFF");
-  view.setUint32(4, 36 + samples.length, true);
-  write(8, "WAVEfmt ");
-  view.setUint32(16, 16, true); // `fmt ` payload length
-  view.setUint16(20, 1, true); // linear PCM
-  view.setUint16(22, format.channels, true);
-  view.setUint32(24, format.sampleRate, true);
-  view.setUint32(28, bytesPerSecond(format), true);
-  view.setUint16(32, blockAlign(format), true);
-  view.setUint16(34, format.bitsPerSample, true);
-  write(36, "data");
-  view.setUint32(40, samples.length, true);
-  out.set(samples, 44);
-  return out;
-}

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

@@ -1,7 +1,13 @@
 /// <reference types="vite/client" />
 
 import type { ToolContext } from "@alexkroman1/aai";
-import { createToolContext, runTool, withDiscoveredTools } from "@alexkroman1/aai/testing";
+import {
+  createToolContext,
+  ok,
+  okPosition,
+  toolRunner,
+  withDiscoveredTools,
+} from "@alexkroman1/aai/testing";
 import { describe, expect, test } from "vitest";
 import authoredAgent from "./agent.ts";
 
@@ -18,7 +24,14 @@ const agentDef = withDiscoveredTools(
   import.meta.glob("./tools/*.ts", { eager: true }),
 );
 
-import { activeAssistant, FLIGHTS, tripProjection, tripSlot, tripView } from "./shared.ts";
+import {
+  activeAssistant,
+  FLIGHTS,
+  gateFlow,
+  tripProjection,
+  tripSlot,
+  tripView,
+} from "./shared.ts";
 
 // ─── Harness ─────────────────────────────────────────────────────────────────
 
@@ -26,11 +39,11 @@ import { activeAssistant, FLIGHTS, tripProjection, tripSlot, tripView } from "./
  *  below rests on. */
 const makeCtx = (): ToolContext => createToolContext();
 
-/** A tool by the name the model calls it by, bound to this agent. The lookup
- *  and its "no such tool" message are `runTool`'s (`@alexkroman1/aai/testing`);
- *  what is local is only which agent they run against. */
-const run = (name: string, args: Record<string, unknown>, ctx: ToolContext) =>
-  runTool(agentDef, name, args, ctx);
+/** A tool by the name the model calls it by, bound to this agent. The lookup,
+ *  its "no such tool" message and the args-or-context shape are all
+ *  `toolRunner`'s (`@alexkroman1/aai/testing`); what is local is only which
+ *  agent it runs against. */
+const run = toolRunner(agentDef);
 
 /** The state a tool just mutated, read back the way `syncState` reads it. */
 function stateOf(ctx: ToolContext) {
@@ -116,36 +129,47 @@ describe("sensitive tools stage rather than act", () => {
     const ctx = makeCtx();
     await run("book_hotel", { hotelId: "H1", nights: 3 }, ctx);
 
-    const applied = (await run("confirm_action", {}, ctx)) as {
-      applied: string;
-      reference: string;
-    };
-    expect(applied.applied).toContain("Harborview Suites");
+    // Staging moved the gate, in the same window it wrote `pending`.
+    expect(gateFlow.position(ctx).state).toBe("awaitingConfirmation");
+
+    // A gated tool answers the flow's POSITION wrapped around the body's own
+    // return value, so the applied sentence is under `result`. `okPosition`
+    // keeps the position and THROWS on a refusal, quoting it — where the cast
+    // it replaces read `undefined` off the failure and died three assertions
+    // later on a property of undefined.
+    const confirmed = okPosition<{ applied: string; reference: string }>(
+      await run("confirm_action", ctx),
+    );
+    expect(confirmed.result.applied).toContain("Harborview Suites");
     // 3 nights at $265.
-    expect(applied.applied).toContain("$795");
+    expect(confirmed.result.applied).toContain("$795");
+    // SETTLED: the gate re-armed as part of the same call.
+    expect(confirmed.state).toBe("browsing");
 
     const state = stateOf(ctx);
     expect(state.pending).toBeNull();
     expect(state.bookings).toHaveLength(1);
-    expect(state.bookings[0]?.reference).toBe(applied.reference);
+    expect(state.bookings[0]?.reference).toBe(confirmed.result.reference);
 
-    // The gate re-arms: a second confirm has nothing to apply.
-    expect(await run("confirm_action", {}, ctx)).toEqual({
-      error: "Nothing is waiting for confirmation. Use the booking tool first.",
+    // The gate re-arms, and now REFUSES rather than reporting an empty apply —
+    // `when: "awaitingConfirmation"` is what a second confirm meets.
+    expect(await run("confirm_action", ctx)).toMatchObject({
+      error: expect.stringContaining('this conversation is at "browsing"'),
     });
   });
 
   test("cancel_action drops the staged change and leaves the booking alone", async () => {
     const ctx = makeCtx();
     await run("update_ticket", { flightId: "LX54" }, ctx);
-    const dropped = (await run("cancel_action", {}, ctx)) as { discarded: string };
-    expect(dropped.discarded).toContain("LX54");
+    const dropped = okPosition<{ discarded: string }>(await run("cancel_action", ctx));
+    expect(dropped.result.discarded).toContain("LX54");
+    expect(dropped.state).toBe("browsing");
 
     const state = stateOf(ctx);
     expect(state.pending).toBeNull();
     expect(state.ticket?.flightId).toBe("LX40");
-    expect(await run("cancel_action", {}, ctx)).toEqual({
-      message: "Nothing was waiting for confirmation.",
+    expect(await run("cancel_action", ctx)).toMatchObject({
+      error: expect.stringContaining('this conversation is at "browsing"'),
     });
   });
 
@@ -161,14 +185,14 @@ describe("sensitive tools stage rather than act", () => {
 
   test("cancelling the ticket makes a later ticket change impossible", async () => {
     const ctx = makeCtx();
-    await run("cancel_ticket", {}, ctx);
-    await run("confirm_action", {}, ctx);
+    await run("cancel_ticket", ctx);
+    await run("confirm_action", ctx);
     expect(stateOf(ctx).ticket).toBeNull();
 
     expect(await run("update_ticket", { flightId: "LX52" }, ctx)).toEqual({
       error: "This caller has no ticket to move — it was cancelled on this call.",
     });
-    expect(await run("cancel_ticket", {}, ctx)).toEqual({ error: "There is no ticket to cancel." });
+    expect(await run("cancel_ticket", ctx)).toEqual({ error: "There is no ticket to cancel." });
   });
 
   test("a second staging is REFUSED rather than overwriting the first", async () => {
@@ -193,7 +217,12 @@ describe("sensitive tools stage rather than act", () => {
 
     // The first staging is untouched, and it is what a yes applies.
     expect(stateOf(ctx).pending).toEqual({ kind: "update_ticket", flightId: "LX52" });
-    const applied = (await run("confirm_action", {}, ctx)) as { applied: string };
+    // A refused SECOND staging must not have moved the gate either — it was
+    // already `awaitingConfirmation` and the refusal changed nothing.
+    expect(gateFlow.position(ctx).state).toBe("awaitingConfirmation");
+    // `ok` is `okPosition` with `.result` taken off: this assertion is about
+    // what the apply DID, not about where the gate landed.
+    const applied = ok<{ applied: string }>(await run("confirm_action", ctx));
     expect(applied.applied).toContain("LX52");
     expect(stateOf(ctx).bookings).toEqual([]);
 
@@ -207,7 +236,7 @@ describe("sensitive tools stage rather than act", () => {
   test("cancel_action clears the block, so a declined change does not wedge the desk", async () => {
     const ctx = makeCtx();
     await run("book_car_rental", { carId: "C2", days: 3 }, ctx);
-    await run("cancel_action", {}, ctx);
+    await run("cancel_action", ctx);
     const staged = (await run("book_excursion", { excursionId: "E2" }, ctx)) as {
       awaitingConfirmation: boolean;
     };
@@ -225,12 +254,14 @@ describe("sensitive tools stage rather than act", () => {
 
     await run("to_hotel_assistant", { request: "a room" }, first);
     await run("book_hotel", { hotelId: "H3", nights: 1 }, first);
-    await run("confirm_action", {}, first);
+    await run("confirm_action", first);
 
     expect(activeAssistant(stateOf(second))).toBe("primary");
     expect(stateOf(second).bookings).toEqual([]);
-    expect(await run("confirm_action", {}, second)).toEqual({
-      error: "Nothing is waiting for confirmation. Use the booking tool first.",
+    // The GATE is per-session too, not just the trip.
+    expect(gateFlow.position(second).state).toBe("browsing");
+    expect(await run("confirm_action", second)).toMatchObject({
+      error: expect.stringContaining('this conversation is at "browsing"'),
     });
     expect(stateOf(first).bookings).toHaveLength(1);
   });
@@ -283,8 +314,8 @@ describe("search tools", () => {
   test("lookup_booking reports the ticket the caller is actually holding", async () => {
     const ctx = makeCtx();
     await run("update_ticket", { flightId: "LX52" }, ctx);
-    await run("confirm_action", {}, ctx);
-    const booking = (await run("lookup_booking", {}, ctx)) as {
+    await run("confirm_action", ctx);
+    const booking = (await run("lookup_booking", ctx)) as {
       passenger: string;
       ticket: { flight: string; departs: string } | null;
     };
@@ -327,9 +358,9 @@ describe("tripView projection", () => {
   test("totals every confirmed booking", async () => {
     const ctx = makeCtx();
     await run("book_hotel", { hotelId: "H3", nights: 2 }, ctx); // 2 × 180
-    await run("confirm_action", {}, ctx);
+    await run("confirm_action", ctx);
     await run("book_excursion", { excursionId: "E1" }, ctx); // 35
-    await run("confirm_action", {}, ctx);
+    await run("confirm_action", ctx);
 
     const view = tripView(stateOf(ctx));
     expect(view.total).toBe(395);

package/dist/templates/travel-concierge/client.tsx

@@ -1,5 +1,5 @@
 import "@alexkroman1/aai-ui/styles.css";
-import { AutoScroll, client, useAgentState, useTheme } from "@alexkroman1/aai-ui";
+import { AutoScroll, client, useAgentState } from "@alexkroman1/aai-ui";
 import type { TripView } from "./shared.ts";
 import { SPECIALIST_IDS, SPECIALISTS, tripProjection } from "./shared.ts";
 
@@ -15,7 +15,6 @@ function deskLabel(id: (typeof DESKS)[number]): string {
  * the transcript — the whole delegation mechanism is otherwise invisible.
  */
 function DeskStrip({ active }: { active: TripView["assistant"] }) {
-  const theme = useTheme();
   return (
     <div className="flex flex-wrap gap-1.5">
       {DESKS.map((id) => {
@@ -23,12 +22,9 @@ function DeskStrip({ active }: { active: TripView["assistant"] }) {
         return (
           <span
             key={id}
-            className="rounded-full px-2.5 py-1 text-[11px] font-medium capitalize"
-            style={{
-              background: on ? theme.primary : theme.surface,
-              color: on ? theme.bg : theme.text,
-              opacity: on ? 1 : 0.55,
-            }}
+            className={`rounded-full px-2.5 py-1 text-[11px] font-medium capitalize ${
+              on ? "bg-aai-primary text-aai-bg" : "bg-aai-surface text-aai-text opacity-55"
+            }`}
           >
             {deskLabel(id)}
           </span>
@@ -39,11 +35,10 @@ function DeskStrip({ active }: { active: TripView["assistant"] }) {
 }
 
 function ItinerarySidebar() {
-  const theme = useTheme();
   const trip = useAgentState(tripProjection);
 
   return (
-    <div className="flex flex-col gap-4 p-4 h-full min-h-0" style={{ color: theme.text }}>
+    <div className="flex flex-col gap-4 p-4 h-full min-h-0 text-aai-text">
       <div className="flex flex-col gap-2">
         <h3 className="text-sm font-bold opacity-60 uppercase tracking-wide">{trip.passenger}</h3>
         <DeskStrip active={trip.assistant} />
@@ -52,10 +47,7 @@ function ItinerarySidebar() {
       {/* The staged action — the browser half of the confirmation gate. What is
           on screen is exactly what the concierge just asked out loud. */}
       {trip.pending && (
-        <div
-          className="rounded-lg p-3 text-sm"
-          style={{ background: theme.surface, border: `1px solid ${theme.primary}` }}
-        >
+        <div className="rounded-lg p-3 text-sm bg-aai-surface border border-aai-primary">
           <p className="text-[11px] font-bold uppercase tracking-wide opacity-60">
             Waiting on your yes
           </p>
@@ -66,7 +58,7 @@ function ItinerarySidebar() {
       <div className="flex flex-col gap-2">
         <p className="text-[11px] font-bold uppercase tracking-wide opacity-60">Ticket</p>
         {trip.ticket ? (
-          <div className="rounded-lg p-3" style={{ background: theme.surface }}>
+          <div className="rounded-lg p-3 bg-aai-surface">
             <p className="text-sm font-medium">
               {trip.ticket.flightId} · {trip.ticket.route}
             </p>
@@ -85,24 +77,20 @@ function ItinerarySidebar() {
           {trip.bookings.map((booking) => (
             <div
               key={booking.reference}
-              className="flex items-center justify-between gap-3 rounded-lg p-3"
-              style={{ background: theme.surface }}
+              className="flex items-center justify-between gap-3 rounded-lg p-3 bg-aai-surface"
             >
               <div className="min-w-0">
                 <p className="truncate text-sm">{booking.summary}</p>
                 <p className="text-xs opacity-60">{booking.reference}</p>
               </div>
-              <span className="text-sm font-bold" style={{ color: theme.primary }}>
+              <span className="text-sm font-bold text-aai-primary">
                 ${booking.price.toLocaleString("en-US")}
               </span>
             </div>
           ))}
-          <div
-            className="flex justify-between border-t pt-2 text-sm font-bold"
-            style={{ borderColor: theme.border }}
-          >
+          <div className="flex justify-between border-t border-aai-border pt-2 text-sm font-bold">
             <span>Total</span>
-            <span style={{ color: theme.primary }}>${trip.total.toLocaleString("en-US")}</span>
+            <span className="text-aai-primary">${trip.total.toLocaleString("en-US")}</span>
           </div>
         </div>
       )}

package/dist/templates/travel-concierge/routing.ts

@@ -24,6 +24,7 @@ import {
   activeAssistant,
   applyPending,
   describeAction,
+  gateFlow,
   note,
   SPECIALISTS,
   type SpecialistId,
@@ -111,28 +112,46 @@ export const completeOrEscalate = tripSlot.updateTool({
  * halts before a sensitive tool and resumes on approval; the halt here is that
  * every sensitive tool stages instead of acting, so the approval has somewhere
  * to arrive.
+ *
+ * **`when: "awaitingConfirmation"` is the other side of that halt.** It used to
+ * be a null check inside {@link applyPending} — "Nothing is waiting for
+ * confirmation. Use the booking tool first." — which is the question "where is
+ * this conversation", asked of the payload. The gate asks the machine instead,
+ * and its refusal carries the state's own instruction. `SETTLED` fires only when
+ * the body did NOT answer with a {@link ToolFailure}, so an application that
+ * failed leaves the change staged and the caller still being asked.
  */
-export const confirmAction = tripSlot.updateTool({
+export const confirmAction = gateFlow.tool({
   description:
     "Apply the change the caller has just confirmed out loud. Only call this " +
     "after you have read the change back and heard a clear yes.",
-  execute(_args, trip) {
-    return applyPending(trip);
-  },
+  when: "awaitingConfirmation",
+  send: { type: "SETTLED" },
+  execute: (_args, ctx) => tripSlot.update(ctx, (trip) => applyPending(trip)),
 });
 
-/** `cancel_action` — the caller said no. Drops the staged action, changes nothing. */
-export const cancelAction = tripSlot.updateTool({
+/**
+ * `cancel_action` — the caller said no. Drops the staged action, changes nothing.
+ *
+ * Gated for the same reason as `confirm_action`, and its own "nothing was
+ * waiting" arm is gone with the same argument.
+ */
+export const cancelAction = gateFlow.tool({
   description:
     "Discard the change the caller just declined. Call this when they say no, " +
     "or when they want to change the details before confirming.",
-  execute(_args, trip) {
-    const action = trip.pending;
-    if (!action) return { message: "Nothing was waiting for confirmation." };
-    trip.pending = null;
-    const described = describeAction(action);
-    const summary = typeof described === "string" ? described : action.kind;
-    note(trip, `Declined: ${summary}`);
-    return { discarded: summary, message: "Nothing was changed." };
-  },
+  when: "awaitingConfirmation",
+  send: { type: "SETTLED" },
+  execute: (_args, ctx) =>
+    tripSlot.update(ctx, (trip) => {
+      const action = trip.pending;
+      // Reachable only if the position and the payload disagree; see
+      // `applyPending`. Reported rather than thrown, mid-call.
+      if (!action) return { discarded: null, message: "Nothing was staged after all." };
+      trip.pending = null;
+      const described = describeAction(action);
+      const summary = typeof described === "string" ? described : action.kind;
+      note(trip, `Declined: ${summary}`);
+      return { discarded: summary, message: "Nothing was changed." };
+    }),
 });

package/dist/templates/travel-concierge/shared.ts

@@ -35,7 +35,15 @@
  * agent that can rebook a flight and one that can rebook a flight *by mistake*.
  */
 
-import { type DeepReadonly, pushCapped, sessionSlot, type ToolFailure } from "@alexkroman1/aai";
+import {
+  type DeepReadonly,
+  type DialogSpec,
+  dialog,
+  pushCapped,
+  sessionSlot,
+  type ToolContext,
+  type ToolFailure,
+} from "@alexkroman1/aai";
 
 // ─── The booking world ───────────────────────────────────────────────────────
 // Their notebook downloads a sqlite database of a real airline's schedule and
@@ -341,6 +349,51 @@ export function note(state: TripState, entry: string): void {
 
 // ─── The confirmation gate ───────────────────────────────────────────────────
 
+/**
+ * The gate as a STATE MAP — their `interrupt_before`, which is a graph construct.
+ *
+ * This port had to hand-roll it: a voice session had no graph, so "halt before a
+ * sensitive tool and resume on approval" became "every sensitive tool STAGES and
+ * `confirm_action` is the only thing that applies one". That half is unchanged
+ * and is still the mechanism — see {@link stageAction}. What the machine adds is
+ * the PRECONDITION on the other side of the halt: `confirm_action` and
+ * `cancel_action` are legal only while something is actually waiting, which was
+ * a null check inside each of them and is now `when`.
+ *
+ * **The staging tools are deliberately NOT gated on `browsing`.**
+ * {@link stageAction}'s refusal NAMES the sentence already waiting, which is what
+ * lets the model settle that one first and restage the rest; a state gate can
+ * only say "you are in awaitingConfirmation", since a state's instruction is
+ * static. So the specific refusal stays where it is and the flow follows it.
+ */
+const gateSpec = {
+  initial: "browsing",
+  states: {
+    browsing: {
+      instruction:
+        "Nothing is waiting for the caller's yes. Stage a change with a booking tool first.",
+      on: { STAGED: "awaitingConfirmation" },
+    },
+    awaitingConfirmation: {
+      instruction:
+        "Read the staged change back and hear a clear yes or no, then use confirm_action or cancel_action.",
+      on: { SETTLED: "browsing" },
+    },
+  },
+} as const satisfies DialogSpec;
+
+/**
+ * Whether a change is waiting on the caller's word.
+ *
+ * Its own slot, beside {@link tripSlot}: the flow holds the POSITION and the
+ * trip holds the staged action itself, because an inspectable
+ * {@link PendingAction} is what `confirm_action` re-derives the effect from. One
+ * tool call always moves both — {@link stageAction} sends `STAGED` in the same
+ * synchronous window it writes `pending` in, and the two settling tools send
+ * `SETTLED` only on success.
+ */
+export const gateFlow = dialog("gate", gateSpec);
+
 /**
  * Describe a staged action in one sentence, in the second person — this is
  * read aloud, so it is a question's worth of text and not a receipt.
@@ -396,6 +449,7 @@ export function describeAction(action: DeepReadonly<PendingAction>): string | To
  * model ask about that one first and restage the rest afterwards.
  */
 export function stageAction(
+  ctx: ToolContext,
   state: TripState,
   action: PendingAction,
 ):
@@ -413,6 +467,11 @@ export function stageAction(
     };
   }
   state.pending = action;
+  // The flow moves in the SAME synchronous window `pending` is written in, so
+  // the position and the payload cannot be observed disagreeing. `gateFlow` is
+  // a different slot from `tripSlot`, so this is not a nested write to the draft
+  // being held — the open-draft guard is per slot.
+  gateFlow.send(ctx, { type: "STAGED" });
   note(state, `Awaiting confirmation: ${described}`);
   return {
     awaitingConfirmation: true,
@@ -421,13 +480,21 @@ export function stageAction(
   };
 }
 
-/** Apply the staged action. The ONE place any of them takes effect. */
+/**
+ * Apply the staged action. The ONE place any of them takes effect.
+ *
+ * The "nothing is waiting" guard is gone: `confirm_action` is gated on
+ * `awaitingConfirmation`, so reaching here means something IS staged. The
+ * remaining `!action` arm is the flow and the payload disagreeing, which one
+ * synchronous window per transition is what rules out — it reports rather than
+ * throwing, because a live call is the wrong place to find out.
+ */
 export function applyPending(
   state: TripState,
 ): { applied: string; reference?: string } | ToolFailure {
   const action = state.pending;
   if (!action) {
-    return { error: "Nothing is waiting for confirmation. Use the booking tool first." };
+    return { error: "Nothing is staged after all — ask the caller again what they want." };
   }
   const described = describeAction(action);
   if (typeof described !== "string") return described;

package/dist/templates/travel-concierge/tools/book_car_rental.ts

@@ -10,8 +10,8 @@ export default tripSlot.updateTool({
     carId: z.string().max(20).describe("The car id from search_car_rentals, e.g. 'C2'"),
     days: z.number().int().min(1).max(60).describe("How many days"),
   }),
-  execute(args, trip) {
-    return stageAction(trip, {
+  execute(args, trip, ctx) {
+    return stageAction(ctx, trip, {
       kind: "book_car",
       carId: args.carId.toUpperCase(),
       days: args.days,

package/dist/templates/travel-concierge/tools/book_excursion.ts

@@ -9,8 +9,8 @@ export default tripSlot.updateTool({
   inputSchema: z.object({
     excursionId: z.string().max(20).describe("The excursion id from search_excursions, e.g. 'E2'"),
   }),
-  execute(args, trip) {
-    return stageAction(trip, {
+  execute(args, trip, ctx) {
+    return stageAction(ctx, trip, {
       kind: "book_excursion",
       excursionId: args.excursionId.toUpperCase(),
     });

package/dist/templates/travel-concierge/tools/book_hotel.ts

@@ -10,8 +10,8 @@ export default tripSlot.updateTool({
     hotelId: z.string().max(20).describe("The hotel id from search_hotels, e.g. 'H1'"),
     nights: z.number().int().min(1).max(30).describe("How many nights"),
   }),
-  execute(args, trip) {
-    return stageAction(trip, {
+  execute(args, trip, ctx) {
+    return stageAction(ctx, trip, {
       kind: "book_hotel",
       hotelId: args.hotelId.toUpperCase(),
       nights: args.nights,

package/dist/templates/travel-concierge/tools/cancel_ticket.ts

@@ -9,8 +9,8 @@ export default tripSlot.updateTool({
   description:
     "Cancel the caller's ticket outright. This does NOT cancel anything yet — " +
     "it stages the cancellation so you can read it back and hear a yes.",
-  execute(_args, trip) {
+  execute(_args, trip, ctx) {
     if (!trip.ticket) return { error: "There is no ticket to cancel." };
-    return stageAction(trip, { kind: "cancel_ticket" });
+    return stageAction(ctx, trip, { kind: "cancel_ticket" });
   },
 });

package/dist/templates/travel-concierge/tools/update_ticket.ts

@@ -13,10 +13,10 @@ export default tripSlot.updateTool({
   inputSchema: z.object({
     flightId: z.string().max(20).describe("The flight to move to, e.g. 'LX52'"),
   }),
-  execute(args, trip) {
+  execute(args, trip, ctx) {
     if (!trip.ticket) {
       return { error: "This caller has no ticket to move — it was cancelled on this call." };
     }
-    return stageAction(trip, { kind: "update_ticket", flightId: args.flightId.toUpperCase() });
+    return stageAction(ctx, trip, { kind: "update_ticket", flightId: args.flightId.toUpperCase() });
   },
 });