@agent-native/core 0.161.1 → 0.161.4

package/corpus/templates/clips/app/components/meetings/transcript-bubbles.tsx

@@ -61,8 +61,99 @@ export interface SpeakerIdentity {
   initialsSource: AttendeeStackParticipant | string;
   isOwner: boolean;
   accentClass: string;
+  /** The capture could not tell speakers apart, so this transcript names
+   *  nobody — the row renders without an avatar or label rather than claiming
+   *  a speaker we cannot know. */
+  unattributed?: boolean;
 }
 
+/**
+ * Whether a transcript carries enough signal to name who said what.
+ *
+ * A capture that only ever produced one speaker signal cannot distinguish two
+ * people: the mic-only fallback engines tag every segment `mic` (the remote
+ * side reaches the transcript only as bleed into the same microphone), and
+ * cloud transcription of a single mixed track tags nothing at all. Attributing
+ * those to the recording owner reads as fact and is wrong for every line the
+ * other person spoke — including in the AI summary and action items derived
+ * from it. A per-segment `speaker` label from a diarizing provider counts as
+ * signal even when `source` is absent.
+ *
+ * Only meaningful when two people could have spoken; a solo recording that is
+ * all mic genuinely is all one person.
+ */
+export function transcriptDistinguishesSpeakers(
+  segments: TranscriptSegment[],
+  participants: AttendeeStackParticipant[],
+  ownerEmail?: string | null,
+): boolean {
+  if (countPossibleSpeakers(participants, ownerEmail) < 2) return true;
+  const signals = new Set<string>();
+  for (const segment of segments) {
+    const signal = speakerSignal(segment);
+    if (signal) signals.add(signal);
+    if (signals.size > 1) return true;
+  }
+  return false;
+}
+
+/**
+ * What one segment claims about who was speaking, as a comparable key.
+ *
+ * A generic placeholder is not an identity — it names a side of the
+ * conversation, which is what `source` already says. Counting `speaker: "Me"`
+ * and a plain `source: "mic"` as two different speakers would mark a mic-only
+ * transcript distinguishable and hand the remote side's bleed back to the
+ * owner's name, so placeholders resolve to the side they mean instead. A real
+ * name wins over `source`, since a diarizing provider knows more than the
+ * stream split does; a placeholder yields to it.
+ */
+function speakerSignal(segment: TranscriptSegment): string | null {
+  const speaker = segment.speaker?.trim();
+  const side = placeholderSide(speaker);
+  if (speaker && !side) return `speaker:${normalizeSpeaker(speaker)}`;
+  if (segment.source) return `source:${segment.source}`;
+  // No placeholder and no source is an absence of information, not a side.
+  // Defaulting it to "system" here would make a transcript that mixes tagged
+  // and untagged segments look like two speakers.
+  return side ? `source:${side}` : null;
+}
+
+/**
+ * How many people could have spoken in this meeting.
+ *
+ * The participant roster is the calendar attendee list, which routinely omits
+ * the recording owner — `create-meeting` deliberately does not synthesize a row
+ * for a non-attendee owner, because that table feeds the public share payload.
+ * So counting rows alone reads an owner-plus-one-attendee meeting as solo and
+ * hands a mic-only transcript back to attribution, which is what labels the
+ * remote side's bleed as the owner.
+ *
+ * A withheld owner (`null`, from the public share page) still counts: it means
+ * an owner exists and is not among the participants. An owner we were never
+ * told about (`undefined`) also counts, because "we cannot name them" is not
+ * the same as "they are not there" — the cost of over-counting is a lost label,
+ * and the cost of under-counting is a false one.
+ */
+function countPossibleSpeakers(
+  participants: AttendeeStackParticipant[],
+  ownerEmail?: string | null,
+): number {
+  const ownerInRoster = ownerEmail
+    ? Boolean(findParticipant(ownerEmail, participants))
+    : false;
+  return participants.length + (ownerInRoster ? 0 : 1);
+}
+
+const UNATTRIBUTED_SPEAKER: SpeakerIdentity = {
+  key: "unattributed",
+  label: null,
+  initialsSource: "",
+  isOwner: false,
+  accentClass: "",
+  unattributed: true,
+};
+
 const SPEAKER_ACCENTS = [
   "bg-accent text-accent-foreground",
   "bg-secondary text-secondary-foreground",
@@ -75,6 +166,37 @@ function normalizeSpeaker(value: string): string {
   return value.trim().toLowerCase().replace(/\s+/g, " ");
 }
 
+// Some providers (and our own seed fixture) tag unresolved segments with a
+// literal placeholder word instead of leaving `speaker` blank. These name a
+// side of the conversation rather than a person, so neither the label nor the
+// attribution check may treat one as an identity.
+const GENERIC_MIC_SPEAKER = /^(me|self|you)$/i;
+const GENERIC_SYSTEM_SPEAKER = /^them$/i;
+
+/** The side a generic placeholder names, or null when it names a person. */
+function placeholderSide(
+  label: string | null | undefined,
+): "mic" | "system" | null {
+  const speaker = label?.trim();
+  if (!speaker) return null;
+  if (GENERIC_MIC_SPEAKER.test(speaker)) return "mic";
+  if (GENERIC_SYSTEM_SPEAKER.test(speaker)) return "system";
+  return null;
+}
+
+/**
+ * Which side of the conversation a segment belongs to.
+ *
+ * `source` is the real signal, but a segment can arrive with only a
+ * placeholder speaker on it. Falling straight through to "system" then drops
+ * every "Me" into the remote group, which is how a transcript labelled purely
+ * with placeholders renders entirely as "Them" — the original bug. Read the
+ * side the placeholder names before defaulting.
+ */
+function segmentSide(segment: TranscriptSegment): "mic" | "system" {
+  return segment.source ?? placeholderSide(segment.speaker) ?? "system";
+}
+
 // Exported for regression testing — see transcript-bubbles.test.ts. These
 // are pure functions with no dependency on the component itself.
 export function findParticipant(
@@ -139,22 +261,23 @@ export function resolveSpeaker(
   participants: AttendeeStackParticipant[],
   ownerEmail?: string | null,
 ): SpeakerIdentity {
-  const source = segment.source === "mic" ? "mic" : "system";
+  const source = segmentSide(segment);
   const rawSpeaker = segment.speaker?.trim();
   const participant =
     findParticipant(segment.speaker, participants) ||
     resolveParticipantForSpeaker(source, participants, ownerEmail);
   const participantName = participant?.name?.trim();
   const resolvedLabel = participantName || rawSpeaker;
-  // Some providers (and our own seed fixture) tag unresolved segments with a
-  // literal placeholder word instead of leaving speaker blank. Treat those the
-  // same as "no label" on both sides so the UI falls back to the translated
-  // Me/Them string instead of rendering the raw English placeholder verbatim.
+  // Treat a placeholder as "no label" so the UI falls back to the translated
+  // Me/Them string instead of rendering the raw English word verbatim. Only
+  // the placeholder matching this segment's own side counts: "Them" on a mic
+  // segment is a contradiction, not a placeholder, and keeping it visible is
+  // better than silently dropping it.
   const isGenericPlaceholderLabel =
     !!resolvedLabel &&
     (source === "mic"
-      ? /^(me|self|you)$/i.test(resolvedLabel)
-      : /^them$/i.test(resolvedLabel));
+      ? GENERIC_MIC_SPEAKER.test(resolvedLabel)
+      : GENERIC_SYSTEM_SPEAKER.test(resolvedLabel));
   const label = isGenericPlaceholderLabel
     ? null
     : participantName || rawSpeaker || null;
@@ -203,9 +326,16 @@ function groupConsecutive(
   participants: AttendeeStackParticipant[],
   ownerEmail?: string | null,
 ): BubbleGroup[] {
+  const attributable = transcriptDistinguishesSpeakers(
+    segments,
+    participants,
+    ownerEmail,
+  );
   const groups: BubbleGroup[] = [];
   segments.forEach((seg, index) => {
-    const speaker = resolveSpeaker(seg, participants, ownerEmail);
+    const speaker = attributable
+      ? resolveSpeaker(seg, participants, ownerEmail)
+      : UNATTRIBUTED_SPEAKER;
     const last = groups[groups.length - 1];
     if (last && last.speaker.key === speaker.key) {
       last.segments.push({ seg, index });
@@ -509,38 +639,40 @@ export function TranscriptBubbles({
                   key={`${group.speaker.key}:${gi}`}
                   className="space-y-0.5"
                 >
-                  <div className="flex h-6 items-center gap-2">
-                    <Avatar
-                      className={cn(
-                        "size-6 shrink-0",
-                        group.speaker.accentClass,
-                      )}
-                    >
-                      <AvatarFallback
+                  {!group.speaker.unattributed && (
+                    <div className="flex h-6 items-center gap-2">
+                      <Avatar
                         className={cn(
-                          "text-[9px] font-semibold",
+                          "size-6 shrink-0",
                           group.speaker.accentClass,
                         )}
                       >
-                        {attendeeInitials(group.speaker.initialsSource)}
-                      </AvatarFallback>
-                    </Avatar>
-                    <div className="flex min-h-6 items-center">
-                      <span
-                        className={cn(
-                          "text-xs font-semibold leading-6",
-                          group.speaker.isOwner
-                            ? "text-primary"
-                            : "text-foreground",
-                        )}
-                      >
-                        {group.speaker.label ||
-                          (group.speaker.isOwner
-                            ? t("transcriptBubbles.me")
-                            : t("transcriptBubbles.them"))}
-                      </span>
+                        <AvatarFallback
+                          className={cn(
+                            "text-[9px] font-semibold",
+                            group.speaker.accentClass,
+                          )}
+                        >
+                          {attendeeInitials(group.speaker.initialsSource)}
+                        </AvatarFallback>
+                      </Avatar>
+                      <div className="flex min-h-6 items-center">
+                        <span
+                          className={cn(
+                            "text-xs font-semibold leading-6",
+                            group.speaker.isOwner
+                              ? "text-primary"
+                              : "text-foreground",
+                          )}
+                        >
+                          {group.speaker.label ||
+                            (group.speaker.isOwner
+                              ? t("transcriptBubbles.me")
+                              : t("transcriptBubbles.them"))}
+                        </span>
+                      </div>
                     </div>
-                  </div>
+                  )}
                   <div className="space-y-1">
                     {group.segments.map(({ seg, index }) => {
                       return (

package/corpus/templates/clips/desktop/src/lib/transcription-capture.ts

@@ -36,7 +36,9 @@ function wait(ms: number): Promise<void> {
 export interface CapturedTranscript {
   /** Speaker-labelled text, lines joined by blank lines. */
   text: string;
-  /** Real whisper segments with verbatim timestamps. */
+  /** Whisper's verbatim timestamps where the engine reported them, else one
+   *  synthesized segment per line — the mic-only engines report no timings,
+   *  and a dropped line would lose its speaker along with its text. */
   segments: SourcedTranscriptSegment[];
   /** Source stored with `save-browser-transcript`. */
   source?: "web-speech" | "macos-native" | "whisper";
@@ -332,9 +334,14 @@ export async function startTranscriptionCapture(
     });
   };
 
+  // `source` reports the engine that actually produced this transcript, not
+  // the one we asked for: `startTranscriptionEngine` may have fallen back to
+  // mic-only macos-native. Omitting it made the server default to "whisper"
+  // and treat a mic-only capture as mixed mic + system audio.
   const captured = (): CapturedTranscript => ({
     text: transcriptFullText(lines),
     segments: transcriptSegments(lines),
+    source: engine,
   });
 
   let engine: TranscriptionEngine;

package/corpus/templates/clips/desktop/src/lib/transcription-engine.ts

@@ -245,11 +245,48 @@ export function transcriptFullText(lines: TranscriptLine[]): string {
     .trim();
 }
 
-/** Flattened verbatim segments, as persisted alongside the text. */
+/** Rough duration estimate for a line with no verbatim timing, matching the
+ *  pacing `buildCaptionSegmentsFromText` uses server-side. */
+function estimatedLineDurationMs(text: string): number {
+  const words = text.split(/\s+/).filter(Boolean).length || 1;
+  return Math.max(900, words * 420);
+}
+
+/** Flattened verbatim segments, as persisted alongside the text.
+ *
+ *  A line with no verbatim timings still contributes one synthesized segment
+ *  rather than being dropped: the mic-only fallback engines report no
+ *  timestamps at all, and dropping the line loses its text and its `source`
+ *  — and a `source`-less stored segment silently renders as "Them". Those
+ *  engines report `startMs: null` on *every* line, so a synthesized segment
+ *  continues from the previous line's end; anchoring each at its own
+ *  null-coalesced 0 would stack the whole transcript on one instant and break
+ *  ordering and timestamp seeking. */
 export function transcriptSegments(
   lines: TranscriptLine[],
 ): SourcedTranscriptSegment[] {
-  return lines.flatMap((line) => line.segments);
+  const segments: SourcedTranscriptSegment[] = [];
+  let cursorMs = 0;
+  for (const line of lines) {
+    if (line.segments.length) {
+      segments.push(...line.segments);
+      cursorMs = line.segments.reduce(
+        (latest, segment) => Math.max(latest, segment.endMs),
+        cursorMs,
+      );
+      continue;
+    }
+    // `appendFinalTranscript` is the only path that yields an untimed line and
+    // it always pairs `segments: []` with `startMs: null`, so today this reads
+    // as `cursorMs`. Honouring a line's own stamp is for the shape the type
+    // still permits (see `historyLine` in overlays/live-transcript.tsx), and
+    // clamping to the cursor keeps a stale stamp from reordering the transcript.
+    const startMs = Math.max(line.startMs ?? cursorMs, cursorMs);
+    const endMs = startMs + estimatedLineDurationMs(line.text);
+    segments.push({ startMs, endMs, text: line.text, source: line.source });
+    cursorMs = endMs;
+  }
+  return segments;
 }
 
 /**

package/corpus/templates/slides/actions/list-decks.ts

@@ -22,7 +22,9 @@ export default defineAction({
     includeSlides: z
       .enum(["true", "false"])
       .optional()
-      .describe("Set to 'true' for full frontend deck payloads"),
+      .describe(
+        "Set to 'true' for full frontend deck payloads; omitted returns metadata only",
+      ),
     light: z
       .enum(["true", "false"])
       .optional()
@@ -84,6 +86,39 @@ export default defineAction({
       return { count: rows.length, decks: rows };
     }
 
+    if (args.includeSlides !== "true") {
+      // The deck body is an opaque JSON blob containing every slide's HTML.
+      // Metadata callers must opt into it explicitly; the frontend opens one
+      // deck at a time through get-deck instead of downloading every body.
+      const rows = await db
+        .select({
+          id: schema.decks.id,
+          title: schema.decks.title,
+          ownerEmail: schema.decks.ownerEmail,
+          designSystemId: schema.decks.designSystemId,
+          createdAt: schema.decks.createdAt,
+          updatedAt: schema.decks.updatedAt,
+          visibility: schema.decks.visibility,
+        })
+        .from(schema.decks)
+        .where(where)
+        .orderBy(desc(schema.decks.updatedAt));
+
+      return {
+        count: rows.length,
+        decks: rows.map((row) => ({
+          id: row.id,
+          title: row.title,
+          url: getDeckUrl(row.id),
+          visibility: row.visibility,
+          designSystemId: row.designSystemId ?? null,
+          createdByMe: ownerEmail ? row.ownerEmail === ownerEmail : false,
+          createdAt: row.createdAt,
+          updatedAt: row.updatedAt,
+        })),
+      };
+    }
+
     const rows = await db
       .select()
       .from(schema.decks)

package/corpus/templates/slides/app/context/DeckContext.tsx

@@ -940,7 +940,7 @@ export function deriveInverseOp(
 }
 
 /**
- * Fetch the deck list. Returns `null` on any failure (network error, non-2xx
+ * Fetch the deck metadata list. Returns `null` on any failure (network error, non-2xx
  * response) so callers can distinguish "authoritative empty list" from
  * "couldn't reach the server" — wiping local state on a transient failure
  * kicks the user out of the editor and shows the "Create your first deck"
@@ -951,7 +951,7 @@ async function fetchDecksFromAPI(): Promise<Deck[] | null> {
   try {
     const result = await callAction<DeckListActionResult>(
       "list-decks",
-      { includeSlides: "true" },
+      { light: "true" },
       { method: "GET" },
     );
     if (!Array.isArray(result?.decks)) {
@@ -1076,12 +1076,23 @@ export async function includeOpenDeckIfMissing(
 async function fetchDecksForCurrentRoute(): Promise<Deck[] | null> {
   const currentOpenDeckId = currentOpenDeckIdFromWindow();
   const loaded = await fetchDecksFromAPI();
-  if (loaded !== null) {
-    return includeOpenDeckIfMissing(loaded, currentOpenDeckId);
+  if (loaded === null) {
+    if (!currentOpenDeckId) return null;
+    const directDeck = await fetchDeckFromAPI(currentOpenDeckId);
+    return directDeck ? [directDeck] : null;
   }
-  if (!currentOpenDeckId) return null;
+  if (!currentOpenDeckId) return loaded;
+
+  // The list is intentionally metadata-only. Hydrate just the deck the user
+  // opened so the editor gets full slide content without making the home page
+  // download every deck body.
   const directDeck = await fetchDeckFromAPI(currentOpenDeckId);
-  return directDeck ? [directDeck] : null;
+  if (!directDeck) return loaded;
+  const index = loaded.findIndex((deck) => deck.id === currentOpenDeckId);
+  if (index < 0) return [...loaded, directDeck];
+  const next = [...loaded];
+  next[index] = directDeck;
+  return next;
 }
 
 async function deleteDeckFromAPI(id: string): Promise<void> {

package/dist/agent/engine/builder-engine.js

@@ -226,6 +226,17 @@ class BuilderEngine {
                 }
                 : {}),
         };
+        // Measured once, from the exact string that goes on the wire, and carried
+        // on every error stop below. A gateway rejection tells us nothing about
+        // what we sent, so without this an oversized or malformed request and a
+        // gateway outage are the same capture.
+        const payload = JSON.stringify(body);
+        const requestShape = {
+            model: opts.model,
+            payloadBytes: new TextEncoder().encode(payload).length,
+            toolCount: cachedTools.length,
+            messageCount: cachedMessages.length,
+        };
         const gatewayBaseUrl = getBuilderGatewayBaseUrl();
         const gatewayUrl = new URL("messages", gatewayBaseUrl.endsWith("/") ? gatewayBaseUrl : `${gatewayBaseUrl}/`);
         gatewayUrl.searchParams.set("apiKey", spaceId);
@@ -246,7 +257,7 @@ class BuilderEngine {
                         ...getBuilderGatewayRequestHeaders(),
                         ...(builderUserId ? { "x-builder-user-id": builderUserId } : {}),
                     },
-                    body: JSON.stringify(body),
+                    body: payload,
                     signal: gatewayAbort.signal,
                 });
             }
@@ -265,12 +276,12 @@ class BuilderEngine {
                         elapsedMs: Date.now() - tStart,
                     });
                 }
-                yield createBuilderGatewayTimeoutStop(err, timedOut, gatewayAbort.effectiveTimeoutMs(), creditsLane);
+                yield createBuilderGatewayTimeoutStop(err, timedOut, gatewayAbort.effectiveTimeoutMs(), creditsLane, requestShape);
                 return;
             }
             console.log(`[builder-engine] ← ${response.status} ${response.statusText} in ${Date.now() - tStart}ms`);
             if (!response.ok) {
-                yield* emitHttpError(response, { creditsLane });
+                yield* emitHttpError(response, { creditsLane, requestShape });
                 return;
             }
             // A successful gateway call proves the connected credentials are valid
@@ -302,7 +313,7 @@ class BuilderEngine {
                     ...(isTransientGatewayFailure(error, status)
                         ? { providerRetryable: true }
                         : {}),
-                }, creditsLane);
+                }, creditsLane, requestShape);
                 return;
             }
             const reader = response.body?.getReader();
@@ -311,7 +322,7 @@ class BuilderEngine {
                     error: "Builder gateway response has no body",
                     errorCode: "builder_gateway_error",
                     statusCode: response.status,
-                }, creditsLane);
+                }, creditsLane, requestShape);
                 return;
             }
             yield* parseJsonlStream(reader, opts.model, {
@@ -322,6 +333,7 @@ class BuilderEngine {
                 onFirstEvent: gatewayAbort.markFirstEvent,
                 gatewayUrl,
                 requestStartedAt: tStart,
+                requestShape,
             });
         }
         finally {
@@ -358,7 +370,7 @@ function isTransientGatewayFailure(rawMessage, status) {
  * signals downstream may read: keyword coupling to the message turns a retryable
  * throttle into a dead turn on credits sites alone.
  */
-function gatewayErrorStop(details, creditsLane) {
+function gatewayErrorStop(details, creditsLane, requestShape) {
     const { error, errorCode, upgradeUrl, ...retry } = details;
     return {
         type: "stop",
@@ -373,6 +385,9 @@ function gatewayErrorStop(details, creditsLane) {
         ...(isContextOverflowMessage(error) || isContextOverflowCode(errorCode)
             ? { contextOverflow: true }
             : {}),
+        // Absent before the request is built (missing credentials): a stop with no
+        // shape means nothing was sent, not that the payload measured zero.
+        ...(requestShape ? { requestShape } : {}),
         ...retry,
     };
 }
@@ -394,7 +409,7 @@ async function* emitHttpError(response, opts) {
     }
     const code = errBody.code ?? `http_${status}`;
     const message = errBody.message ?? `Builder gateway returned ${status}`;
-    const stop = (details) => gatewayErrorStop(details, opts.creditsLane);
+    const stop = (details) => gatewayErrorStop(details, opts.creditsLane, opts.requestShape);
     // Belt-and-suspenders: 402 without a structured `credits-limit` code
     // (e.g. bare proxy response) still means quota → show upgrade CTA.
     if (code.startsWith("credits-limit") || status === 402) {
@@ -543,7 +558,7 @@ async function* parseJsonlStream(reader, model, captureContext = {}) {
                     errorCode: "http_502",
                     statusCode: 502,
                     providerRetryable: true,
-                }, captureContext.creditsLane);
+                }, captureContext.creditsLane, captureContext.requestShape);
                 return;
             }
             // Heartbeats are transport-level keepalives, not proof the model is
@@ -624,7 +639,7 @@ async function* parseJsonlStream(reader, model, captureContext = {}) {
                     yield* recoverUndeliveredToolCalls();
                     yield { type: "assistant-content", parts };
                     const reason = event.reason ?? "end_turn";
-                    const stop = (details) => gatewayErrorStop(details, captureContext.creditsLane);
+                    const stop = (details) => gatewayErrorStop(details, captureContext.creditsLane, captureContext.requestShape);
                     if (reason === "rate_limited") {
                         yield stop({
                             error: `rate_limit exceeded: ${event.error ?? "upstream provider rate limited"}`,
@@ -655,6 +670,7 @@ async function* parseJsonlStream(reader, model, captureContext = {}) {
                         const explicitErrMsg = event.error || event.message || event.detail;
                         const errMsg = explicitErrMsg ??
                             `Gateway error (no detail; raw event: ${JSON.stringify(event)})`;
+                        const gatewayRequestId = typeof event.requestId === "string" ? event.requestId : undefined;
                         const gatewayErrCode = event.errorCode ?? event.code;
                         // The gateway already authenticated this request before streaming,
                         // so a bare "Unauthorized" here means the account cannot use this
@@ -684,7 +700,7 @@ async function* parseJsonlStream(reader, model, captureContext = {}) {
                                                 // would otherwise do it downstream on the visitor line and
                                                 // record `unknown` on the credits lane alone.
                                                 classifyTerminalErrorCode(String(errMsg))));
-                        console.error(`[builder-engine] stop reason=error model=${model} code=${errCode ?? "(none)"} error=${errMsg}`);
+                        console.error(`[builder-engine] stop reason=error model=${model} code=${errCode ?? "(none)"} requestId=${gatewayRequestId ?? "(none)"} error=${errMsg}`);
                         if (isCredentialAuthError) {
                             await recordBuilderGatewayAuthFailure({
                                 code: typeof gatewayErrCode === "string" ? gatewayErrCode : errCode,
@@ -699,9 +715,7 @@ async function* parseJsonlStream(reader, model, captureContext = {}) {
                         // it's thrown, but without these tags.
                         if (!explicitErrMsg) {
                             captureBuilderGatewayNoDetailError({
-                                requestId: typeof event.requestId === "string"
-                                    ? event.requestId
-                                    : undefined,
+                                requestId: gatewayRequestId,
                                 model,
                                 gatewayUrl: captureContext.gatewayUrl,
                                 rawEvent: event,
@@ -716,6 +730,10 @@ async function* parseJsonlStream(reader, model, captureContext = {}) {
                             ...(isTransientGatewayFailure(String(errMsg))
                                 ? { providerRetryable: true }
                                 : {}),
+                            // requestId rides the stop event whether or not the gateway sent a
+                            // message: a message like "...ERROR ID: <hex>" is as opaque as no
+                            // message at all, and this is the only key that reaches upstream.
+                            ...(gatewayRequestId ? { requestId: gatewayRequestId } : {}),
                         });
                     }
                     else if (reason === "end_turn" ||
@@ -741,7 +759,7 @@ async function* parseJsonlStream(reader, model, captureContext = {}) {
         yield gatewayErrorStop({
             error: "Builder gateway stream ended without a stop event",
             errorCode: BUILDER_GATEWAY_STREAM_ENDED_ERROR_CODE,
-        }, captureContext.creditsLane);
+        }, captureContext.creditsLane, captureContext.requestShape);
     }
     catch (err) {
         const timedOut = captureContext.didGatewayTimeout?.() ?? false;
@@ -759,7 +777,7 @@ async function* parseJsonlStream(reader, model, captureContext = {}) {
                     : undefined,
             });
         }
-        yield createBuilderGatewayTimeoutStop(err, timedOut, gatewayTimeoutMs, captureContext.creditsLane);
+        yield createBuilderGatewayTimeoutStop(err, timedOut, gatewayTimeoutMs, captureContext.creditsLane, captureContext.requestShape);
     }
     finally {
         // Release the reader on every exit path — early returns (invalid JSONL,
@@ -973,27 +991,27 @@ function normalizeBuilderGatewayFetchError(err, timedOut, timeoutMs) {
  * the credits lane run-manager has no text left to classify at persistence time,
  * and a run persisted as `unknown` reads as "do not attempt recovery".
  */
-function createBuilderGatewayTimeoutStop(err, timedOut, timeoutMs, creditsLane) {
+function createBuilderGatewayTimeoutStop(err, timedOut, timeoutMs, creditsLane, requestShape) {
     const error = normalizeBuilderGatewayFetchError(err, timedOut, timeoutMs);
     if (timedOut) {
         // Deliberately no `providerRetryable`: the timeout spent the whole request
         // budget, so the recovery is a fresh invocation (the client's
         // `builder_gateway_timeout` continuation), never an in-call retry.
-        return gatewayErrorStop({ error, errorCode: "builder_gateway_timeout" }, creditsLane);
+        return gatewayErrorStop({ error, errorCode: "builder_gateway_timeout" }, creditsLane, requestShape);
     }
     if (isBuilderGatewayNetworkError(err)) {
         return gatewayErrorStop({
             error,
             errorCode: BUILDER_GATEWAY_NETWORK_ERROR_CODE,
             providerRetryable: true,
-        }, creditsLane);
+        }, creditsLane, requestShape);
     }
     const errorCode = classifyTerminalErrorCode(error);
     return gatewayErrorStop({
         error,
         ...(errorCode ? { errorCode } : {}),
         ...(isTransientGatewayFailure(error) ? { providerRetryable: true } : {}),
-    }, creditsLane);
+    }, creditsLane, requestShape);
 }
 function formatTimeoutMs(timeoutMs) {
     if (timeoutMs < 1000)