cartethyia 2.7.4 → 2.7.5

package/src/transport/dispatch/generation.ts

@@ -20,20 +20,26 @@
  */
 import type { ImageGenerationOutcome, ProviderAdapter, ProviderDispatchTarget } from "../../providers/provider-contracts";
 import { GatewayError } from "../../protocol/gateway-error";
-import { resolveCredentialForAccount } from "../../providers/operations/provider-credential-service";
 import type { ServiceKind } from "../../protocol/canonical-model";
 import { metrics } from "../../observability/metrics";
 import type { ProxyRequestState } from "../request/state";
 import { completeAttempt, estimatedUsage, nativeCompletionBase } from "./attempt-finalize";
 import { runAttemptLoop } from "./attempt-loop";
 import { captureProviderRateLimit } from "./ratelimit-capture";
+import {
+  hasScope,
+  jsonResponse,
+  networkFetchContext,
+  requireRecordBody,
+  resolveAttemptCredential,
+} from "./native-shared";
 
 import type { GatewayHandlerDeps } from "./handler-deps";
 
-export type GenerationHandlerDeps = GatewayHandlerDeps;
+type GenerationHandlerDeps = GatewayHandlerDeps;
 
 /** Which surface a handler serves. Drives candidate filtering and error copy. */
-export type GenerationKind = Extract<ServiceKind, "imageGeneration" | "videoGeneration">;
+type GenerationKind = Extract<ServiceKind, "imageGeneration" | "videoGeneration">;
 
 /**
  * Surfaces the gateway routes but does not model.
@@ -44,7 +50,7 @@ export type GenerationKind = Extract<ServiceKind, "imageGeneration" | "videoGene
  * is the whole feature: routing, admission, failover, and accounting still
  * apply, and the upstream's own bytes come back untouched.
  */
-export type PassthroughKind = Extract<ServiceKind, "embedding" | "audioTranscription" | "audioSpeech">;
+type PassthroughKind = Extract<ServiceKind, "embedding" | "audioTranscription" | "audioSpeech">;
 
 /** Error-copy noun per surface, so a refusal names what the caller asked for. */
 const SURFACE_NOUNS: Record<GenerationKind | PassthroughKind, string> = {
@@ -74,13 +80,6 @@ function isMediaKind(kind: GenerationKind | PassthroughKind): kind is Generation
  */
 const MAX_ITEMS_PER_REQUEST = 10;
 
-function jsonResponse(payload: unknown, status: number, requestId: string): Response {
-  return new Response(JSON.stringify(payload), {
-    status,
-    headers: { "content-type": "application/json", "x-request-id": requestId },
-  });
-}
-
 /**
  * Forwards a streaming upstream response to the client and accounts for it.
  *
@@ -145,12 +144,12 @@ async function passThrough(
 }
 
 /** Builds the handler for one generation surface. */
-export function createGenerationHandler(kind: GenerationKind, deps: GenerationHandlerDeps) {
+function createGenerationHandler(kind: GenerationKind, deps: GenerationHandlerDeps) {
   return createNativeSurfaceHandler(kind, deps);
 }
 
 /** Builds the handler for one routed surface, media or passthrough. */
-export function createNativeSurfaceHandler(
+function createNativeSurfaceHandler(
   kind: GenerationKind | PassthroughKind,
   deps: GenerationHandlerDeps,
 ) {
@@ -158,19 +157,14 @@ export function createNativeSurfaceHandler(
   return async ({ request }: { request: Request }): Promise<Response> => {
     const state = deps.stateStore.require(request);
     const authorization = state.authorization;
-    const body = state.ingressBody;
-    if (!authorization || body === null || typeof body !== "object" || Array.isArray(body)) {
-      throw new GatewayError(
-        "invalid_request",
-        400,
-        `The ${noun} body must be a JSON object (request {requestId}). Send one with at least a model and a prompt. Check the shape of what you sent — then resend 🪞`,
-      );
-    }
-    const generation = body as Record<string, unknown>;
+    const generation = requireRecordBody(
+      state,
+      `The ${noun} body must be a JSON object (request {requestId}). Send one with at least a model and a prompt. Check the shape of what you sent — then resend 🪞`,
+    );
     if (typeof generation.model !== "string" || generation.model.trim().length === 0) {
       throw new GatewayError("invalid_request", 400, `A model is required (request {requestId}): it names the ${noun} provider to use. Check the shape of what you sent — then resend 🪞`);
     }
-    if (!authorization.snapshot.scopes?.includes("routing:invoke" as never)) {
+    if (!hasScope(authorization?.snapshot.scopes, "routing:invoke")) {
       throw new GatewayError(
         "policy_rejected",
         403,
@@ -200,10 +194,15 @@ export function createNativeSurfaceHandler(
     const prepared = await deps.proxyPreparer.prepareNativeService({
       model: generation.model,
       serviceKind: kind,
-      authorization,
+      // `requireRecordBody` already refused a missing authorization; this guard
+      // exists only to narrow the type for the code below.
+      authorization: authorization!,
       ...(state.abortController.signal ? { signal: state.abortController.signal } : {}),
       ...(state.clientUserAgent === undefined ? {} : { clientUserAgent: state.clientUserAgent }),
     });
+    if (!authorization) {
+      throw new GatewayError("invalid_request", 400, "authentication required (request {requestId})");
+    }
 
     return runAttemptLoop<Response, ProviderAdapter>({
       state,
@@ -221,19 +220,7 @@ export function createNativeSurfaceHandler(
       strictPoolSelection: false,
       exhaustedError: new GatewayError("route_unavailable", 503, `no eligible ${noun} generation route (request {requestId}). The bouncer stepped out — come back shortly 🚪`),
       prepare: async (candidate) => {
-        const credential = candidate.provider_account_id
-          ? await resolveCredentialForAccount(
-              deps.db,
-              candidate.provider_id,
-              candidate.provider_account_id,
-              deps.oauthRefreshService && deps.resolveOAuthRefresher
-                ? { refreshService: deps.oauthRefreshService, resolveRefresher: deps.resolveOAuthRefresher }
-                : undefined,
-            )
-          : {
-              provider_id: candidate.provider_id as ProviderAdapter["provider_id"],
-              credential_kind: "none" as const,
-            };
+        const credential = await resolveAttemptCredential(deps, candidate);
         const adapter = await deps.resolveProviderAdapter?.(candidate.provider_id);
         if (!adapter) {
           throw new GatewayError(
@@ -309,14 +296,7 @@ export function createNativeSurfaceHandler(
           abort_signal: state.abortController.signal,
           request_headers: inboundHeaders,
           ...(candidate.user_agent === undefined ? {} : { user_agent: candidate.user_agent }),
-          ...(deps.networkBindingFactory
-            ? {
-                outbound_fetch: deps.networkBindingFactory.fetch(
-                  leases.proxySlot?.poolId,
-                  authorization.tenantId,
-                ),
-              }
-            : {}),
+          ...networkFetchContext(deps, leases.proxySlot?.poolId, authorization.tenantId),
         };
         // Prefer the provider's own method for this kind; otherwise post the
         // body to the candidate's endpoint through the adapter, which owns the

package/src/transport/dispatch/native-shared.ts

@@ -0,0 +1,127 @@
+/**
+ * Shared helpers for the native dispatch handlers (web search, token count,
+ * System One, responses-compact, generation). The handlers previously spelled
+ * the same credential-resolution, outbound-fetch, body-validation, thinking-
+ * suffix, response-serialization, and usage-clone blocks by hand, and the
+ * copies could drift (generation's `jsonResponse` lost the `cache-control`
+ * header). One home here keeps them in step.
+ */
+import { GatewayError } from "../../protocol/gateway-error";
+import type { ProviderId, ResolvedCredential, ValidatedOutboundFetch } from "../../providers/provider-contracts";
+import { resolveCredentialForAccount } from "../../providers/operations/provider-credential-service";
+import { repriceUsage, usageFromProvider } from "../../providers/provider-usage";
+import type { UsageRecord } from "../../protocol/canonical-model";
+import { parseThinkingSuffix } from "../../protocol/translation/thinking";
+import type { GatewayHandlerDeps } from "./handler-deps";
+
+/**
+ * Whether a scope list contains the named scope. The native handlers used to
+ * force `scopes?.includes(name as never)` — a type-loop hole that bypassed
+ * the `AccessScope` union only to compare runtime strings. The check is the
+ * same, with a real `readonly string[]` receiver.
+ */
+export function hasScope(scopes: readonly string[] | undefined, name: string): boolean {
+  return scopes?.includes(name) === true;
+}
+
+/**
+ * Resolves the credential for one candidate: a real account credential when
+ * the candidate carries an account, otherwise the credential-less `"none"`
+ * credential. Shared by every native handler's `prepare`.
+ */
+export async function resolveAttemptCredential(
+  deps: Pick<GatewayHandlerDeps, "db" | "oauthRefreshService" | "resolveOAuthRefresher">,
+  candidate: { readonly provider_id: string; readonly provider_account_id?: string },
+): Promise<ResolvedCredential> {
+  if (!candidate.provider_account_id) {
+    return {
+      provider_id: candidate.provider_id as ProviderId,
+      credential_kind: "none" as const,
+    };
+  }
+  return resolveCredentialForAccount(
+    deps.db,
+    candidate.provider_id,
+    candidate.provider_account_id,
+    deps.oauthRefreshService && deps.resolveOAuthRefresher
+      ? { refreshService: deps.oauthRefreshService, resolveRefresher: deps.resolveOAuthRefresher }
+      : undefined,
+  );
+}
+
+/** The outbound-fetch context fragment native handlers spread into the dispatch context. */
+export function networkFetchContext(
+  deps: { readonly networkBindingFactory?: GatewayHandlerDeps["networkBindingFactory"] },
+  poolId: string | undefined,
+  tenantId: string | null,
+): { outbound_fetch?: ValidatedOutboundFetch } {
+  if (!deps.networkBindingFactory) return {};
+  return { outbound_fetch: deps.networkBindingFactory.fetch(poolId, tenantId ?? undefined) };
+}
+
+/** Serializes a JSON payload with the shared native-response header set. */
+export function jsonResponse(payload: unknown, status: number, requestId: string): Response {
+  return new Response(JSON.stringify(payload), {
+    status,
+    headers: {
+      "content-type": "application/json",
+      "cache-control": "no-store",
+      "x-request-id": requestId,
+    },
+  });
+}
+
+/**
+ * Strips a thinking suffix (`model(high)`) from the model name and rebuilds
+ * the body with the bare model when it changed. Returns the bare model and
+ * the body to forward upstream.
+ */
+export function stripThinkingSuffix(
+  model: string,
+  body: Record<string, unknown>,
+): { bareModel: string; body: Record<string, unknown> } {
+  const { model: bareModel } = parseThinkingSuffix(model);
+  return { bareModel, body: bareModel === model ? body : { ...body, model: bareModel } };
+}
+
+/**
+ * Validates the ingress body is a non-null object and returns it as a record.
+ * Throws the standard `invalid_request` with the caller's message (kept
+ * per-route so the wire text is unchanged).
+ */
+export function requireRecordBody(
+  state: { readonly authorization?: unknown; readonly ingressBody?: unknown },
+  message: string,
+): Record<string, unknown> {
+  const { authorization, ingressBody } = state;
+  if (!authorization || ingressBody === null || typeof ingressBody !== "object" || Array.isArray(ingressBody))
+    throw new GatewayError("invalid_request", 400, message);
+  return ingressBody as Record<string, unknown>;
+}
+
+/**
+ * Reads usage from an upstream response clone, repricing the reported value (or
+ * the caller's estimate) for the routed provider/model. Shared by the native
+ * handlers that proxy an upstream JSON body verbatim.
+ */
+export async function usageFromUpstreamClone(
+  response: Response,
+  estimate: UsageRecord,
+  providerId: string,
+  modelId: string,
+): Promise<UsageRecord> {
+  let reportedUsage: ReturnType<typeof usageFromProvider>;
+  try {
+    const parsed: unknown = await response.clone().json();
+    reportedUsage = usageFromProvider(
+      typeof parsed === "object" && parsed !== null
+        ? (parsed as Record<string, unknown>)["usage"]
+        : undefined,
+    );
+  } catch {
+    reportedUsage = undefined;
+  }
+  return repriceUsage(reportedUsage ?? estimate, providerId, modelId);
+}
+
+

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

@@ -41,7 +41,7 @@ import type { PreparedProxyRequest } from "../request/preparer";
 
 import type { GatewayHandlerDeps } from "./handler-deps";
 
-export type ProviderProxyHandlerDeps = GatewayHandlerDeps & {
+type ProviderProxyHandlerDeps = GatewayHandlerDeps & {
   /** Live lookup of a provider's SSRF-validated upstream host. */
   readonly byokUpstreamHosts?: { readonly get: (providerId: string) => ByokUpstreamHost | undefined };
 };
@@ -135,6 +135,7 @@ export async function handleProviderProxyRequest(
         {
           providerId: candidateForPrompt.provider_id,
           modelId: candidateForPrompt.model_id,
+          requestedModel: prepared.plan?.requested_model ?? candidateForPrompt.model_id,
         },
       )?.text
     : undefined;
@@ -239,6 +240,7 @@ export async function handleProviderProxyRequest(
         ...(candidate.output_limit == null ? {} : { output_limit: candidate.output_limit }),
         capabilities: candidate.capability_profile,
         user_agent: candidate.user_agent,
+        ...(candidate.dialect === undefined ? {} : { dialect: candidate.dialect }),
       };
       const candidateRequest =
         candidate.model_id === dispatchRequest.model

package/src/transport/dispatch/responses-compact.ts

@@ -1,11 +1,15 @@
 import { GatewayError } from "../../protocol/gateway-error";
-import { resolveCredentialForAccount } from "../../providers/operations/provider-credential-service";
 import { metrics } from "../../observability/metrics";
-import { parseThinkingSuffix } from "../../protocol/translation/thinking";
 import type { CodexCompactAdapter } from "../../providers/integrations/codex/codex";
 import { completeAttempt, estimatedUsage, nativeCompletionBase } from "./attempt-finalize";
-import { repriceUsage, usageFromProvider } from "../../providers/provider-usage";
 import { runAttemptLoop } from "./attempt-loop";
+import {
+  networkFetchContext,
+  requireRecordBody,
+  resolveAttemptCredential,
+  stripThinkingSuffix,
+  usageFromUpstreamClone,
+} from "./native-shared";
 
 /**
  * The native Codex compaction route (`POST /v1/responses/compact`) and the
@@ -13,7 +17,7 @@ import { runAttemptLoop } from "./attempt-loop";
  */
 import type { GatewayHandlerDeps } from "./handler-deps";
 
-export type ResponsesCompactHandlerDeps = GatewayHandlerDeps;
+type ResponsesCompactHandlerDeps = GatewayHandlerDeps;
 
 /**
  * Handles `POST /v1/responses/compact`: the native Codex compaction proxy. The
@@ -25,10 +29,10 @@ export function createResponsesCompactHandler(deps: ResponsesCompactHandlerDeps)
   return async ({ request }: { request: Request }): Promise<Response> => {
     const state = deps.stateStore.require(request);
     const authorization = state.authorization;
-    const body = state.ingressBody;
-    if (!authorization || body === null || typeof body !== "object" || Array.isArray(body))
-      throw new GatewayError("invalid_request", 400, "compact request body must be a JSON object (request {requestId}). Check the shape of what you sent — then resend 🪞");
-    const compact = body as Record<string, unknown>;
+    const compact = requireRecordBody(
+      state,
+      "compact request body must be a JSON object (request {requestId}). Check the shape of what you sent — then resend 🪞",
+    );
     if (typeof compact.model !== "string" || compact.model.trim().length === 0)
       throw new GatewayError("invalid_request", 400, "model is required (request {requestId}). Check the shape of what you sent — then resend 🪞");
     // A thinking suffix (`model(high)`) is stripped here for the same reason the
@@ -39,9 +43,7 @@ export function createResponsesCompactHandler(deps: ResponsesCompactHandlerDeps)
     // reasoning effort to shape, and the body is passed upstream verbatim.
     // Stripping keeps a client that appends the suffix to every request working
     // here instead of failing with a misleading model-not-found.
-    const { model: compactModel } = parseThinkingSuffix(compact.model);
-    const compactBody: Record<string, unknown> =
-      compactModel === compact.model ? compact : { ...compact, model: compactModel };
+    const { bareModel: compactModel, body: compactBody } = stripThinkingSuffix(compact.model, compact);
     if (!(typeof compact.input === "string" || Array.isArray(compact.input)))
       throw new GatewayError("invalid_request", 400, "input must be a string or array (request {requestId}). Check the shape of what you sent — then resend 🪞");
     if ("instructions" in compact && typeof compact.instructions !== "string")
@@ -57,7 +59,7 @@ export function createResponsesCompactHandler(deps: ResponsesCompactHandlerDeps)
       throw new GatewayError("admission_unavailable", 503, "Codex compact transport unavailable (request {requestId}). The bouncer stepped out — come back shortly 🚪");
     const prepared = await deps.proxyPreparer.prepareNativeCompact({
       model: compactModel,
-      authorization,
+      authorization: authorization!,
       signal: state.abortController.signal,
       ...(state.clientUserAgent === undefined ? {} : { clientUserAgent: state.clientUserAgent }),
     });
@@ -88,14 +90,10 @@ export function createResponsesCompactHandler(deps: ResponsesCompactHandlerDeps)
             503,
             "Codex compact requires an OAuth account (request {requestId}). Wrong key, right door — check the credential 🔑",
           );
-        const credential = await resolveCredentialForAccount(
-          deps.db,
-          "codex",
-          candidate.provider_account_id,
-          deps.oauthRefreshService && deps.resolveOAuthRefresher
-            ? { refreshService: deps.oauthRefreshService, resolveRefresher: deps.resolveOAuthRefresher }
-            : undefined,
-        );
+        const credential = await resolveAttemptCredential(deps, {
+          ...candidate,
+          provider_id: "codex",
+        });
         if (credential.credential_kind !== "oauth")
           throw new GatewayError(
             "capability_unsupported",
@@ -110,36 +108,17 @@ export function createResponsesCompactHandler(deps: ResponsesCompactHandlerDeps)
           credential,
           deadline: state.deadlineMs,
           abort_signal: state.abortController.signal,
-          ...(deps.networkBindingFactory
-            ? {
-                outbound_fetch: deps.networkBindingFactory.fetch(
-                  leases.proxySlot?.poolId,
-                  authorization.tenantId,
-                ),
-              }
-            : {}),
+          ...networkFetchContext(deps, leases.proxySlot?.poolId, authorization!.tenantId),
         });
         // Prefer the usage the compaction endpoint actually reported. The
         // estimate is a fixed 1024+1024 reserve, and compaction is by
         // construction a large-input operation, so charging it unconditionally
-        // let real spend run far past the counter. `usageFromProvider` returns
-        // undefined when the body reported nothing, which keeps the estimate as
-        // the fallback. `response.clone()` leaves the body readable for the
-        // client.
-        let reportedUsage: ReturnType<typeof usageFromProvider>;
-        try {
-          const parsed: unknown = await response.clone().json();
-          reportedUsage = usageFromProvider(
-            typeof parsed === "object" && parsed !== null
-              ? (parsed as Record<string, unknown>)["usage"]
-              : undefined,
-          );
-        } catch {
-          reportedUsage = undefined;
-        }
-        const usage = repriceUsage(
-          reportedUsage ??
-            estimatedUsage(prepared.estimatedInputTokens, prepared.estimatedOutputTokens),
+        // let real spend run far past the counter. `usageFromUpstreamClone`
+        // falls back to the estimate when the body reported nothing, and
+        // `response.clone()` leaves the body readable for the client.
+        const usage = await usageFromUpstreamClone(
+          response,
+          estimatedUsage(prepared.estimatedInputTokens, prepared.estimatedOutputTokens),
           candidate.provider_id,
           candidate.model_id,
         );

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

@@ -12,12 +12,12 @@
 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 { ThinkSplitter } from "../../../protocol/think-split";
 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" }>;
+type StreamTerminalEvent = Extract<CanonicalEvent, { type: "terminal" }>;
 
 /**
  * SSE comment frame: valid framing on every streamed surface, ignored by
@@ -46,7 +46,7 @@ interface TruncatedEventTranscript {
 }
 
 /** Error-frame input in the shape the dispatch stream encoder accepts. */
-export type StreamErrorFrameInput = Parameters<DispatchStreamEncoder["encodeError"]>[0];
+type StreamErrorFrameInput = Parameters<DispatchStreamEncoder["encodeError"]>[0];
 
 /**
  * Per-event state and framing for one stream. Client framing and protocol
@@ -93,10 +93,11 @@ export class StreamEventPipeline {
    */
   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();
+  // One splitter per stream, kept purely as a feeder for the loop guard: it
+  // reports the content currently inside an open `<think>` span so a runaway
+  // chain-of-thought is caught even when the provider wrote it into the text
+  // stream. It never re-routes the emitted events — text is forwarded verbatim.
+  private readonly thinkSplitter = new ThinkSplitter();
   /**
    * Content-level loop guard. A model that degenerates into a repeated
    * chain-of-thought keeps sending bytes, so the stall timeout — which fires
@@ -259,26 +260,17 @@ export class StreamEventPipeline {
     // `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
-    // right while messages and responses — and any other provider wire whose
-    // text carries the tags — showed the raw reasoning as the answer.
+    // Text is forwarded verbatim: inline thinking tags are a per-provider
+    // decoder concern, not a universal one. Splitting them here for every
+    // surface misclassified literal `<think>` in an answer as reasoning — the
+    // answer vanished into the thinking pane and the poisoned history stopped
+    // follow-up turns. The loop guard still watches reasoning a provider puts
+    // inside an open `<think>` span, without reclassifying the answer.
     if (event.type === "content_delta" && event.content.kind === "text") {
+      const enqueued = this.enqueueOne(event, controller);
       const split = this.thinkSplitter.push(event.content.text);
-      let enqueued = false;
-      if (split.reasoning.length > 0) {
-        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 =
-          this.enqueueOne({ ...event, content: { kind: "text", text: split.text } }, controller) ||
-          enqueued;
+      if (split.pendingReasoning.length > 0) {
+        if (this.guardReasoning(split.pendingReasoning, controller)) return true;
       }
       return enqueued;
     }
@@ -290,31 +282,8 @@ export class StreamEventPipeline {
       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.
     if (event.type === "terminal") {
-      const rest = this.thinkSplitter.flush();
-      if (rest.reasoning.length > 0) {
-        this.enqueueOne(
-          {
-            type: "content_delta",
-            sequence_number: event.sequence_number,
-            content: { kind: "reasoning", payload: null, summary: rest.reasoning },
-          },
-          controller,
-        );
-      }
-      if (rest.text.length > 0) {
-        this.enqueueOne(
-          {
-            type: "content_delta",
-            sequence_number: event.sequence_number,
-            content: { kind: "text", text: rest.text },
-          },
-          controller,
-        );
-      }
+      return this.enqueueOne(event, controller);
     }
     return this.enqueueOne(event, controller);
   }
@@ -335,29 +304,6 @@ export class StreamEventPipeline {
   ): 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,

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

@@ -39,7 +39,7 @@ import {
 import { KEEPALIVE_COMMENT_BYTES, type StreamEventPipeline } from "./encoder";
 
 /** Collaborators the stream tail reads from the dispatch handler. */
-export interface StreamFinalizeDeps {
+interface StreamFinalizeDeps {
   readonly db: CartethyiaDatabase;
   readonly poolSelector?: NetworkPoolSelector | undefined;
   readonly telemetryBuffer?: TelemetryBatchBuffer | undefined;
@@ -56,7 +56,7 @@ export interface StreamCandidateIdentity {
 }
 
 /** What the stream tail needs from the attempt's input. */
-export interface StreamFinalizeInput {
+interface StreamFinalizeInput {
   readonly state: ProxyRequestState;
   readonly deps: StreamFinalizeDeps;
   readonly prepared: PreparedProxyRequest;

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

@@ -64,7 +64,7 @@ import { StreamEventPipeline } from "./encoder";
 import { StreamFinalizer, type StreamCandidateIdentity } from "./finalize";
 
 /** Collaborators the streaming branch reads from the dispatch handler. */
-export interface StreamingDispatchDeps {
+interface StreamingDispatchDeps {
   readonly db: CartethyiaDatabase;
   readonly networkBindingFactory?: ValidatedNetworkBindingFactory | undefined;
   readonly poolSelector?: NetworkPoolSelector | undefined;
@@ -73,7 +73,7 @@ export interface StreamingDispatchDeps {
 }
 
 /** Everything one streamed attempt needs, all resolved by its caller. */
-export interface StreamingDispatchInput {
+interface StreamingDispatchInput {
   readonly state: ProxyRequestState;
   readonly deps: StreamingDispatchDeps;
   readonly prepared: PreparedProxyRequest;
@@ -228,7 +228,11 @@ export async function dispatchStreamingAttempt(input: StreamingDispatchInput): P
       if (!isWrappedInjectionProvider(candidate.provider_id)) return {};
       const text = resolveTenantSystemPrompt(
         await readTenantSystemPromptsForDispatch(deps.db, prepared.authorization.snapshot.tenant_id),
-        { providerId: candidate.provider_id, modelId: candidate.model_id },
+        {
+          providerId: candidate.provider_id,
+          modelId: candidate.model_id,
+          requestedModel: prepared.plan?.requested_model ?? candidate.model_id,
+        },
       )?.text;
       return text === undefined ? {} : { tenantSystemPrompt: text };
     })()),

package/src/transport/dispatch/streaming/thinking-loop.ts

@@ -70,7 +70,7 @@ const SEGMENT_MIN_CLUSTER = 4;
  *  would hide every later prose paragraph from the heuristics. */
 const CODE_LINE = /^(?:[ \t]*```.*|(?: {2,}|\t)(?![ \t]*(?:[-*+]|\d+[.)])[ \t]).*|.*[{}[\](;,>][ \t]*)$/gm;
 
-export interface ThinkingLoopConfig {
+interface ThinkingLoopConfig {
   readonly enabled?: boolean;
 }