@mupt-ai/dari-gateway 0.3.1 → 0.3.3

package/dist/telemetry/report.js

@@ -16,7 +16,7 @@ import { routingBillingProviderAttemptFacts, } from "./billing_finalization.js";
 import { estimateBenchmarkReplay } from "./benchmark_replay.js";
 import { extractInteractionObservability } from "./requests/interaction_observability.js";
 import { costString, finiteNumber, isRecord, tokenCount, } from "./ingest_values.js";
-import { buildCompletedPrefixHit, leaseCountdownForPrefix, prefixEntryForIngest, reportPendingLease, reportPrefixState, } from "./prefix_state.js";
+import { buildCompletedPrefixHit, leaseCountdownForPrefix, prefixEntryForIngest, reportPrefixState, } from "./prefix_state.js";
 import { subscriptionUsageLimitFromFailure } from "../providers/subscription_limits.js";
 import { scrubSecrets } from "./scrub.js";
 import { encodeRetainedInteractionRequest } from "./requests/retained_interaction_request.js";
@@ -50,7 +50,6 @@ export class RequestReporter {
     selectorOutputAccepted = false;
     decision = null;
     nextDecision = null;
-    fallbackDecision = null;
     providerAttempts = [];
     billingProviderAttempts = [];
     decisionDetails = {};
@@ -66,7 +65,6 @@ export class RequestReporter {
         this.selectorOutputAccepted = true;
         this.decision = run.decision;
         this.nextDecision = run.decision;
-        this.fallbackDecision = run.fallbackDecision ?? null;
     }
     attachSpeculativeSelectorRun(run, servingDecision) {
         this.selectorRun = run;
@@ -74,7 +72,6 @@ export class RequestReporter {
         this.selectorOutputAccepted = true;
         this.decision = servingDecision;
         this.nextDecision = run.decision;
-        this.fallbackDecision = run.fallbackDecision ?? null;
     }
     // Speculative execution can begin before a selector run; its serving
     // decision drives selected-model attribution, prefix entries, and errors.
@@ -82,9 +79,6 @@ export class RequestReporter {
         this.decision = decision;
         this.nextDecision = decision;
     }
-    attachFallbackDecision(decision) {
-        this.fallbackDecision = decision ?? null;
-    }
     attachServingDecision(decision) {
         this.decision = decision;
     }
@@ -96,10 +90,10 @@ export class RequestReporter {
     modelCost(attempt) {
         return modelCost(attempt ? [...this.billingProviderAttempts, this.billingFacts(attempt)] : this.billingProviderAttempts);
     }
-    billingFacts({ execution, message, role, attempt, billingOutcome }) {
+    billingFacts({ execution, message, attempt, billingOutcome }) {
         return routingBillingProviderAttemptFacts({
             provider: execution.provider, model: execution.model,
-            providerKeySource: execution.providerKeySource, role, attempt, outcome: billingOutcome,
+            providerKeySource: execution.providerKeySource, attempt, outcome: billingOutcome,
             providerMessage: message, usage: isRecord(message.usage) ? message.usage : null,
             providerPricingKnown: this.pricingKnown(execution.model),
         });
@@ -224,16 +218,8 @@ export class RequestReporter {
             const decision = this.decision;
             const selectedModel = outcome.providerExecution?.model ?? decision?.selectedModel ?? null;
             const reasoningBucket = decision?.reasoningEffort ?? null;
-            // A completed fallback attempt means the intended pair failed this
-            // turn: the next-turn recommendation and any lease countdown follow the
-            // pair that actually served instead of re-pinning the failed one.
-            const fallbackServed = this.providerAttempts.some((attempt) => attempt.role === "fallback" && attempt.outcome === "completed");
-            const nextModel = fallbackServed
-                ? selectedModel
-                : this.nextDecision?.selectedModel ?? selectedModel;
-            const nextReasoningEffort = fallbackServed
-                ? reasoningBucket
-                : this.nextDecision?.reasoningEffort ?? reasoningBucket;
+            const nextModel = this.nextDecision?.selectedModel ?? selectedModel;
+            const nextReasoningEffort = this.nextDecision?.reasoningEffort ?? reasoningBucket;
             const selectedProvider = outcome.providerExecution?.provider ?? (selectedModel
                 ? executionProviderForModel(a.credentials, selectedModel)
                 : null);
@@ -292,7 +278,6 @@ export class RequestReporter {
                     leaseTurnsRemaining: leaseCountdownForPrefix({
                         served: decision ?? null,
                         next: this.nextDecision,
-                        fallbackServed,
                     }),
                     reason: this.nextDecision?.reason ?? decision?.reason ?? null,
                     chain: selectedChain,
@@ -324,19 +309,6 @@ export class RequestReporter {
             // resolves this turn's conversation id and next-model prediction.
             // The full report below re-applies the same state idempotently, so a
             // lost or timed-out fast write only degrades to the old ordering.
-            // An ordinary fallback breaks any lease commitment, prefetched ones
-            // included. A lease-aware fallback transfers the active countdown to
-            // the serving pair, so only clear pending state when no countdown was
-            // transferred. The depth fence orders the clear safely against
-            // in-flight prefetch writes.
-            if (!backgroundRequest && fallbackServed && decision?.leaseTurnsRemaining === undefined) {
-                trackBackgroundTelemetry(reportPendingLease({
-                    routerId: a.routerId,
-                    conversationId: a.conversationId,
-                    decidedAtDepth: a.leaseDepth,
-                    lease: null,
-                }));
-            }
             if (prefixEntry !== null || touchedHash !== null) {
                 this.prefixStatePromise = reportPrefixState({
                     organization_id: a.credentials.organization_id,
@@ -404,12 +376,6 @@ export class RequestReporter {
                     strategy: a.strategy,
                     selected_reasoning_effort: reasoningBucket,
                     next_reasoning_effort: nextReasoningEffort,
-                    ...(this.fallbackDecision
-                        ? {
-                            fallback_model: this.fallbackDecision.selectedModel,
-                            fallback_reasoning_effort: this.fallbackDecision.reasoningEffort,
-                        }
-                        : {}),
                     ...(this.providerAttempts.length > 0
                         ? { provider_attempts: this.providerAttempts }
                         : {}),
@@ -466,8 +432,6 @@ export class RequestReporter {
                     selected_reasoning_effort: reasoningBucket,
                     next_model: nextModel,
                     next_reasoning_effort: nextReasoningEffort,
-                    fallback_model: this.fallbackDecision?.selectedModel ?? null,
-                    fallback_reasoning_effort: this.fallbackDecision?.reasoningEffort ?? null,
                     provider_key_source: keySource,
                     message_count: observability.messageCount,
                     tool_count: observability.metadata.declared_tool_counts.total,

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { CustomRouterConfig, Provider, ReasoningEffort, RouterEval, RouterEvalScore, RouterModelPrice, RouterPrefixHit, RoutingStrategy } from "@mupt-ai/dari-router/policy-engine";
+import type { CustomRouterConfig, Provider, ReasoningEffort, RouterEval, RouterEvalScore, RouterModelPrice, RouterPrefixHit, RoutingDecision, RoutingStrategy } from "@mupt-ai/dari-router/policy-engine";
 export type ProviderKeySource = "user" | "managed" | "subscription";
 export type BearerProviderAuth = {
     type: "bearer";
@@ -41,6 +41,9 @@ export type PublicEvalCatalogCard = Omit<RouterEval, "scores"> & {
     updated_at: string | null;
     scores: PublicEvalCatalogScore[];
 };
+export type ServedDecision = RoutingDecision & {
+    sessionPinned?: boolean;
+};
 export type ClientHarness = "claude_code" | "muse_code";
 export type ResolvedRouterModelConfig = {
     provider: string;
@@ -74,11 +77,10 @@ export type ResolvedRouter = {
     zdr?: boolean;
     allow_long_context?: boolean;
     speculative_routing?: boolean;
+    session_pinning?: boolean;
     primary_retries?: number;
     strict?: boolean;
     strict_providers?: string[];
-    model_fallback_enabled?: boolean;
-    fallback_requires_different_provider?: boolean;
     evals?: RouterEval[];
     eval_score_imputation?: boolean;
     image_capability_filtering?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mupt-ai/dari-gateway",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Self-hostable LLM gateway for coding agents and APIs: one endpoint for Anthropic Messages, OpenAI Chat Completions, and OpenAI Responses, with subscription pooling, failover, and prompt-cache-aware routing.",
   "license": "Apache-2.0",
   "repository": {
@@ -50,7 +50,7 @@
   "dependencies": {
     "@aws-sdk/client-sts": "3.1063.0",
     "@mupt-ai/dari-router": "0.2.5",
-    "@mupt-ai/pi-ai": "1.4.0-mupt.1"
+    "@mupt-ai/pi-ai": "1.4.0-mupt.2"
   },
   "devDependencies": {
     "@types/bun": "^1.3.4",

package/src/context/interaction_fingerprint.ts

@@ -105,7 +105,10 @@ export function interactionLooseChain(routerId: string, request: InteractionRequ
 // unrelated work reusing the same harness session gets a new group.
 export function interactionConversationPrefix(request: InteractionRequest): string {
   const firstStep = conversationFingerprintSteps(
-    looseFingerprintSteps(request.sourceProtocol, request.items),
+    looseFingerprintSteps(
+      request.sourceProtocol,
+      request.items.filter((item) => !isOpenClawRuntimeContext(item)),
+    ),
   ).at(0);
   return sha256(stableStringify({
     version: CONVERSATION_PREFIX_VERSION,
@@ -115,6 +118,17 @@ export function interactionConversationPrefix(request: InteractionRequest): stri
   }));
 }
 
+// OpenClaw appends a user message of runtime context (active exec sessions,
+// subagents) to each request and drops it from later history. On a first
+// turn it merges into the first transcript step, so leaving it in would give
+// the first turn a different conversation than the turns after it.
+const OPENCLAW_RUNTIME_CONTEXT = "<<<BEGIN_OPENCLAW_INTERNAL_CONTEXT>>>";
+
+function isOpenClawRuntimeContext(item: InteractionItem): boolean {
+  return item.type === "message" && item.role === "user" && item.content.length > 0 &&
+    item.content.every((part) => part.type === "text" && part.text.trimStart().startsWith(OPENCLAW_RUNTIME_CONTEXT));
+}
+
 export function interactionPrefixContext(
   routerId: string,
   request: InteractionRequest,

package/src/http/auth.ts

@@ -6,7 +6,7 @@ export function bearerToken(headers: Headers): string {
   const value = headers.get("authorization") ?? "";
   const [scheme, token] = value.split(/\s+/, 2);
   if (scheme?.toLowerCase() !== "bearer" || !token) {
-    throw new HttpError(401, "Missing or invalid routing API key.", "authentication_error");
+    throw new HttpError(401, "Missing or invalid API key.", "authentication_error");
   }
   return publicRoutingToken(token);
 }
@@ -16,7 +16,7 @@ export function anthropicToken(headers: Headers): string {
   if (authorization) return bearerToken(headers);
   const apiKey = headers.get("x-api-key");
   if (!apiKey) {
-    throw new HttpError(401, "Missing or invalid routing API key.", "authentication_error");
+    throw new HttpError(401, "Missing or invalid API key.", "authentication_error");
   }
   return publicRoutingToken(apiKey);
 }

package/src/http/http2_server.ts

@@ -23,7 +23,11 @@ const HTTP2_FORBIDDEN_RESPONSE_HEADERS = new Set([
   "upgrade",
 ]);
 
-export function startHttp2Server(port: number, handler: Http2RequestHandler): Http2RoutingServer {
+export function startHttp2Server(
+  port: number,
+  handler: Http2RequestHandler,
+  hostname = "0.0.0.0",
+): Http2RoutingServer {
   const sessions = new Set<ServerHttp2Session>();
   let closePromise: Promise<void> | undefined;
   const server = createServer((request, response) => {
@@ -33,10 +37,10 @@ export function startHttp2Server(port: number, handler: Http2RequestHandler): Ht
     sessions.add(session);
     session.once("close", () => sessions.delete(session));
   });
-  server.listen(port, "0.0.0.0");
+  server.listen(port, hostname);
   const address = server.address();
   if (address === null || typeof address === "string") {
-    throw new Error("HTTP/2 routing server did not bind to a TCP port.");
+    throw new Error("HTTP/2 gateway server did not bind to a TCP port.");
   }
   return {
     port: address.port,

package/src/http/serve.ts

@@ -16,10 +16,10 @@ type StoppableServer = {
 export function startServer(
   listenPort: number,
   handler: (request: Request) => Promise<Response>,
-  options: { http2?: boolean } = {},
+  options: { http2?: boolean; hostname?: string } = {},
 ) {
   if (options.http2) {
-    return startHttp2Server(listenPort, handler);
+    return startHttp2Server(listenPort, handler, options.hostname);
   }
 
   // The selector runs before the first response byte, and routed models can
@@ -27,6 +27,7 @@ export function startServer(
   // clients and infrastructure still bound total request lifetime.
   return Bun.serve({
     port: listenPort,
+    hostname: options.hostname,
     fetch: handler,
     idleTimeout: 0,
   });
@@ -45,7 +46,7 @@ export function installShutdownHandlers(
     if (shuttingDown) return;
     shuttingDown = true;
     const workDeadlineAtMs = performance.now() + SHUTDOWN_WORK_TIMEOUT_MS;
-    console.info("routing server shutting down", JSON.stringify({ signal }));
+    console.info("gateway server shutting down", JSON.stringify({ signal }));
     try {
       await stopServerForShutdown(server);
     } finally {
@@ -54,7 +55,7 @@ export function installShutdownHandlers(
       );
       if (remaining > 0) {
         console.warn(
-          "routing server background drain timed out",
+          "gateway server background drain timed out",
           JSON.stringify({ remaining_task_count: remaining }),
         );
         captureOperationalError(
@@ -112,7 +113,7 @@ function stopWithin(
 
 function reportServerStopFailure(error: unknown): void {
   console.warn(
-    "routing server shutdown failed",
+    "gateway server shutdown failed",
     error instanceof Error ? error.name : "UnknownError",
   );
   captureOperationalError(error, { code: "server_force_stop_failed" });

package/src/ingress/chat_completions.ts

@@ -9,6 +9,7 @@ import type { SelectorBackend } from "../strategies/routing.js";
 import {
   chatCompletionsConversationIdentity,
   openCodeRequestContext,
+  piRequestContext,
 } from "../runtime/harness_identity/index.js";
 import { parseJsonRequest } from "./json.js";
 import { museCodeClientId } from "./muse_code.js";
@@ -22,7 +23,7 @@ export async function handleChatCompletions(
     const apiKey = bearerToken(request.headers);
     const payload = await parseJsonRequest<ChatCompletionRequest>(request);
     const interaction = chatCompletionsToInteraction({ ...payload, source_protocol: "openai_chat" });
-    const agentContext = openCodeRequestContext(request.headers);
+    const agentContext = piRequestContext(request.headers) ?? openCodeRequestContext(request.headers);
     const museClientId = museCodeClientId(request.headers);
     return await handleRoutedCompletion({
       request,

package/src/ingress/codex.ts

@@ -1,3 +1,4 @@
+import { explicitModelId } from "../protocol/input/router_model.js";
 import { bearerToken } from "../http/auth.js";
 import { errorResponse } from "../http/errors.js";
 import { captureRequestError } from "../observability/errors.js";
@@ -12,6 +13,7 @@ import {
   codexConversationIdentity,
   codexRequestPurpose,
   codexRequestContext,
+  museCodeConversationIdentity,
 } from "../runtime/harness_identity/index.js";
 
 export async function handleResponses(
@@ -32,15 +34,16 @@ export async function handleResponses(
       ...(agentContext === undefined ? {} : { agentContext }),
       ...(museClientId === undefined ? {} : { museCodeClientId: museClientId }),
     };
-    const harnessConversationIdentity = codexConversationIdentity(
-      request.headers,
-      rawPayload,
-    );
+    const codexIdentity = codexConversationIdentity(request.headers, rawPayload);
     // Codex applies its global model_reasoning_effort setting to custom model
     // providers. That preference describes a direct model, not a heterogeneous
     // router, so let Dari select the reasoning effort for verified Codex turns.
     // Parsing above still validates malformed Responses reasoning controls.
-    if (harnessConversationIdentity !== undefined) payload.reasoning = undefined;
+    if (codexIdentity !== undefined && explicitModelId(payload.model) === null) {
+      payload.reasoning = undefined;
+    }
+    const harnessConversationIdentity = codexIdentity
+      ?? (museClientId === undefined ? undefined : museCodeConversationIdentity(request.headers));
     return await handleRoutedCompletion({
       request,
       routerId,

package/src/ingress/codex_models.ts

@@ -32,6 +32,8 @@ type CodexCatalogEntry = {
   contextWindow: number;
   hostedWebSearch: boolean;
   imageInput: boolean;
+  reasoningLevels?: string[];
+  defaultReasoningLevel?: string | null;
 };
 
 function codexCatalogEntry(args: CodexCatalogEntry): Record<string, unknown> {
@@ -39,8 +41,11 @@ function codexCatalogEntry(args: CodexCatalogEntry): Record<string, unknown> {
     slug: args.slug,
     display_name: args.displayName,
     description: args.description,
-    default_reasoning_level: null,
-    supported_reasoning_levels: [],
+    default_reasoning_level: args.defaultReasoningLevel ?? null,
+    supported_reasoning_levels: (args.reasoningLevels ?? []).map((effort) => ({
+      effort,
+      description: `${effort} thinking`,
+    })),
     shell_type: "shell_command",
     visibility: "list",
     supported_in_api: true,
@@ -80,15 +85,17 @@ function codexCatalogEntry(args: CodexCatalogEntry): Record<string, unknown> {
   };
 }
 
-/* `dari/routing` stays first (the Codex launcher patches it); each enabled
-   model follows as `dari/model/<id>` so Codex's /model menu can switch to it. */
+/* `dari/routing` comes first while the router may autoroute (the Codex
+   launcher patches it); each enabled model follows as `dari/model/<id>` so
+   Codex's /model menu can switch to it. The `dari` launchers build every
+   agent's model menu from this list. */
 export function codexModelsResponse(
-  router: Pick<ResolvedRouter, "enabled_models" | "model_configs" | "allow_long_context">,
+  router: Pick<ResolvedRouter, "enabled_models" | "model_configs" | "allow_long_context" | "autorouting_enabled">,
   imageInputFor: (model: string) => boolean
 ): Record<string, unknown> {
   return {
     models: [
-      codexCatalogEntry({
+      ...(router.autorouting_enabled === false ? [] : [codexCatalogEntry({
         slug: CANONICAL_ROUTER_MODEL,
         displayName: "Dari Routing",
         description: "Routes Codex HTTP Responses requests through the configured Dari model router.",
@@ -96,7 +103,7 @@ export function codexModelsResponse(
         contextWindow: codexRouterContextWindow(router),
         hostedWebSearch: codexRouterSupportsHostedWebSearch(router),
         imageInput: router.enabled_models.some(imageInputFor),
-      }),
+      })]),
       ...router.enabled_models.map((model, index) =>
         codexCatalogEntry({
           slug: explicitModelSlug(model),
@@ -106,6 +113,10 @@ export function codexModelsResponse(
           contextWindow: codexRouterContextWindow({ ...router, enabled_models: [model] }),
           hostedWebSearch: codexRouterSupportsHostedWebSearch({ ...router, enabled_models: [model] }),
           imageInput: imageInputFor(model),
+          reasoningLevels: router.model_configs?.[model]?.supported_thinking_levels
+            ?.map((effort) => effort === "off" ? "none" : effort),
+          defaultReasoningLevel: router.model_configs?.[model]?.default_thinking_level === "off"
+            ? "none" : router.model_configs?.[model]?.default_thinking_level,
         })
       ),
     ],

package/src/platform/platform.ts

@@ -45,6 +45,10 @@ export type GatewayPlatform = {
   writePrefixState(write: PrefixStateWrite): Promise<void>;
   /** Set or clear a conversation's prefetched routing lease. */
   writePendingLease(write: PendingLeaseWrite): Promise<void>;
+  /** The pair a session pinned on a session-pinning router, or null. */
+  readSessionPin(request: SessionPinKey): Promise<SessionPin | null>;
+  /** Pin a session to a pair, replacing any earlier pin. */
+  writeSessionPin(write: SessionPinKey & SessionPin): Promise<void>;
   /**
    * Hold an exhausted personal subscription until it resets. Resolves whether
    * another connected subscription for the same provider can serve a retry.
@@ -104,6 +108,17 @@ export type PendingLeaseWrite = {
   } | null;
 };
 
+// A main agent and each of its subagents have their own pin key.
+export type SessionPinKey = {
+  routerId: string;
+  pinKey: string;
+};
+
+export type SessionPin = {
+  model: string;
+  reasoningEffort: ReasoningEffort;
+};
+
 export type SubscriptionHold = {
   userId: string;
   credentialId: string | undefined;
@@ -146,8 +161,6 @@ export type RequestSummary = {
   selected_reasoning_effort: ReasoningEffort | null;
   next_model: string | null;
   next_reasoning_effort: ReasoningEffort | null;
-  fallback_model: string | null;
-  fallback_reasoning_effort: ReasoningEffort | null;
   provider_key_source: ProviderKeySource | null;
   message_count: number;
   tool_count: number;
@@ -184,6 +197,7 @@ export type OperationalErrorCode =
   | "routing_report_assembly_failed"
   | "routing_report_barrier_failed"
   | "server_force_stop_failed"
+  | "session_pin_write_failed"
   | "stream_report_finalization_failed"
   | "subscription_unavailable_ingest_failed";
 

package/src/protocol/input/openai_responses.ts

@@ -572,15 +572,8 @@ function reasoningControls(value: unknown): InteractionRequest["reasoning"] {
   if (value === undefined || value === null) return undefined;
   if (!isRecord(value)) throw new HttpError(400, "reasoning must be an object.", "invalid_request_error", "reasoning");
   const normalizedEffort = normalizedReasoningEffort(value.effort, "reasoning.effort");
-  const summary = value.summary;
-  if (summary !== undefined) {
-    throw new HttpError(
-      400,
-      "reasoning.summary is not supported by this router MVP.",
-      "invalid_request_error",
-      "reasoning.summary"
-    );
-  }
+  // Summaries are display-only: clients such as Muse Code ask for them by
+  // default, and the router serves the turn without them.
   return normalizedEffort === undefined ? undefined : { effort: normalizedEffort };
 }
 

package/src/protocol/output/anthropic_messages_output.ts

@@ -2,7 +2,7 @@ import { parseDataImageUrl } from "../../interaction/image.js";
 import { encodeProviderContinuationState } from "../../interaction/provider_continuation_state.js";
 import { encodePortableReasoningState } from "../../interaction/portable_reasoning_state.js";
 import type { InteractionOutput } from "../../interaction/types.js";
-import type { RoutingDecision } from "@mupt-ai/dari-router/policy-engine";
+import type { ServedDecision } from "../../types.js";
 
 export function anthropicMessageId(requestId: string): string {
   return `msg_${requestId.replace(/[^A-Za-z0-9_-]/g, "_")}`.slice(0, 64);
@@ -99,7 +99,7 @@ export function anthropicUsage(output: Pick<InteractionOutput, "usage">): Record
 }
 
 export function anthropicRouting(
-  decision: RoutingDecision,
+  decision: ServedDecision,
   requestId: string,
   conversationId?: string
 ): Record<string, unknown> {
@@ -113,6 +113,7 @@ export function anthropicRouting(
     ...(decision.leaseTurnsRemaining === undefined
       ? {}
       : { lease_turns_remaining: decision.leaseTurnsRemaining }),
+    ...(decision.sessionPinned === true ? { session_pinned: true } : {}),
   };
 }
 

package/src/protocol/output/openai_responses_stream.ts

@@ -6,7 +6,7 @@ import {
   openAIResponsesTerminal,
   openAIResponsesUsage,
 } from "./openai_responses_output.js";
-import { piMessageToInteractionOutput } from "../../providers/pi_output.js";
+import { piMessageToInteractionOutput, textSignature } from "../../providers/pi_output.js";
 import type {
   InteractionOutput,
   InteractionOutputItem,
@@ -119,6 +119,7 @@ class ResponsesAccumulator {
   private readonly addedIndexes = new Set<number>();
   private readonly completedIndexes = new Set<number>();
   private readonly messageIds = new Map<number, string>();
+  private readonly messagePhases = new Map<number, "commentary" | "final_answer">();
   private readonly reasoningIds = new Map<number, string>();
   private readonly messagePartStarted = new Set<number>();
   private readonly reasoningPartStarted = new Set<number>();
@@ -144,6 +145,7 @@ class ResponsesAccumulator {
       const index = this.indexFor(event);
       this.activate(index, send);
       if (type === "thinking_start") this.ensureReasoning(index, send);
+      if (type === "text_start") this.rememberMessageSignature(event, index);
       return;
     }
     if (type === "text_delta" && typeof event.delta === "string" && event.delta) {
@@ -330,17 +332,29 @@ class ResponsesAccumulator {
     return openAIResponsesUsage(this.finalOutput ?? this.baseOutput());
   }
 
+  // Pi signs a Responses text block with its message id and phase at
+  // text_start, so the item is announced with the phase it ends with.
+  private rememberMessageSignature(event: Record<string, unknown>, index: number): void {
+    const content = isRecord(event.partial) ? event.partial.content : undefined;
+    const block = Array.isArray(content) ? content[event.contentIndex as number] : undefined;
+    const signature = isRecord(block) ? textSignature(block.textSignature) : null;
+    if (signature?.id && !this.messageIds.has(index)) this.messageIds.set(index, signature.id);
+    if (signature?.phase) this.messagePhases.set(index, signature.phase);
+  }
+
   private ensureMessage(index: number, send: Send): Extract<InteractionOutputItem, { type: "message" }> {
     const existing = this.items.get(index);
     if (existing?.type === "message") return existing;
     const id = this.messageIds.get(index) ?? streamedItemId("msg", this.responseId, index);
     this.messageIds.set(index, id);
+    const phase = this.messagePhases.get(index);
     const message: Extract<InteractionOutputItem, { type: "message" }> = {
       type: "message",
       id,
       role: "assistant",
       content: [{ type: "text", text: "" }],
       contentShape: "parts",
+      ...(phase ? { phase } : {}),
       source: this.args.source,
     };
     this.items.set(index, message);
@@ -353,6 +367,7 @@ class ResponsesAccumulator {
         id,
         status: "in_progress",
         content: [],
+        ...(phase ? { phase } : {}),
       },
     });
     this.sendMessagePartAdded(index, id, send);
@@ -420,6 +435,7 @@ class ResponsesAccumulator {
             id: serialized.id,
             status: "in_progress",
             content: [],
+            ...(item.phase ? { phase: item.phase } : {}),
           },
         });
       } else {