@centerforagenticai/pi-multi-account 0.1.1 → 0.1.4

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "Global Anthropic and OpenAI Codex multi-account OAuth routing for Pi.",
   "type": "module",
   "bin": {

package/src/anthropic-adaptive-stream.ts

@@ -24,8 +24,9 @@
  * Provenance: pi-anthropic-oauth@0.2.4-intel.2, private pin
  * 99ac00f290efbcb93e7f23e6b7482d8727367aa7, upstream baseline
  * 53266ecb51b6d1890ef3f7251a64cb1d71d96099, source src/stream.ts.
- * Local delta: adaptive thinking emits type=adaptive and mapped output effort,
- * without budget_tokens; all other request and response behavior is unchanged.
+ * Local delta: adaptive thinking emits type=adaptive and mapped output effort
+ * without budget_tokens; request-local retry/timeout options reach the SDK; and
+ * refusal or unknown stop reasons retain bounded, structured error details.
  */
 
 import { Anthropic } from "@anthropic-ai/sdk";
@@ -41,6 +42,8 @@ import {
   type SimpleStreamOptions,
   type StopReason,
 } from "@earendil-works/pi-ai";
+import { sanitizeDiagnosticText } from "./diagnostics.js";
+import type { ProviderErrorCode } from "./error-classification.js";
 type IndexedBlock =
   | ({ type: "text"; text: string } & { index: number })
   | ({ type: "thinking"; thinking: string; thinkingSignature?: string } & {
@@ -95,18 +98,51 @@ const REQUIRED_BETAS = [
   "interleaved-thinking-2025-05-14",
 ] as const;
 
-function mapStopReason(reason: string | null | undefined): StopReason {
+type StopReasonResult = Readonly<{
+  stopReason: StopReason;
+  errorMessage?: string;
+  code?: Extract<ProviderErrorCode, "refusal" | "unknown_stop">;
+}>;
+
+function mapStopReason(
+  reason: string | null | undefined,
+  stopDetails?: unknown,
+): StopReasonResult {
   switch (reason) {
     case "end_turn":
     case "pause_turn":
     case "stop_sequence":
-      return "stop";
+      return { stopReason: "stop" };
     case "max_tokens":
-      return "length";
+      return { stopReason: "length" };
     case "tool_use":
-      return "toolUse";
-    default:
-      return "error";
+      return { stopReason: "toolUse" };
+    case "refusal": {
+      const explanation =
+        typeof stopDetails === "object" &&
+        stopDetails !== null &&
+        typeof (stopDetails as { explanation?: unknown }).explanation === "string"
+          ? sanitizeDiagnosticText(
+              (stopDetails as { explanation: string }).explanation,
+            )
+          : "";
+      return {
+        stopReason: "error",
+        errorMessage:
+          explanation || "The model refused to complete the request",
+        code: "refusal",
+      };
+    }
+    default: {
+      const boundedReason = sanitizeDiagnosticText(reason ?? "unknown");
+      return {
+        stopReason: "error",
+        errorMessage: sanitizeDiagnosticText(
+          `Provider stopped with: ${boundedReason}`,
+        ),
+        code: "unknown_stop",
+      };
+    }
   }
 }
 
@@ -163,7 +199,7 @@ export function streamAnthropicAdaptive(
   const stream = createAssistantMessageEventStream();
 
   void (async () => {
-    const output: AssistantMessage = {
+    const output: AssistantMessage & { code?: ProviderErrorCode } = {
       role: "assistant",
       content: [],
       api: model.api,
@@ -276,10 +312,24 @@ export function streamAnthropicAdaptive(
       // which throws under fine-grained-tool-streaming (input may be invalid
       // mid-flight) and aborts the turn. The raw stream yields the same
       // RawMessageStreamEvents; tool args are already parsed leniently below.
+      const maxRetries = options?.maxRetries;
+      const timeoutMs = options?.timeoutMs;
       const { data: anthropicStream, response: httpResponse } =
         await client.messages
           .create(params, {
             signal: options?.signal,
+            ...(Number.isFinite(maxRetries) &&
+            Number.isInteger(maxRetries) &&
+            (maxRetries ?? -1) >= 0
+              ? { maxRetries }
+              : {}),
+            // Any finite positive timeout is honored; the SDK timer takes whole
+            // milliseconds, so a fractional value is floored to at least 1.
+            ...(typeof timeoutMs === "number" &&
+            Number.isFinite(timeoutMs) &&
+            timeoutMs > 0
+              ? { timeout: Math.max(1, Math.floor(timeoutMs)) }
+              : {}),
           })
           .withResponse();
 
@@ -474,7 +524,19 @@ export function streamAnthropicAdaptive(
         }
 
         if (event.type === "message_delta") {
-          output.stopReason = mapStopReason(event.delta.stop_reason);
+          const rawStopReason = event.delta.stop_reason;
+          const mapped = mapStopReason(
+            rawStopReason,
+            (event.delta as { stop_details?: unknown }).stop_details,
+          );
+          output.stopReason = mapped.stopReason;
+          if (typeof rawStopReason === "string") {
+            output.rawStopReason = sanitizeDiagnosticText(rawStopReason);
+          }
+          if (mapped.errorMessage !== undefined) {
+            output.errorMessage = mapped.errorMessage;
+          }
+          if (mapped.code !== undefined) output.code = mapped.code;
           output.usage.input =
             (event.usage as { input_tokens?: number }).input_tokens ||
             output.usage.input;
@@ -505,11 +567,15 @@ export function streamAnthropicAdaptive(
       }
 
       if (options?.signal?.aborted) throw new Error("Request aborted");
-      stream.push({
-        type: "done",
-        reason: output.stopReason as "stop" | "length" | "toolUse",
-        message: output,
-      });
+      if (output.stopReason === "error") {
+        stream.push({ type: "error", reason: "error", error: output });
+      } else {
+        stream.push({
+          type: "done",
+          reason: output.stopReason as "stop" | "length" | "toolUse",
+          message: output,
+        });
+      }
       stream.end();
     } catch (error) {
       for (const block of output.content as Array<{

package/src/anthropic-alias-stream.ts

@@ -13,6 +13,7 @@ import {
   sanitizeDiagnosticText,
   sanitizeHeaderValue,
 } from "./diagnostics.js";
+import { hostFinalStopMessage } from "./host-final-stop-message.js";
 
 export const ANTHROPIC_ALIAS_API = "hypha-anthropic-oauth" as const;
 
@@ -53,12 +54,19 @@ function withAliasAttribution(
   };
 }
 
+/**
+ * Bounds an upstream error and, for a structured refusal or unknown stop,
+ * publishes the shared host-final message. A direct alias turn reaches the
+ * host's retry and compaction predicates without the unified provider, so
+ * provider-authored stop wording must not make the host resend the request.
+ */
 function sanitizeUpstreamError(message: AssistantMessage): AssistantMessage {
   if (message.errorMessage === undefined) return message;
-  return {
+  const sanitized: AssistantMessage = {
     ...message,
     errorMessage: sanitizeDiagnosticText(message.errorMessage),
   };
+  return { ...sanitized, ...hostFinalStopMessage(sanitized) };
 }
 
 function withAliasEvent(

package/src/codex-adapter.ts

@@ -235,9 +235,33 @@ function normalizeAliasContext(
 }
 
 /**
- * Wraps the exact maintained stream without replacing transport or OAuth. Pi's
+ * Temporary containment for the Pi 0.99 Codex WebSocket failure: a WebSocket
+ * error leaves the session in a state where the next Codex turn crashes with
+ * "Cannot read properties of undefined (reading 'length')". Routes this
+ * extension owns always request SSE. The base `openai-codex` provider is never
+ * touched; only options on calls we already route are adjusted. Remove once the
+ * WebSocket path is fixed upstream.
+ */
+export const CODEX_FORCED_TRANSPORT = "sse" as const;
+
+/** Returns options with Codex transport pinned to SSE, and whether a value was overridden. */
+export function forceCodexSseOptions<T extends SimpleStreamOptions>(
+  options: T | undefined,
+): { options: T; overridden: boolean } {
+  if (options?.transport === CODEX_FORCED_TRANSPORT) {
+    return { options, overridden: false };
+  }
+  return {
+    options: { ...(options ?? {}), transport: CODEX_FORCED_TRANSPORT } as T,
+    overridden: true,
+  };
+}
+
+/**
+ * Wraps the exact maintained stream without replacing OAuth. Pi's
  * alias-resolved apiKey and every other option field are forwarded unchanged;
- * only model/context identity and callback attribution are adapted.
+ * model/context identity and callback attribution are adapted, and transport
+ * is pinned to SSE (see {@link CODEX_FORCED_TRANSPORT}).
  */
 export function createCodexAliasStream(
   maintainedStream: NonNullable<ProviderConfig["streamSimple"]>,
@@ -251,12 +275,12 @@ export function createCodexAliasStream(
     };
     const upstreamContext = normalizeAliasContext(context, aliasModel);
 
-    let upstreamOptions = options;
+    let upstreamOptions = forceCodexSseOptions(options).options;
     if (options?.onPayload || options?.onResponse) {
       const aliasOnPayload = options.onPayload;
       const aliasOnResponse = options.onResponse;
       upstreamOptions = {
-        ...options,
+        ...upstreamOptions,
         ...(aliasOnPayload
           ? {
               onPayload: (payload: unknown) =>

package/src/error-classification.ts

@@ -13,6 +13,8 @@ export const PROVIDER_ERROR_CODES = [
 	"model_not_found",
 	"unsupported_api_version",
 	"invalid_request",
+	"refusal",
+	"unknown_stop",
 ] as const;
 export type ProviderErrorCode = (typeof PROVIDER_ERROR_CODES)[number];
 
@@ -50,10 +52,12 @@ export type FailureCategory =
 
 export interface FailureClassification {
 	readonly category: FailureCategory;
+	readonly kind?: "refusal" | "unknown-stop";
 	readonly accountAction:
 		| "cooldown-and-route"
 		| "invalidate-and-route"
-		| "route-without-retry";
+		| "route-without-retry"
+		| "retain-account";
 	readonly cooldownReason?: CooldownReason;
 	readonly serverHint?: NumericServerHint;
 }
@@ -248,6 +252,14 @@ export function classifyFailure(
 		return { category: "config", accountAction: "route-without-retry" };
 	}
 
+	if (signal.code === "refusal" || signal.code === "unknown_stop") {
+		return {
+			category: "unknown",
+			kind: signal.code === "refusal" ? "refusal" : "unknown-stop",
+			accountAction: "retain-account",
+		};
+	}
+
 	if (isTransportFailure(signal)) {
 		return cooldown("transport", "transport", signal);
 	}

package/src/host-final-stop-message.ts

@@ -0,0 +1,124 @@
+import {
+	isContextOverflow,
+	isRetryableAssistantError,
+	type AssistantMessage,
+} from "@earendil-works/pi-ai";
+import { sanitizeDiagnosticText } from "./diagnostics.js";
+
+/** Fixed fallbacks for a structured provider stop; none matches a host re-dispatch pattern. */
+export const REFUSAL_FALLBACK_MESSAGE = "The model refused to complete the request";
+export const UNKNOWN_STOP_FALLBACK_MESSAGE =
+	"Provider stopped with an unrecognized stop reason";
+
+/** Upper bound on the normalized stop reason named in a reworded message. */
+const MAX_NAMED_REASON_LENGTH = 64;
+
+/**
+ * Whether the pinned host would re-dispatch an error terminal carrying `text`.
+ *
+ * The host re-dispatches when either retry predicate matches the prose:
+ * `AgentSession._isRetryableError` runs pi-ai `isRetryableAssistantError`, and
+ * `_checkCompaction` runs `isContextOverflow` before compacting and retrying once
+ * (pi-coding-agent dist/core/agent-session.js, both from `@earendil-works/pi-ai`).
+ * An unreadable predicate result counts as a match, so the caller keeps looking
+ * for a safer form.
+ */
+function hostWouldRedispatch(message: AssistantMessage, text: string): boolean {
+	try {
+		const probe = { ...message, errorMessage: text };
+		return isRetryableAssistantError(probe) || isContextOverflow(probe, 0);
+	} catch {
+		return true;
+	}
+}
+
+function namedReasonMessage(reason: string): string {
+	return `Provider stopped (reason: ${reason})`;
+}
+
+/**
+ * Normalizes a bounded, sanitized raw stop reason into plain words: every run of
+ * non-alphanumeric characters (underscores included) becomes one space, and the
+ * result is capped at a word boundary where possible.
+ */
+function normalizedReasonWords(rawStopReason: unknown): string[] {
+	if (typeof rawStopReason !== "string") return [];
+	const words = sanitizeDiagnosticText(rawStopReason)
+		.replace(/[^A-Za-z0-9]+/g, " ")
+		.trim()
+		.split(" ")
+		.filter((word) => word.length > 0);
+	const kept: string[] = [];
+	let length = 0;
+	for (const word of words) {
+		const next = length === 0 ? word.length : length + 1 + word.length;
+		if (next > MAX_NAMED_REASON_LENGTH) {
+			if (kept.length === 0) kept.push(word.slice(0, MAX_NAMED_REASON_LENGTH));
+			break;
+		}
+		kept.push(word);
+		length = next;
+	}
+	return kept;
+}
+
+/**
+ * Names an unknown stop reason in a message neither host predicate acts on.
+ *
+ * The first form keeps every normalized word. When that still matches a host
+ * predicate (a reason containing "overloaded" or "timeout", say), the second
+ * form admits words in order and drops each one whose addition would make the
+ * message match. Every admitted prefix was probed, so the result is host-final
+ * by construction. An empty result yields `undefined`.
+ */
+function unknownStopNamingReason(
+	message: AssistantMessage,
+	rawStopReason: unknown,
+): string | undefined {
+	const words = normalizedReasonWords(rawStopReason);
+	if (words.length === 0) return undefined;
+	const reworded = namedReasonMessage(words.join(" "));
+	if (!hostWouldRedispatch(message, reworded)) return reworded;
+	const kept: string[] = [];
+	for (const word of words) {
+		const tentative = namedReasonMessage([...kept, word].join(" "));
+		if (!hostWouldRedispatch(message, tentative)) kept.push(word);
+	}
+	return kept.length === 0 ? undefined : namedReasonMessage(kept.join(" "));
+}
+
+/**
+ * The public error text for a structured refusal or unknown provider stop.
+ *
+ * The pinned host re-dispatches an error terminal from its prose alone (see
+ * `hostWouldRedispatch`). A refusal explanation or stop reason is
+ * provider-authored, so text such as "overloaded", "prompt is too long", or
+ * "model_context_window_exceeded" would make the host send the stopped request
+ * again. The structured code alone selects this path; the provider text is kept
+ * only when neither host predicate would act on it. An unknown stop is then
+ * reworded so it still names its reason, and only when no reworded form is safe
+ * is a fixed fallback published. A refusal whose explanation is unsafe publishes
+ * its fixed fallback directly. A message without the structured code, or that is
+ * not an error terminal, yields `undefined` and must be published unchanged.
+ */
+export function hostFinalStopMessage(
+	message: AssistantMessage,
+): { readonly errorMessage: string } | undefined {
+	const code = (message as { code?: unknown }).code;
+	if (message.stopReason !== "error") return undefined;
+	if (code !== "refusal" && code !== "unknown_stop") return undefined;
+	const candidate = message.errorMessage;
+	if (
+		typeof candidate === "string" &&
+		candidate.length > 0 &&
+		!hostWouldRedispatch(message, candidate)
+	) {
+		return { errorMessage: candidate };
+	}
+	if (code === "refusal") return { errorMessage: REFUSAL_FALLBACK_MESSAGE };
+	return {
+		errorMessage:
+			unknownStopNamingReason(message, message.rawStopReason) ??
+			UNKNOWN_STOP_FALLBACK_MESSAGE,
+	};
+}

package/src/index.ts

@@ -1,8 +1,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import type { Api, AssistantMessage, Model } from "@earendil-works/pi-ai";
 import { readStoredCredential } from "@earendil-works/pi-coding-agent";
 import type {
@@ -29,6 +28,10 @@ import {
 	createOpenAiAliasProviderConfig,
 	openaiPlatformModels,
 } from "./openai-adapter.js";
+import {
+	loadMaintainedCodexStream,
+	resolveInstalledPiAiVersion,
+} from "./pi-ai-entrypoints.js";
 import {
 	ALLOWED_FAMILIES,
 	DEFAULT_CONFIG,
@@ -405,6 +408,16 @@ function readInstalledDeclaration(targetPath: string): unknown {
 	}
 }
 
+/** The session's id, or undefined when the host context cannot supply one. */
+function readSessionId(ctx: ExtensionContext): string | undefined {
+	try {
+		const id = (ctx.sessionManager as { getSessionId?: () => unknown }).getSessionId?.();
+		return typeof id === "string" && id.length > 0 ? id : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
 /** The complete declaration-gated startup seam, exported for causal registration contracts. */
 export function registerLogicalProviderAtMatchedStartup(input: {
 	pi: Parameters<typeof registerLogicalProviderForSession>[0];
@@ -413,6 +426,8 @@ export function registerLogicalProviderAtMatchedStartup(input: {
 	deps: LogicalProviderDeps;
 	attributionStoreFactory?: () => LogicalAttributionLifecycle;
 	registerLogicalApi?: LogicalApiRegistrar;
+	/** The registering session's id; routes `unified` calls back to their caller. */
+	sessionId?: string | undefined;
 }): {
 	status: ReturnType<typeof inspectInstalledDeclaration>;
 	expectedModels: ReturnType<typeof buildModelDeclaration>["models"];
@@ -424,6 +439,7 @@ export function registerLogicalProviderAtMatchedStartup(input: {
 		deps,
 		attributionStoreFactory,
 		registerLogicalApi,
+		sessionId,
 	} = input;
 	const expected = buildModelDeclaration(liveCatalogs);
 	const status = inspectInstalledDeclaration(installed, expected.models);
@@ -442,6 +458,7 @@ export function registerLogicalProviderAtMatchedStartup(input: {
 			expected.models,
 			attributedDeps,
 			registerLogicalApi,
+			sessionId === undefined ? {} : { sessionId },
 		);
 	}
 	return { status, expectedModels: expected.models };
@@ -1242,24 +1259,6 @@ function continuationReason(
 	}
 }
 
-async function loadMaintainedCodexStream(): Promise<
-	NonNullable<ProviderConfig["streamSimple"]>
-> {
-	const publicRoot = await import("@earendil-works/pi-ai");
-	const compatibilityStream = (
-		publicRoot as unknown as Record<string, unknown>
-	)["streamSimpleOpenAICodexResponses"];
-	if (typeof compatibilityStream === "function") {
-		return compatibilityStream as NonNullable<ProviderConfig["streamSimple"]>;
-	}
-	const maintainedApi = await import(
-		"@earendil-works/pi-ai/api/openai-codex-responses"
-	);
-	return maintainedApi.streamSimple as unknown as NonNullable<
-		ProviderConfig["streamSimple"]
-	>;
-}
-
 /**
  * Fail-closed sentinel used only when the host codex OAuth surface is
  * unavailable at session_start (host shape drift). Its OAuth callbacks throw a
@@ -2065,50 +2064,6 @@ function cacheInheritedAccountGroupResolution(
 }
 
 
-/**
- * Resolves the actually-installed `@earendil-works/pi-ai` package version by
- * walking up from its resolved `providers/anthropic.models` module file to
- * the nearest `package.json` whose `name` matches. A local, bounded,
- * offline disk read -- never a network request -- so the report's recorded
- * pricing-method provenance names whichever pinned catalog this process
- * actually loaded instead of a hard-coded string that could drift from it.
- * Shares its shape with the standalone CLI's own offline resolver in
- * `standalone-cli.ts`; the two adapters read from different sources (a live
- * `ExtensionContext.modelRegistry` here, the pinned package directly there)
- * and so cannot share one function without coupling this extension entry
- * point to the separate standalone-CLI module.
- */
-function resolveInstalledPiAiVersion(): string {
-	try {
-		const moduleUrl = import.meta.resolve(
-			"@earendil-works/pi-ai/providers/anthropic.models",
-		);
-		let directory = dirname(fileURLToPath(moduleUrl));
-		for (let depth = 0; depth < 6; depth += 1) {
-			try {
-				const candidate = JSON.parse(
-					readFileSync(join(directory, "package.json"), "utf-8"),
-				) as { readonly name?: unknown; readonly version?: unknown };
-				if (
-					candidate.name === "@earendil-works/pi-ai" &&
-					typeof candidate.version === "string" &&
-					candidate.version.length > 0
-				) {
-					return `pi-ai@${candidate.version}`;
-				}
-			} catch {
-				// Keep walking toward the installed package root.
-			}
-			const parent = dirname(directory);
-			if (parent === directory) break;
-			directory = parent;
-		}
-	} catch {
-		// Resolution failure falls through to the bounded fallback below.
-	}
-	return "pi-ai@unknown";
-}
-
 /**
  * Builds the extension surfaces' live Pi-catalog snapshot from the session's
  * real `ExtensionContext.modelRegistry.getAll()` -- the same public,
@@ -3935,6 +3890,18 @@ export const createMultiAccountExtension =
 				modelSupport,
 				alreadyCooled: classified.alreadyCooled === true,
 			});
+			if (decision.status === "retained") {
+				// A structured refusal or unknown stop keeps the account: no switch,
+				// no park, no OpenRouter, and no continuation. The same context would
+				// stop the same way on any account.
+				diagnostics.record(
+					"info",
+					"routing.retained",
+					"The provider stopped the turn with a refusal or unknown stop reason; the account was kept and no follow-up was scheduled.",
+					{ providerId, kind: decision.classification.kind ?? "unknown" },
+				);
+				return;
+			}
 			if (decision.status === "paused") {
 				// OpenRouter is an explicitly enabled, metered FINAL rung. The helper
 				// re-checks every managed family so family-chain policy cannot bypass
@@ -4531,6 +4498,8 @@ export const createMultiAccountExtension =
 						installed,
 						liveCatalogs,
 						registerLogicalApi,
+						// Optional routing key; an unreadable id must never block registration.
+						sessionId: readSessionId(startupContext),
 						attributionStoreFactory: () => {
 							const store = createAttributionStore({
 								onResponse: (route, response) => {
@@ -4916,7 +4885,7 @@ export const createMultiAccountExtension =
 								config,
 								nowMs,
 							});
-							if (reactive.status === "paused") return;
+							if (reactive.status !== "selected") return;
 							reactiveCandidate = reactive;
 							destinationProviderId = reactive.destination.providerId;
 						}
@@ -5342,9 +5311,17 @@ export const createMultiAccountExtension =
 			turnRouteOrigin = origin;
 			handledFailures.add(event.message);
 			const responseFailure = lastFailure.get(providerId) ?? {};
-			const messageCode = providerErrorCodeFromMessage(
-				event.message.errorMessage,
-			);
+			// A structured provider stop is copied only from this two-value allowlist,
+			// never spread, and it wins over any code parsed from provider-authored
+			// errorMessage prose: refusal text must not read as a rate limit.
+			const rawStopCode = (event.message as { code?: unknown }).code;
+			const stopCode =
+				rawStopCode === "refusal" || rawStopCode === "unknown_stop"
+					? rawStopCode
+					: undefined;
+			const messageCode =
+				stopCode ??
+				providerErrorCodeFromMessage(event.message.errorMessage);
 			const failure: ProviderFailureSignal = {
 				...responseFailure,
 				...(messageCode === undefined ? {} : { code: messageCode }),

package/src/logical-provider.ts

@@ -22,6 +22,7 @@ import {
 	type SimpleStreamOptions,
 } from "@earendil-works/pi-ai";
 import { RuntimeState, type LogicalRoutePin } from "./runtime-state.js";
+import { hostFinalStopMessage } from "./host-final-stop-message.js";
 import { DEFAULT_CONFIG } from "./config.js";
 import type {
 	AllowedFamily,
@@ -47,6 +48,16 @@ import type { ProviderType, Vendor } from "./vendor.js";
 
 export { LOGICAL_PROVIDER_ID } from "./models-declaration.js";
 import { LOGICAL_PROVIDER_ID } from "./models-declaration.js";
+import { forceCodexSseOptions } from "./codex-adapter.js";
+
+/** Fixed diagnostic label for a caller-supplied transport; never echoes the raw value. */
+function codexTransportLabel(
+	transport: unknown,
+): "websocket" | "websocket-cached" | "auto" | "other" {
+	return transport === "websocket" || transport === "websocket-cached" || transport === "auto"
+		? transport
+		: "other";
+}
 
 /** One physical account the logical provider may dispatch to. */
 export interface LogicalPhysicalAccount {
@@ -666,6 +677,7 @@ export function createLogicalProvider(
 	deps: LogicalProviderDeps,
 ): LogicalProvider {
 	const coordinator = createHostRetryCoordinator(deps);
+	let codexTransportNoticeSent = false;
 
 	const diagnose = (message: string): void => {
 		deps.onDiagnostic?.(message);
@@ -936,6 +948,7 @@ export function createLogicalProvider(
 
 	const projectMessage = (message: AssistantMessage, modelId: string): AssistantMessage => ({
 		...message, api: LOGICAL_PROVIDER_ID, provider: LOGICAL_PROVIDER_ID, model: modelId,
+		...hostFinalStopMessage(message),
 	});
 
 	const projectEvent = (event: unknown, modelId: string): unknown => {
@@ -1127,8 +1140,24 @@ export function createLogicalProvider(
 					await originalOnResponse(response, responseModel);
 				}
 			};
+			let routedOptions = options;
+			if (account.family === "openai-codex") {
+				// Temporary Pi 0.99 WebSocket containment; see CODEX_FORCED_TRANSPORT.
+				const forced = forceCodexSseOptions(options);
+				routedOptions = forced.options;
+				if (forced.overridden && options?.transport !== undefined && !codexTransportNoticeSent) {
+					codexTransportNoticeSent = true;
+					try {
+						deps.onDiagnostic?.(
+							`Codex transport "${codexTransportLabel(options.transport)}" overridden to "sse" on routed calls (Pi 0.99 WebSocket containment).`,
+						);
+					} catch {
+						// A diagnostic sink failure cannot replace a provider result.
+					}
+				}
+			}
 			const attributedOptions: SimpleStreamOptions = {
-				...options,
+				...routedOptions,
 				onPayload: wrappedOnPayload,
 				onResponse: wrappedOnResponse,
 			};