@psnext/slingcli 2.5.20260623-1 → 2.5.20260705-1

package/node_modules/@earendil-works/pi-ai/dist/api/azure-openai-responses.js

@@ -1,5 +1,6 @@
 import { AzureOpenAI } from "openai";
 import { clampThinkingLevel } from "../models.js";
+import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
@@ -31,20 +32,7 @@ function resolveDeploymentName(model, options) {
     return mappedDeployment || model.id;
 }
 function formatAzureOpenAIError(error) {
-    if (error instanceof Error) {
-        const status = error.status;
-        const statusCode = typeof status === "number" ? status : undefined;
-        if (statusCode !== undefined) {
-            return `Azure OpenAI API error (${statusCode}): ${error.message}`;
-        }
-        return error.message;
-    }
-    try {
-        return JSON.stringify(error);
-    }
-    catch {
-        return String(error);
-    }
+    return formatProviderError(normalizeProviderError(error), "Azure OpenAI API error");
 }
 /**
  * Generate function for Azure OpenAI Responses API
@@ -120,7 +108,7 @@ export const streamSimple = (model, context, options) => {
     if (!apiKey) {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
-    const base = buildBaseOptions(model, options, apiKey);
+    const base = buildBaseOptions(model, context, options, apiKey);
     const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
     const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
     return stream(model, context, {
@@ -137,11 +125,17 @@ function normalizeAzureBaseUrl(baseUrl) {
     catch {
         throw new Error(`Invalid Azure OpenAI base URL: ${baseUrl}`);
     }
-    const isAzureHost = url.hostname.endsWith(".openai.azure.com") || url.hostname.endsWith(".cognitiveservices.azure.com");
+    const isAzureHost = url.hostname.endsWith(".openai.azure.com") ||
+        url.hostname.endsWith(".cognitiveservices.azure.com") ||
+        url.hostname.endsWith(".ai.azure.com");
     const normalizedPath = url.pathname.replace(/\/+$/, "");
     // Ensure Azure hosts have /openai/v1 as base path so the AzureOpenAI SDK
     // can append /deployments/<model>/... and ?api-version=v1 correctly.
-    if (isAzureHost && (normalizedPath === "" || normalizedPath === "/" || normalizedPath === "/openai")) {
+    if (isAzureHost &&
+        (normalizedPath === "" ||
+            normalizedPath === "/" ||
+            normalizedPath === "/openai" ||
+            normalizedPath === "/openai/v1/responses")) {
         url.pathname = "/openai/v1";
         url.search = "";
     }

package/node_modules/@earendil-works/pi-ai/dist/api/bedrock-converse-stream.js

@@ -3,12 +3,14 @@ import { NodeHttpHandler } from "@smithy/node-http-handler";
 import { HttpProxyAgent } from "http-proxy-agent";
 import { HttpsProxyAgent } from "https-proxy-agent";
 import { calculateCost } from "../models.js";
+import { normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
+import { providerHeadersToRecord } from "../utils/headers.js";
 import { parseStreamingJson } from "../utils/json-parse.js";
 import { resolveHttpProxyUrlForTarget } from "../utils/node-http-proxy.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
-import { adjustMaxTokensForThinking, buildBaseOptions, clampReasoning } from "./simple-options.js";
+import { adjustMaxTokensForThinking, buildBaseOptions, clampMaxTokensToContext, clampReasoning, } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
 const EMPTY_TEXT_PLACEHOLDER = "<empty>";
 export const stream = (model, context, options = {}) => {
@@ -105,8 +107,9 @@ export const stream = (model, context, options = {}) => {
         }
         try {
             const client = new BedrockRuntimeClient(config);
-            if (options.headers && Object.keys(options.headers).length > 0) {
-                addCustomHeadersMiddleware(client, options.headers);
+            const customHeaders = providerHeadersToRecord(options.headers);
+            if (customHeaders) {
+                addCustomHeadersMiddleware(client, customHeaders);
             }
             const cacheRetention = resolveCacheRetention(options.cacheRetention, options.env);
             const inferenceMaxTokens = options.maxTokens ?? (isAnthropicClaudeModel(model) ? model.maxTokens : undefined);
@@ -223,15 +226,21 @@ const BEDROCK_DATA_RETENTION_DOCS_URL = "https://docs.aws.amazon.com/bedrock/lat
  * detection) can distinguish error categories via simple string matching.
  */
 function formatBedrockError(error) {
-    const message = error instanceof Error ? error.message : JSON.stringify(error);
-    const dataRetentionHint = /data retention mode/i.test(message)
+    const norm = normalizeProviderError(error);
+    // Surface the raw HTTP body (with status) when the SDK did not fold it into
+    // the message; otherwise fall back to the message. This is what stops a
+    // gateway 403 from collapsing to `Unknown: UnknownError`.
+    const core = !norm.messageCarriesBody && norm.status !== undefined && norm.body !== undefined
+        ? `${norm.status}: ${norm.body}`
+        : norm.message;
+    const dataRetentionHint = /data retention mode/i.test(core)
         ? ` See ${BEDROCK_DATA_RETENTION_DOCS_URL} for supported data retention modes.`
         : "";
     if (error instanceof BedrockRuntimeServiceException) {
         const prefix = BEDROCK_ERROR_PREFIXES[error.name] ?? error.name;
-        return `${prefix}: ${message}${dataRetentionHint}`;
+        return `${prefix}: ${core}${dataRetentionHint}`;
     }
-    return `${message}${dataRetentionHint}`;
+    return `${core}${dataRetentionHint}`;
 }
 /**
  * Header keys that must never be overwritten by caller-supplied headers.
@@ -267,7 +276,7 @@ function addCustomHeadersMiddleware(client, headers) {
     client.middlewareStack.add(middleware, { step: "build", name: "pi-ai-custom-headers", priority: "low" });
 }
 export const streamSimple = (model, context, options) => {
-    const base = buildBaseOptions(model, options, undefined);
+    const base = buildBaseOptions(model, context, options, undefined);
     if (!options?.reasoning) {
         return stream(model, context, { ...base, reasoning: undefined });
     }
@@ -282,13 +291,14 @@ export const streamSimple = (model, context, options) => {
         // Undefined means the caller did not request an output cap; let the helper use the model cap.
         // Do not coerce to 0 here, or the thinking budget would become the entire maxTokens value.
         const adjusted = adjustMaxTokensForThinking(base.maxTokens, model.maxTokens, options.reasoning, options.thinkingBudgets);
+        const maxTokens = clampMaxTokensToContext(model, context, adjusted.maxTokens);
         return stream(model, context, {
             ...base,
-            maxTokens: adjusted.maxTokens,
+            maxTokens,
             reasoning: options.reasoning,
             thinkingBudgets: {
                 ...(options.thinkingBudgets || {}),
-                [clampReasoning(options.reasoning)]: adjusted.thinkingBudget,
+                [clampReasoning(options.reasoning)]: Math.min(adjusted.thinkingBudget, Math.max(0, maxTokens - 1024)),
             },
         });
     }
@@ -415,6 +425,7 @@ function supportsAdaptiveThinking(modelId, modelName) {
         s.includes("opus-4-7") ||
         s.includes("opus-4-8") ||
         s.includes("sonnet-4-6") ||
+        s.includes("sonnet-5") ||
         s.includes("fable-5"));
 }
 function supportsNativeXhighEffort(model) {
@@ -468,7 +479,7 @@ function isAnthropicClaudeModel(model) {
 }
 /**
  * Check if the model supports prompt caching.
- * Supported: Claude 3.5 Haiku, Claude 3.7 Sonnet, Claude 4.x models
+ * Supported: Claude 3.5 Haiku, Claude 3.7 Sonnet, Claude 4.x models, Claude 5 models
  *
  * For base models and system-defined inference profiles the model ID / ARN
  * contains the model name, so we can decide locally.
@@ -488,6 +499,9 @@ function supportsPromptCaching(model, env) {
             return true;
         return false;
     }
+    // Claude 5 models (fable-5, sonnet-5)
+    if (candidates.some((s) => s.includes("fable-5") || s.includes("sonnet-5")))
+        return true;
     // Claude 4.x models (opus-4, sonnet-4, haiku-4)
     if (candidates.some((s) => s.includes("-4-")))
         return true;

package/node_modules/@earendil-works/pi-ai/dist/api/cloudflare.js

@@ -1,4 +1,3 @@
-import { getProviderEnvValue } from "../utils/provider-env.js";
 /** Workers AI direct endpoint. */
 export const CLOUDFLARE_WORKERS_AI_BASE_URL = "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/v1";
 /** AI Gateway Unified API. https://developers.cloudflare.com/ai-gateway/usage/unified-api/ */
@@ -7,21 +6,4 @@ export const CLOUDFLARE_AI_GATEWAY_COMPAT_BASE_URL = "https://gateway.ai.cloudfl
 export const CLOUDFLARE_AI_GATEWAY_OPENAI_BASE_URL = "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai";
 /** AI Gateway → Anthropic passthrough. */
 export const CLOUDFLARE_AI_GATEWAY_ANTHROPIC_BASE_URL = "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic";
-export function isCloudflareProvider(provider) {
-    return provider === "cloudflare-workers-ai" || provider === "cloudflare-ai-gateway";
-}
-/** Substitute `{VAR}` placeholders in a Cloudflare baseUrl from provider env or process.env. */
-export function resolveCloudflareBaseUrl(model, env) {
-    const url = model.baseUrl;
-    if (!url.includes("{"))
-        return url;
-    const baseUrl = url.replace(/\{([A-Z_][A-Z0-9_]*)\}/g, (_match, name) => {
-        const value = getProviderEnvValue(name, env);
-        if (!value) {
-            throw new Error(`${name} is required for provider ${model.provider} but is not set.`);
-        }
-        return value;
-    });
-    return baseUrl;
-}
 //# sourceMappingURL=cloudflare.js.map

package/node_modules/@earendil-works/pi-ai/dist/api/google-generative-ai.js

@@ -1,6 +1,8 @@
 import { GoogleGenAI, } from "@google/genai";
 import { calculateCost, clampThinkingLevel } from "../models.js";
+import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
+import { providerHeadersToRecord } from "../utils/headers.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { convertMessages, convertTools, isThinkingPart, mapStopReason, mapToolChoice, retainThoughtSignature, } from "./google-shared.js";
 import { buildBaseOptions } from "./simple-options.js";
@@ -161,6 +163,7 @@ export const stream = (model, context, options) => {
                         output: (chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0),
                         cacheRead: chunk.usageMetadata.cachedContentTokenCount || 0,
                         cacheWrite: 0,
+                        reasoning: chunk.usageMetadata.thoughtsTokenCount || 0,
                         totalTokens: chunk.usageMetadata.totalTokenCount || 0,
                         cost: {
                             input: 0,
@@ -208,7 +211,7 @@ export const stream = (model, context, options) => {
                 }
             }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+            output.errorMessage = formatProviderError(normalizeProviderError(error));
             stream.push({ type: "error", reason: output.stopReason, error: output });
             stream.end();
         }
@@ -220,7 +223,7 @@ export const streamSimple = (model, context, options) => {
     if (!apiKey) {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
-    const base = buildBaseOptions(model, options, apiKey);
+    const base = buildBaseOptions(model, context, options, apiKey);
     if (!options?.reasoning) {
         return stream(model, context, { ...base, thinking: { enabled: false } });
     }
@@ -250,8 +253,9 @@ function createClient(model, apiKey, optionsHeaders) {
         httpOptions.baseUrl = model.baseUrl;
         httpOptions.apiVersion = ""; // baseUrl already includes version path, don't append
     }
-    if (model.headers || optionsHeaders) {
-        httpOptions.headers = { ...model.headers, ...optionsHeaders };
+    const headers = providerHeadersToRecord({ ...model.headers, ...optionsHeaders });
+    if (headers) {
+        httpOptions.headers = headers;
     }
     return new GoogleGenAI({
         apiKey,

package/node_modules/@earendil-works/pi-ai/dist/api/google-vertex.js

@@ -1,6 +1,8 @@
 import { GoogleGenAI, ResourceScope, ThinkingLevel, } from "@google/genai";
 import { calculateCost, clampThinkingLevel } from "../models.js";
+import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
+import { providerHeadersToRecord } from "../utils/headers.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { convertMessages, convertTools, isThinkingPart, mapStopReason, mapToolChoice, retainThoughtSignature, } from "./google-shared.js";
@@ -170,6 +172,7 @@ export const stream = (model, context, options) => {
                         output: (chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0),
                         cacheRead: chunk.usageMetadata.cachedContentTokenCount || 0,
                         cacheWrite: 0,
+                        reasoning: chunk.usageMetadata.thoughtsTokenCount || 0,
                         totalTokens: chunk.usageMetadata.totalTokenCount || 0,
                         cost: {
                             input: 0,
@@ -217,7 +220,7 @@ export const stream = (model, context, options) => {
                 }
             }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+            output.errorMessage = formatProviderError(normalizeProviderError(error));
             stream.push({ type: "error", reason: output.stopReason, error: output });
             stream.end();
         }
@@ -225,7 +228,7 @@ export const stream = (model, context, options) => {
     return stream;
 };
 export const streamSimple = (model, context, options) => {
-    const base = buildBaseOptions(model, options, undefined);
+    const base = buildBaseOptions(model, context, options, undefined);
     if (!options?.reasoning) {
         return stream(model, context, {
             ...base,
@@ -281,8 +284,9 @@ function buildHttpOptions(model, optionsHeaders) {
             httpOptions.apiVersion = "";
         }
     }
-    if (model.headers || optionsHeaders) {
-        httpOptions.headers = { ...model.headers, ...optionsHeaders };
+    const headers = providerHeadersToRecord({ ...model.headers, ...optionsHeaders });
+    if (headers) {
+        httpOptions.headers = headers;
     }
     return Object.keys(httpOptions).length > 0 ? httpOptions : undefined;
 }

package/node_modules/@earendil-works/pi-ai/dist/api/mistral-conversations.js

@@ -65,7 +65,7 @@ export const streamSimple = (model, context, options) => {
     if (!apiKey) {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
-    const base = buildBaseOptions(model, options, apiKey);
+    const base = buildBaseOptions(model, context, options, apiKey);
     const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
     const reasoning = clampedReasoning === "off" ? undefined : clampedReasoning;
     const shouldUseReasoning = model.reasoning && reasoning !== undefined;

package/node_modules/@earendil-works/pi-ai/dist/api/openai-codex-responses.js

@@ -1,24 +1,16 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
+function loadNodeOs() {
+    if (typeof process === "undefined" || !(process.versions?.node || process.versions?.bun)) {
+        return null;
     }
-    return path;
-};
-// NEVER convert to top-level runtime imports - breaks browser/Vite builds
-let _os = null;
-const dynamicImport = (specifier) => import(__rewriteRelativeImportExtension(specifier));
-const NODE_OS_SPECIFIER = "node:" + "os";
-if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
-    dynamicImport(NODE_OS_SPECIFIER).then((m) => {
-        _os = m;
-    });
+    return process.getBuiltinModule?.("node:os") ?? null;
 }
+// NEVER convert to top-level runtime imports - breaks browser/Vite builds
+const _os = loadNodeOs();
 import { clampThinkingLevel } from "../models.js";
 import { registerSessionResourceCleanup } from "../session-resources.js";
 import { combineAbortSignals } from "../utils/abort-signals.js";
 import { appendAssistantMessageDiagnostic, createAssistantMessageDiagnostic, formatThrownValue, } from "../utils/diagnostics.js";
+import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { resolveHttpProxyUrlForTarget } from "../utils/node-http-proxy.js";
@@ -33,10 +25,10 @@ const JWT_CLAIM_PATH = "https://api.openai.com/auth";
 const DEFAULT_MAX_RETRIES = 0;
 const BASE_DELAY_MS = 1000;
 const DEFAULT_MAX_RETRY_DELAY_MS = 60_000;
-// Keep a bounded pre-header timeout so zero-event Codex SSE stalls fail instead of
-// leaving callers stuck on "Working..." indefinitely. See #4945.
-const DEFAULT_SSE_HEADER_TIMEOUT_MS = 20_000;
 const DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS = 15_000;
+// The Codex backend accepts zstd-compressed request bodies on the SSE responses
+// endpoint (the same endpoint the official Codex client compresses against).
+const REQUEST_COMPRESSION_ZSTD_LEVEL = 3;
 const CODEX_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
 const WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE = 1009;
 const WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE = "websocket_connection_limit_reached";
@@ -110,18 +102,29 @@ function normalizeTimeoutMs(value) {
     }
     return Math.floor(value);
 }
-function createSSEHeaderTimeout() {
-    const controller = new AbortController();
-    let error;
-    const timeout = setTimeout(() => {
-        error = new Error(`Codex SSE response headers timed out after ${DEFAULT_SSE_HEADER_TIMEOUT_MS}ms`);
-        controller.abort(error);
-    }, DEFAULT_SSE_HEADER_TIMEOUT_MS);
-    return {
-        signal: controller.signal,
-        clear: () => clearTimeout(timeout),
-        error: () => error,
-    };
+function loadNodeZlib() {
+    if (typeof process === "undefined" || !(process.versions?.node || process.versions?.bun)) {
+        return null;
+    }
+    return process.getBuiltinModule?.("node:zlib") ?? null;
+}
+// Returns the zstd-compressed body bytes, or null when compression is
+// unavailable (browser/Vite builds). Callers fall back to sending the
+// uncompressed JSON when this returns null.
+function compressRequestBodyZstd(bodyJson) {
+    const zlib = loadNodeZlib();
+    if (!zlib || typeof zlib.zstdCompressSync !== "function") {
+        return null;
+    }
+    try {
+        const compressed = zlib.zstdCompressSync(bodyJson, {
+            params: { [zlib.constants.ZSTD_c_compressionLevel]: REQUEST_COMPRESSION_ZSTD_LEVEL },
+        });
+        return new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength);
+    }
+    catch {
+        return null;
+    }
 }
 // ============================================================================
 // Main Stream Function
@@ -161,7 +164,7 @@ export const stream = (model, context, options) => {
             const sseHeaders = buildSSEHeaders(model.headers, options?.headers, accountId, apiKey, options?.sessionId);
             const websocketHeaders = buildWebSocketHeaders(model.headers, options?.headers, accountId, apiKey, websocketRequestId);
             const bodyJson = JSON.stringify(body);
-            const idleTimeoutMs = normalizeTimeoutMs(options?.timeoutMs);
+            const httpTimeoutMs = normalizeTimeoutMs(options?.timeoutMs);
             const websocketConnectTimeoutMs = normalizeTimeoutMs(options?.websocketConnectTimeoutMs);
             const transport = options?.transport || "auto";
             const websocketDisabledForSession = transport !== "sse" && isWebSocketSseFallbackActive(options?.sessionId);
@@ -176,7 +179,7 @@ export const stream = (model, context, options) => {
                     try {
                         await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), body, websocketHeaders, output, stream, model, () => {
                             websocketStarted = true;
-                        }, idleTimeoutMs, websocketConnectTimeoutMs, options);
+                        }, httpTimeoutMs, websocketConnectTimeoutMs, options);
                         if (options?.signal?.aborted) {
                             throw new Error("Request was aborted");
                         }
@@ -214,6 +217,14 @@ export const stream = (model, context, options) => {
                     }
                 }
             }
+            // Compress the request body once for the SSE path. The Codex backend
+            // decodes Content-Encoding: zstd; the WebSocket transport above sends the
+            // uncompressed JSON frame, matching the official Codex client.
+            const compressedBody = compressRequestBodyZstd(bodyJson);
+            if (compressedBody) {
+                sseHeaders.set("content-encoding", "zstd");
+            }
+            const sseBody = compressedBody ?? bodyJson;
             // Fetch with retry logic for rate limits and transient errors
             let response;
             let lastError;
@@ -223,23 +234,24 @@ export const stream = (model, context, options) => {
                     throw new Error("Request was aborted");
                 }
                 try {
-                    const headerTimeout = createSSEHeaderTimeout();
-                    const combinedSignal = combineAbortSignals([options?.signal, headerTimeout.signal]);
+                    const headerTimeoutSignal = httpTimeoutMs !== undefined && httpTimeoutMs > 0 ? AbortSignal.timeout(httpTimeoutMs) : undefined;
+                    const combinedSignal = combineAbortSignals([options?.signal, headerTimeoutSignal]);
                     try {
                         response = await fetch(resolveCodexUrl(model.baseUrl), {
                             method: "POST",
                             headers: sseHeaders,
-                            body: bodyJson,
+                            body: sseBody,
                             signal: combinedSignal.signal,
                         });
                     }
                     catch (error) {
-                        const timeoutError = headerTimeout.error();
-                        throw timeoutError && !options?.signal?.aborted ? timeoutError : error;
+                        if (headerTimeoutSignal?.aborted && !options?.signal?.aborted) {
+                            throw new Error(`Codex SSE response headers timed out after ${httpTimeoutMs}ms`);
+                        }
+                        throw error;
                     }
                     finally {
                         combinedSignal.cleanup();
-                        headerTimeout.clear();
                     }
                     await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
                     if (response.ok) {
@@ -300,7 +312,7 @@ export const stream = (model, context, options) => {
                 delete block.partialJson;
             }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = error instanceof Error ? error.message : String(error);
+            output.errorMessage = formatProviderError(normalizeProviderError(error));
             stream.push({ type: "error", reason: output.stopReason, error: output });
             stream.end();
         }
@@ -312,7 +324,7 @@ export const streamSimple = (model, context, options) => {
     if (!apiKey) {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
-    const base = buildBaseOptions(model, options, apiKey);
+    const base = buildBaseOptions(model, context, options, apiKey);
     const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
     const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
     return stream(model, context, {
@@ -553,6 +565,7 @@ async function* parseSSE(response, signal) {
 // ============================================================================
 const OPENAI_BETA_RESPONSES_WEBSOCKETS = "responses_websockets=2026-02-06";
 const SESSION_WEBSOCKET_CACHE_TTL_MS = 5 * 60 * 1000;
+const SESSION_WEBSOCKET_MAX_AGE_MS = 55 * 60 * 1000;
 const websocketSessionCache = new Map();
 const websocketDebugStats = new Map();
 const websocketSseFallbackSessions = new Set();
@@ -677,6 +690,9 @@ function isWebSocketReusable(socket) {
     // If readyState is unavailable, assume the runtime keeps it open/reusable.
     return readyState === undefined || readyState === 1;
 }
+function isWebSocketSessionExpired(entry) {
+    return Date.now() - entry.createdAt >= SESSION_WEBSOCKET_MAX_AGE_MS;
+}
 function closeWebSocketSilently(socket, code = 1000, reason = "done") {
     try {
         socket.close(code, reason);
@@ -777,7 +793,11 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
             clearTimeout(cached.idleTimer);
             cached.idleTimer = undefined;
         }
-        if (!cached.busy && isWebSocketReusable(cached.socket)) {
+        if (!cached.busy && isWebSocketSessionExpired(cached)) {
+            closeWebSocketSilently(cached.socket, 1000, "connection_age_limit");
+            websocketSessionCache.delete(sessionId);
+        }
+        else if (!cached.busy && isWebSocketReusable(cached.socket)) {
             cached.busy = true;
             return {
                 socket: cached.socket,
@@ -810,7 +830,7 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
         }
     }
     const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
-    const entry = { socket, busy: true };
+    const entry = { socket, busy: true, createdAt: Date.now() };
     websocketSessionCache.set(sessionId, entry);
     return {
         socket,
@@ -1164,7 +1184,12 @@ function createCodexRequestId() {
 function buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token) {
     const headers = new Headers(initHeaders);
     for (const [key, value] of Object.entries(additionalHeaders || {})) {
-        headers.set(key, value);
+        if (value === null) {
+            headers.delete(key);
+        }
+        else {
+            headers.set(key, value);
+        }
     }
     headers.set("Authorization", `Bearer ${token}`);
     headers.set("chatgpt-account-id", accountId);