cartethyia 2.5.9 → 2.6.0

package/src/transport/dispatch/attempt-loop.ts

@@ -33,7 +33,13 @@ import type { NetworkPoolSelector } from "../../network/pool/selector";
 import type { ProxyRequestState } from "../request/state";
 import type { TelemetryBatchBuffer } from "../../observability/telemetry-buffer";
 import { flagPoolBlocked, flagPoolCooldown } from "../../network/pool-health";
-import { completeAttempt, errorClientResponseBody, estimatedUsage, type ProviderExchangeCapture } from "./attempt-finalize";
+import {
+  completeAttempt,
+  errorClientResponseBody,
+  estimatedUsage,
+  type AttemptCompletion,
+  type ProviderExchangeCapture,
+} from "./attempt-finalize";
 import { repriceUsage } from "../../providers/provider-usage";
 import { isFreeTierIpBlock, isOAuthCredentialInvalidated, shouldCooldownPool } from "./retry-policy";
 import { drainAbortReason } from "../shutdown-notice";
@@ -92,6 +98,50 @@ function buildMemberOrdinals(
   return ordinals;
 }
 
+/** Build the common failure payload; the call site supplies only attempt-specific decisions. */
+function failureCompletion(input: {
+  readonly state: ProxyRequestState;
+  readonly deps: AttemptLoopDeps;
+  readonly candidate?: RouteCandidate | undefined;
+  readonly status: AttemptCompletion["status"];
+  readonly errorCategory?: string;
+  readonly errorOrigin?: string;
+  readonly error: unknown;
+  readonly tenantId: string | null;
+  readonly terminal: boolean;
+  readonly networkPoolId?: string | undefined;
+  readonly lease?: AdmissionLease | undefined;
+  readonly commitUsage?: AttemptCompletion["commitUsage"];
+  readonly providerCapture?: ProviderExchangeCapture | undefined;
+  readonly includeClientResponse: boolean;
+}): AttemptCompletion {
+  const { state, deps, candidate } = input;
+  return {
+    status: input.status,
+    providerId: candidate?.provider_id ?? "",
+    ...(candidate?.provider_account_id ? { accountId: candidate.provider_account_id } : {}),
+    ...(candidate?.provider_account_label ? { accountLabel: candidate.provider_account_label } : {}),
+    ...(candidate?.model_id === undefined ? {} : { modelId: candidate.model_id }),
+    ...(input.networkPoolId === undefined ? {} : { networkPoolId: input.networkPoolId }),
+    ...(input.errorCategory === undefined ? {} : { errorCategory: input.errorCategory }),
+    ...(input.errorOrigin === undefined ? {} : { errorOrigin: input.errorOrigin }),
+    error: input.error,
+    ...(input.lease === undefined ? {} : { lease: input.lease }),
+    ...(input.commitUsage === undefined ? {} : { commitUsage: input.commitUsage }),
+    terminal: input.terminal,
+    tenantId: input.tenantId,
+    ingressBody: state.ingressBody,
+    responseBody: null,
+    ...(input.includeClientResponse && input.status !== "cancelled"
+      ? { clientResponseText: errorClientResponseBody(input.error) }
+      : {}),
+    ...(input.providerCapture === undefined ? {} : { providerCapture: input.providerCapture }),
+    db: deps.db,
+    ...(deps.telemetryBuffer === undefined ? {} : { telemetryBuffer: deps.telemetryBuffer }),
+    ...(deps.snapshotService === undefined ? {} : { snapshotService: deps.snapshotService }),
+  };
+}
+
 /** Route-specific preconditions resolved for one candidate before its leases are taken. */
 interface PreparedAttempt<TAdapter> {
   readonly credential: ResolvedCredential;
@@ -170,9 +220,14 @@ export async function runAttemptLoop<TResult, TAdapter>(
   // sink reaches the payload store. When the terminal attempt fails before it
   // fires an outbound request (lease/acquire/prepare threw, or failover
   // exhausted), its sink is empty and the drawer reads "—" for a request that
-  // DID reach an upstream on an earlier attempt. Keep the fired exchanges so
-  // the terminal completion can fall back to the last one that has a request.
-  const firedCaptures: ProviderExchangeCapture[] = [];
+  // DID reach an upstream on an earlier attempt. Only the LAST fired exchange
+  // is ever consulted — every consumer below falls back to the most recent
+  // capture that has a request — so this holds one reference, not the whole
+  // history: a request walking N attempts used to pin N provider exchanges
+  // (each holding its bounded provider tee) alive until the loop returned.
+  // Earlier attempts' captures are released as each new attempt fires; the
+  // payload store's own bounded writer is what bounds anything persisted.
+  let lastFiredCapture: ProviderExchangeCapture | undefined;
   const maxAttempts = resolveRouteMaxAttempts();
   // One combo member must not be able to spend the whole budget.
   //
@@ -222,36 +277,23 @@ export async function runAttemptLoop<TResult, TAdapter>(
       if (remainingMs < MIN_RETRY_BUDGET_MS) {
         if (lastError !== undefined && !state.completed) {
           const terminal = classifyTerminalOutcome(lastError, state.abortController.signal);
-          const lastFired = [...firedCaptures]
-            .reverse()
-            .find((capture) => capture.request !== null);
-          await completeAttempt(state, {
+          const lastFired =
+            lastFiredCapture?.request !== null && lastFiredCapture !== undefined
+              ? lastFiredCapture
+              : undefined;
+          await completeAttempt(state, failureCompletion({
+            state,
+            deps,
+            candidate,
             status: terminal.status,
-            providerId: candidate.provider_id,
-            ...(candidate.provider_account_id
-              ? { accountId: candidate.provider_account_id }
-              : {}),
-            ...(candidate.provider_account_label
-              ? { accountLabel: candidate.provider_account_label }
-              : {}),
             errorCategory: terminal.errorCategory,
             errorOrigin: terminal.errorOrigin,
-            modelId: candidate.model_id,
             error: lastError,
-            terminal: true,
             tenantId: input.tenantId,
-            ingressBody: state.ingressBody,
-            responseBody: null,
-            ...(terminal.status !== "cancelled"
-              ? { clientResponseText: errorClientResponseBody(lastError) }
-              : {}),
-            // Same fallback the terminal catch uses: a request that did fire
-            // upstream keeps that exchange in Request Detail.
-            ...(lastFired ? { providerCapture: lastFired } : {}),
-            db: deps.db,
-            ...(deps.telemetryBuffer ? { telemetryBuffer: deps.telemetryBuffer } : {}),
-            ...(deps.snapshotService ? { snapshotService: deps.snapshotService } : {}),
-          });
+            terminal: true,
+            providerCapture: lastFired,
+            includeClientResponse: true,
+          }));
           metrics.proxy_requests_total.inc(1, {
             status: terminal.status === "cancelled" ? "cancelled" : "failed",
           });
@@ -358,7 +400,9 @@ export async function runAttemptLoop<TResult, TAdapter>(
         cancelled ||
         !isRetryableFailure(error) ||
         (index === candidates.length - 1 && !poolScopedFailure);
-      if (providerCapture.request !== null) firedCaptures.push(providerCapture);
+      // Track only the most recent fired exchange; the array this replaced
+      // accumulated every attempt's capture until the loop returned.
+      if (providerCapture.request !== null) lastFiredCapture = providerCapture;
       // The payload store only keeps the terminal attempt's exchange. When the
       // terminal attempt never fired (failover walked past the attempt that
       // did, or prepare/lease threw first), fall back to the last fired
@@ -367,50 +411,39 @@ export async function runAttemptLoop<TResult, TAdapter>(
       const terminalCapture =
         providerCapture.request !== null
           ? providerCapture
-          : [...firedCaptures].reverse().find((capture) => capture.request !== null) ??
-            providerCapture;
-      await completeAttempt(state, {
+          : lastFiredCapture ?? providerCapture;
+      await completeAttempt(state, failureCompletion({
+        state,
+        deps,
+        candidate,
         status: terminal.status,
-        providerId: candidate.provider_id,
-        ...(candidate.provider_account_id ? { accountId: candidate.provider_account_id } : {}),
-        ...(candidate.provider_account_label ? { accountLabel: candidate.provider_account_label } : {}),
         errorCategory: terminal.errorCategory,
         errorOrigin: terminal.errorOrigin,
-        modelId: candidate.model_id,
-        ...(networkPoolId ? { networkPoolId } : {}),
         error,
-        ...(lease ? { lease } : {}),
+        tenantId: input.tenantId,
+        terminal: terminalAttempt,
+        networkPoolId,
+        lease,
         // A failed attempt may have sent bytes upstream, so it is not free —
         // but it must not be charged the full input estimate plus a full
         // output reserve either, because a request that walks N candidates
         // would then leave N estimates on the counters for one client request.
         // Commit the input estimate only: nothing was generated, and the
         // `finally` release then refunds the (uncommitted) output reserve.
-        ...(!cancelled && bindingEstablished
-          ? {
-              commitUsage: repriceUsage(
-                estimatedUsage(leaseSource.estimatedInputTokens, 0),
-                candidate.provider_id,
-                candidate.model_id,
-              ),
-            }
-          : {}),
-        terminal: terminalAttempt,
-        tenantId: input.tenantId,
-        ingressBody: state.ingressBody,
-        responseBody: null,
+        commitUsage: !cancelled && bindingEstablished
+          ? repriceUsage(
+              estimatedUsage(leaseSource.estimatedInputTokens, 0),
+              candidate.provider_id,
+              candidate.model_id,
+            )
+          : undefined,
         // The client still receives the public error envelope on the wire —
         // store it so Request Detail's Client Response panel traces failures
         // exactly as the client saw them. Cancelled requests have no client
         // response (the caller is gone).
-        ...(terminalAttempt && !cancelled
-          ? { clientResponseText: errorClientResponseBody(error) }
-          : {}),
         providerCapture: terminalCapture,
-        db: deps.db,
-        ...(deps.telemetryBuffer ? { telemetryBuffer: deps.telemetryBuffer } : {}),
-        ...(deps.snapshotService ? { snapshotService: deps.snapshotService } : {}),
-      });
+        includeClientResponse: terminalAttempt,
+      }));
       // A 403 can be a deterministic provider policy rejection, not an
       // invalid OAuth credential. Only the evidence-based classifier above
       // may trigger a refresh.
@@ -495,36 +528,25 @@ export async function runAttemptLoop<TResult, TAdapter>(
   if (!state.completed) {
     const terminal = classifyTerminalOutcome(lastError, state.abortController.signal);
     const lastCandidate = candidates[Math.min(index, candidates.length - 1)];
-    const terminalCapture = [...firedCaptures]
-      .reverse()
-      .find((capture) => capture.request !== null);
-    await completeAttempt(state, {
+    const terminalCapture =
+      lastFiredCapture?.request !== null && lastFiredCapture !== undefined
+        ? lastFiredCapture
+        : undefined;
+    await completeAttempt(state, failureCompletion({
+      state,
+      deps,
+      candidate: lastCandidate,
       status: terminal.status,
-      providerId: lastCandidate?.provider_id ?? "",
-      ...(lastCandidate?.provider_account_id
-        ? { accountId: lastCandidate.provider_account_id }
-        : {}),
-      ...(lastCandidate?.provider_account_label
-        ? { accountLabel: lastCandidate.provider_account_label }
-        : {}),
       errorCategory: terminal.errorCategory,
       errorOrigin: terminal.errorOrigin,
-      ...(lastCandidate?.model_id === undefined ? {} : { modelId: lastCandidate.model_id }),
       error: lastError,
       terminal: true,
       tenantId: input.tenantId,
-      ingressBody: state.ingressBody,
-      responseBody: null,
       // The client receives the public error envelope on the wire — store it
       // so the Client Response panel traces the failure as the client saw it.
-      ...(terminal.status === "cancelled"
-        ? {}
-        : { clientResponseText: errorClientResponseBody(lastError) }),
-      ...(terminalCapture === undefined ? {} : { providerCapture: terminalCapture }),
-      db: deps.db,
-      ...(deps.telemetryBuffer ? { telemetryBuffer: deps.telemetryBuffer } : {}),
-      ...(deps.snapshotService ? { snapshotService: deps.snapshotService } : {}),
-    });
+      providerCapture: terminalCapture,
+      includeClientResponse: true,
+    }));
   }
   metrics.proxy_requests_total.inc(1, { status: "failed" });
   throw lastError;

package/src/transport/dispatch/capture-policy.ts

@@ -0,0 +1,78 @@
+// Tenant payload-capture policy resolved once and shared by dispatch attempts.
+import type { CartethyiaDatabase } from "../../persistence/db-handle";
+import { payloadRetentionMs, resolvePayloadCapture } from "../../observability/payload-capture";
+import type { TelemetryPayloadDepth, TelemetryPayloadMode } from "../../console/settings/contracts";
+
+/** Per-stage body cap for the provider request/response tee. */
+export function providerCaptureMaxBytes(depth?: TelemetryPayloadDepth): number {
+  if (depth === "moderate") return 2 * 1024 * 1024;
+  if (depth === "maximum") return 4 * 1024 * 1024;
+  return 1024 * 1024;
+}
+
+/** Resolve whether provider bodies should be retained, memoized on this request. */
+export async function shouldCaptureProviderBodyForRequest(
+  db: CartethyiaDatabase,
+  tenantId: string | null,
+  state: { payloadCapturePreference?: unknown },
+): Promise<boolean> {
+  if (state.payloadCapturePreference === undefined) {
+    state.payloadCapturePreference = await resolvePayloadCapture(db, tenantId);
+  }
+  const resolved = state.payloadCapturePreference as
+    | { readonly ok: true; readonly mode: string }
+    | { readonly ok: false };
+  return resolved.ok === true && resolved.mode === "full";
+}
+
+/** Resolve the tenant's capture mode once per request; failed reads fail closed. */
+export async function resolveCaptureModeForRequest(
+  db: CartethyiaDatabase,
+  tenantId: string | null,
+  state: { payloadCapturePreference?: unknown },
+): Promise<TelemetryPayloadMode> {
+  if (state.payloadCapturePreference === undefined) {
+    state.payloadCapturePreference = await resolvePayloadCapture(db, tenantId);
+  }
+  const resolved = state.payloadCapturePreference as
+    | { readonly ok: true; readonly mode: TelemetryPayloadMode }
+    | { readonly ok: false };
+  return resolved.ok === true ? resolved.mode : "none";
+}
+
+/** Resolve the tenant's capture depth once per request. */
+export async function resolveCaptureDepthForRequest(
+  db: CartethyiaDatabase,
+  tenantId: string | null,
+  state: { payloadCapturePreference?: unknown },
+): Promise<TelemetryPayloadDepth> {
+  if (state.payloadCapturePreference === undefined) {
+    state.payloadCapturePreference = await resolvePayloadCapture(db, tenantId);
+  }
+  const resolved = state.payloadCapturePreference as
+    | { readonly ok: true; readonly depth: TelemetryPayloadDepth }
+    | { readonly ok: false };
+  return resolved.ok === true ? resolved.depth : "minimum";
+}
+
+/** Resolve the tenant's payload retention once per request. */
+export async function resolveCaptureRetentionForRequest(
+  db: CartethyiaDatabase,
+  tenantId: string | null,
+  state: { payloadCapturePreference?: unknown },
+): Promise<number> {
+  if (state.payloadCapturePreference === undefined) {
+    state.payloadCapturePreference = await resolvePayloadCapture(db, tenantId);
+  }
+  const resolved = state.payloadCapturePreference as
+    | { readonly ok: true; readonly retentionMs: number }
+    | { readonly ok: false };
+  return resolved.ok === true ? resolved.retentionMs : payloadRetentionMs();
+}
+
+/** Combined body cap for the four payload panels at one configured depth. */
+export function captureDepthMaxBytes(depth: TelemetryPayloadDepth): number {
+  if (depth === "moderate") return 8 * 1024 * 1024;
+  if (depth === "maximum") return 16 * 1024 * 1024;
+  return 1 * 1024 * 1024;
+}

package/src/transport/dispatch/proxy-request.ts

@@ -32,11 +32,13 @@ import {
   completionContext,
   estimatedUsage,
   parseCapturedBody,
+  terminalFailure,
+} from "./attempt-finalize";
+import {
   providerCaptureMaxBytes,
   resolveCaptureDepthForRequest,
   shouldCaptureProviderBodyForRequest,
-  terminalFailure,
-} from "./attempt-finalize";
+} from "./capture-policy";
 import { runAttemptLoop } from "./attempt-loop";
 import { projectForRoute, routeCapabilitiesFor } from "../translation/capabilities";
 import { dispatchStreamingAttempt } from "./streaming/stream";

package/src/transport/dispatch/streaming/encoder.ts

@@ -10,8 +10,11 @@
  * client-visible tracking → encode + enqueue) is preserved exactly.
  */
 import type { CanonicalEvent, SourceSurface, UsageRecord } from "../../../protocol/canonical-model";
+import { canonicalTerminal } from "../../../protocol/codecs";
+import { reasoningTextOf } from "../../../protocol/reasoning-text";
 import { MimoThinkSplitter } from "../../../providers/integrations/xiaomi-mimo/think-stream";
 import { createDispatchStreamEncoder, type DispatchStreamEncoder } from "../stream-bridge";
+import { THINKING_LOOP_MARKER, ThinkingLoopDetector } from "./thinking-loop";
 
 /** The terminal event shape every stream settles (or fails to settle) on. */
 export type StreamTerminalEvent = Extract<CanonicalEvent, { type: "terminal" }>;
@@ -78,20 +81,41 @@ export class StreamEventPipeline {
   // One decoder per stream: `new TextDecoder()` per chunk would allocate
   // on every upstream event for the telemetry transcript copy.
   private readonly clientResponseDecoder = new TextDecoder();
+  /**
+   * Resolved tenant capture mode. `none`/`metadata` gate the diagnostics the
+   * tenant will never be able to see: the JSON-serialized event transcript
+   * copy and the client-response accumulation are skipped entirely, so a
+   * privacy-lean tenant's streams cost neither the per-event `JSON.stringify`
+   * nor the up-to-512 KiB buffered client-response copy. The fields the
+   * completion path always needs (terminal, usage, timing, reported model,
+   * event count, client-visible flag) are recorded regardless — the Responses
+   * prelude retry depends on the flag, and the request row depends on the rest.
+   */
+  private readonly diagnosticsCaptureMode: "none" | "metadata" | "full";
   private readonly streamEncoder: DispatchStreamEncoder;
   // One splitter per stream: a thinking tag can straddle two provider chunks,
   // and the text/idle bookkeeping below must see the split result, not the raw
   // tagged chunk.
   private readonly thinkSplitter = new MimoThinkSplitter();
+  /**
+   * Content-level loop guard. A model that degenerates into a repeated
+   * chain-of-thought keeps sending bytes, so the stall timeout — which fires
+   * only on silence — never trips and the runaway burns the whole output
+   * budget. This detector watches the reasoning text itself and terminates the
+   * stream early when a loop shape is recognized.
+   */
+  private readonly loopDetector = new ThinkingLoopDetector();
   private lastSequenceNumber = -1;
 
   constructor(
     surface: SourceSurface,
     encoderOptions: Record<string, unknown>,
     recoverableResponsesPrelude: boolean,
+    diagnostics: { captureMode: "none" | "metadata" | "full" } = { captureMode: "full" },
   ) {
     this.streamEncoder = createDispatchStreamEncoder(surface, encoderOptions);
     this.recoverableResponsesPrelude = recoverableResponsesPrelude;
+    this.diagnosticsCaptureMode = diagnostics.captureMode;
   }
 
   /** Number of canonical events processed, including those omitted from diagnostics. */
@@ -104,6 +128,13 @@ export class StreamEventPipeline {
     return this.clientVisibleEvent;
   }
 
+  /** Whether the loop guard has terminated this stream early. The pull loop
+   *  stops consuming the upstream once it has: continuing would keep billing
+   *  and emitting a runaway the client was already told is over. */
+  get loopDetected(): boolean {
+    return this.loopDetector.detected;
+  }
+
   /** The client-facing response transcript (decoded SSE/JSON) — distinct from the provider-side canonical events. */
   get clientResponseText(): string {
     const text = this.clientResponseChunks.join("");
@@ -114,6 +145,9 @@ export class StreamEventPipeline {
   get telemetryEventTranscript():
     | readonly (CanonicalEvent & { timestamp: number })[]
     | TruncatedEventTranscript {
+    // Gated modes recorded nothing, so the transcript is the plain empty
+    // array — no truncated-marker object for content that was never kept.
+    if (this.diagnosticsCaptureMode !== "full") return [];
     const tail = this.eventTranscriptTail.slice(this.eventTranscriptTailStart).map((entry) => entry.event);
     const events = [...this.eventTranscriptHead, ...tail];
     const omittedEvents = this.totalEventCount - events.length;
@@ -140,6 +174,9 @@ export class StreamEventPipeline {
 
   private recordTelemetryEvent(event: CanonicalEvent & { timestamp: number }): void {
     this.totalEventCount += 1;
+    // Gated diagnostics: the transcript is only ever read by the terminal
+    // capture path in `full` mode, so `none`/`metadata` pay only the count.
+    if (this.diagnosticsCaptureMode !== "full") return;
     // Single serialization per event: the byte size is stored with the entry
     // so eviction subtracts without re-serializing the removed event.
     const eventBytes = Buffer.byteLength(JSON.stringify(event), "utf8");
@@ -179,6 +216,9 @@ export class StreamEventPipeline {
   }
 
   private appendClientResponse(bytes: Uint8Array): void {
+    // Gated diagnostics: the client-response copy feeds only the terminal
+    // capture's client panel, which exists only in `full` mode.
+    if (this.diagnosticsCaptureMode !== "full") return;
     if (this.clientResponseTruncated) return;
     const chunk = this.clientResponseDecoder.decode(bytes, { stream: true });
     if (this.clientResponseLength + chunk.length > CLIENT_RESPONSE_CAP) {
@@ -213,6 +253,12 @@ export class StreamEventPipeline {
     event: CanonicalEvent,
     controller: ReadableStreamDefaultController<Uint8Array>,
   ): boolean {
+    // Once the guard has terminated the stream, the surface encoders reject
+    // any further event — content *and* a second terminal both throw
+    // (`canonical event arrived after terminal`). The pull loop stops on
+    // `loopDetected`, so this only matters for an event already in flight;
+    // dropping it is the alternative to throwing mid-stream.
+    if (this.loopDetector.detected) return false;
     // The one place every surface shares. A provider that writes its reasoning
     // into the answer as `<think>…</think>` had that text forwarded verbatim:
     // the chat wire happened to split it in its own decoder, so chat looked
@@ -222,11 +268,12 @@ export class StreamEventPipeline {
       const split = this.thinkSplitter.push(event.content.text);
       let enqueued = false;
       if (split.reasoning.length > 0) {
-        enqueued =
-          this.enqueueOne(
-            { ...event, content: { kind: "reasoning", payload: null, summary: split.reasoning } },
-            controller,
-          ) || enqueued;
+        const reasoningEvent: CanonicalEvent = {
+          ...event,
+          content: { kind: "reasoning", payload: null, summary: split.reasoning },
+        };
+        enqueued = this.enqueueOne(reasoningEvent, controller) || enqueued;
+        if (this.guardReasoning(split.reasoning, controller)) return enqueued;
       }
       if (split.text.length > 0) {
         enqueued =
@@ -235,6 +282,14 @@ export class StreamEventPipeline {
       }
       return enqueued;
     }
+    // Reasoning a provider already classified: feed it to the guard too, so a
+    // loop is caught whether the reasoning arrived pre-classified or was
+    // recovered from a `<think>` span in the answer.
+    if (event.type === "content_delta" && event.content.kind === "reasoning") {
+      const enqueued = this.enqueueOne(event, controller);
+      this.guardReasoning(reasoningTextOf(event.content) ?? "", controller);
+      return enqueued;
+    }
     // Text held back for a tag that never completed must be released *before*
     // the terminal: a content event after it is rejected by the surface
     // encoders, and the tail of the answer would be lost instead.
@@ -264,6 +319,57 @@ export class StreamEventPipeline {
     return this.enqueueOne(event, controller);
   }
 
+  /**
+   * Feeds one reasoning chunk to the loop guard and, on the first hit,
+   * terminates the stream early. Returns whether it terminated.
+   *
+   * The terminal is a real canonical terminal rather than an error frame: the
+   * client already received valid reasoning, and the runaway is cut off
+   * mid-generation — which is exactly what `stop_reason: "length"` means on
+   * every surface (`length` / `max_tokens`). `provider_stop_reason` carries the
+   * marker so the cut is distinguishable from hitting the real token cap.
+   */
+  private guardReasoning(
+    text: string,
+    controller: ReadableStreamDefaultController<Uint8Array>,
+  ): boolean {
+    const reason = text.length > 0 ? this.loopDetector.push(text) : undefined;
+    if (reason === undefined) return false;
+    // Flush before the terminal: content after it is rejected by the surface
+    // encoders, and the held-back text would be lost.
+    const rest = this.thinkSplitter.flush();
+    if (rest.reasoning.length > 0) {
+      this.enqueueOne(
+        {
+          type: "content_delta",
+          sequence_number: this.lastSequenceNumber + 1,
+          content: { kind: "reasoning", payload: null, summary: rest.reasoning },
+        },
+        controller,
+      );
+    }
+    if (rest.text.length > 0) {
+      this.enqueueOne(
+        {
+          type: "content_delta",
+          sequence_number: this.lastSequenceNumber + 1,
+          content: { kind: "text", text: rest.text },
+        },
+        controller,
+      );
+    }
+    this.enqueueOne(
+      canonicalTerminal({
+        sequenceNumber: this.lastSequenceNumber + 1,
+        state: "complete",
+        stopReason: "length",
+        providerStopReason: THINKING_LOOP_MARKER,
+      }),
+      controller,
+    );
+    return true;
+  }
+
   private enqueueOne(
     event: CanonicalEvent,
     controller: ReadableStreamDefaultController<Uint8Array>,

package/src/transport/dispatch/streaming/stream.ts

@@ -43,12 +43,13 @@ import type { AdmissionLease } from "../../../security/admission/contracts";
 import type { NetworkPoolSelector } from "../../../network/pool/selector";
 import type { TelemetryBatchBuffer } from "../../../observability/telemetry-buffer";
 import type { ProviderExchangeCapture } from "../attempt-finalize";
+import { captureProviderExchange } from "../attempt-finalize";
 import {
-  captureProviderExchange,
   providerCaptureMaxBytes,
   resolveCaptureDepthForRequest,
+  resolveCaptureModeForRequest,
   shouldCaptureProviderBodyForRequest,
-} from "../attempt-finalize";
+} from "../capture-policy";
 import { resolveTenantImageClampMaxBytes } from "../../request/tenant-preferences";
 import { proxySuccessHeaders, buildUpstreamDispatchContext } from "../upstream";
 import type { AttemptLeaseOwnership } from "../leases";
@@ -179,6 +180,14 @@ export async function dispatchStreamingAttempt(input: StreamingDispatchInput): P
     prepared.authorization.snapshot.tenant_id,
     state,
   );
+  // Resolved once, before the pipeline exists: the pipeline's diagnostics are
+  // gated on it from construction, so `none`/`metadata` tenants never pay the
+  // transcript serialization or the client-response copy for any event.
+  const captureMode = await resolveCaptureModeForRequest(
+    deps.db,
+    prepared.authorization.snapshot.tenant_id,
+    state,
+  );
   const wrappedOutboundFetch = outboundFetch
     ? captureProviderExchange(
         outboundFetch,
@@ -276,6 +285,7 @@ export async function dispatchStreamingAttempt(input: StreamingDispatchInput): P
         ? { response_id: `msg-${crypto.randomUUID()}`, model: candidate.model_id }
         : streamOptions,
     recoverableResponsesPrelude,
+    { captureMode },
   );
   const finalizer = new StreamFinalizer(
     {
@@ -400,6 +410,13 @@ export async function dispatchStreamingAttempt(input: StreamingDispatchInput): P
             }
             sawUpstreamActivity = true;
             if (pipeline.enqueueEvent(result.value, controller)) return;
+            // The guard terminated the stream early: stop consuming. Pulling
+            // on would keep the runaway upstream alive and bill tokens the
+            // client was already told are not coming.
+            if (pipeline.loopDetected) {
+              await finalizer.finalizeStream(controller);
+              return;
+            }
           }
         } catch (err) {
           finalizer.clearStallWatchdog();