@fractaal/pi-ai 0.85.4 → 0.86.1

package/dist/api/openai-codex-responses.js

@@ -1,21 +1,15 @@
-function loadNodeOs() {
-    if (typeof process === "undefined" || !(process.versions?.node || process.versions?.bun)) {
-        return null;
-    }
-    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 { splitDeferredTools } from "../utils/deferred-tools.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";
+import { getPiUserAgent } from "../utils/pi-user-agent.js";
 import { isRetryableAssistantError, retryAssistantCall } from "../utils/retry.js";
+import { getSystemMessageText } from "../utils/text.js";
+import { getDeclaredTools, getInitialSystemMessage, normalizeContext, resolveTranscript, resolveTranscriptTools, } from "../utils/transcript.js";
 import { uuidv7 } from "../utils/uuid.js";
 import { createGrammarToolInputProperties } from "./constrained-sampling.js";
 import { retainCodexCompactionInput, trimCodexCompactionToolOutputs } from "./openai-codex-compaction-history.js";
@@ -191,6 +185,7 @@ function compressRequestBodyZstd(bodyJson) {
 // ============================================================================
 export const stream = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
+    const normalizedContext = resolveTranscript(context, model.compat?.supportsMidConvoSystemMessages);
     (async () => {
         const output = {
             role: "assistant",
@@ -219,10 +214,10 @@ export const stream = (model, context, options) => {
                 throw new Error(`No API key for provider: ${model.provider}`);
             }
             const accountId = apiKey ? extractAccountId(apiKey) : undefined;
-            const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, model.compat?.supportsOpenAIGrammarTools ?? false);
+            const grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(normalizedContext.messages), model.compat?.supportsOpenAIGrammarTools ?? false);
             const cacheSessionId = options?.cacheRetention === "none" ? undefined : options?.sessionId;
             const codexSessionId = clampOpenAIPromptCacheKey(cacheSessionId);
-            let body = buildRequestBody(model, context, options, codexSessionId, grammarToolInputProperties);
+            let body = buildRequestBody(model, normalizedContext, options, codexSessionId, grammarToolInputProperties);
             const nextBody = await options?.onPayload?.(body, model);
             if (nextBody !== undefined) {
                 body = nextBody;
@@ -239,7 +234,8 @@ export const stream = (model, context, options) => {
             if (websocketDisabledForSession) {
                 recordWebSocketSseFallback(cacheSessionId);
             }
-            if (transport !== "sse" && !websocketDisabledForSession) {
+            // WebSocket sessions are cached per account; transport auth has no account and always uses SSE.
+            if (transport !== "sse" && !websocketDisabledForSession && accountId) {
                 let websocketStarted = false;
                 let retriedWebSocketConnectionLimit = false;
                 let retriedMissingWebSocketContinuation = false;
@@ -252,7 +248,7 @@ export const stream = (model, context, options) => {
                                 startEmitted = true;
                                 stream.push({ type: "start", partial: output });
                             }
-                        }, httpTimeoutMs, websocketConnectTimeoutMs, cacheSessionId, grammarToolInputProperties, options);
+                        }, httpTimeoutMs, websocketConnectTimeoutMs, cacheSessionId, accountId, grammarToolInputProperties, options);
                         if (options?.signal?.aborted) {
                             throw new Error("Request was aborted");
                         }
@@ -282,7 +278,7 @@ export const stream = (model, context, options) => {
                         }
                         appendAssistantMessageDiagnostic(output, createAssistantMessageDiagnostic("provider_transport_failure", error, {
                             configuredTransport: transport,
-                            fallbackTransport: websocketStarted ? undefined : "sse",
+                            ...(websocketStarted ? {} : { fallbackTransport: "sse" }),
                             eventsEmitted: websocketStarted,
                             phase: websocketStarted ? "after_message_stream_start" : "before_message_stream_start",
                             requestBytes: new TextEncoder().encode(bodyJson).byteLength,
@@ -423,7 +419,10 @@ function buildSimpleCodexOptions(model, context, options) {
     if (!apiKey && options?.authMode !== "transport") {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
-    const base = buildBaseOptions(model, context, options, apiKey);
+    const base = {
+        ...buildBaseOptions(model, context, options, apiKey),
+        toolChoice: options?.toolChoice,
+    };
     const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
     return {
         ...base,
@@ -433,7 +432,8 @@ function buildSimpleCodexOptions(model, context, options) {
     };
 }
 export const streamSimple = (model, context, options) => stream(model, context, buildSimpleCodexOptions(model, context, options));
-export async function compactOpenAICodexResponses(model, context, options) {
+export async function compactOpenAICodexResponses(model, requestContext, options) {
+    const context = normalizeContext(requestContext);
     const items = [];
     const base = buildSimpleCodexOptions(model, context, options);
     let transport = base.transport;
@@ -466,10 +466,9 @@ export async function compactOpenAICodexResponses(model, context, options) {
     }
     return {
         item: { ...item },
-        retainedInput: retainCodexCompactionInput(buildRequestBody(model, {
-            ...context,
-            messages: (options?.nativeCompactionRetainedMessages ?? context.messages).filter((message) => message.role === "user"),
-        }, base, undefined).input ?? []),
+        retainedInput: retainCodexCompactionInput(buildRequestBody(model, normalizeContext({
+            messages: (options?.nativeCompactionRetainedMessages ?? requestContext.messages).filter((message) => message.role === "user"),
+        }), base, undefined).input ?? []),
         tokensBefore: result.usage.input + result.usage.cacheRead,
         usage: result.usage,
     };
@@ -477,10 +476,12 @@ export async function compactOpenAICodexResponses(model, context, options) {
 // ============================================================================
 // Request Building
 // ============================================================================
-function buildRequestBody(model, context, options, cacheSessionId, grammarToolInputProperties = createGrammarToolInputProperties(context.tools, model.compat?.supportsOpenAIGrammarTools ?? false)) {
+function buildRequestBody(model, context, options, cacheSessionId, grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(context.messages), model.compat?.supportsOpenAIGrammarTools ?? false)) {
     const supportsStrictMode = model.compat?.supportsStrictMode ?? true;
     const supportsOpenAIGrammarTools = model.compat?.supportsOpenAIGrammarTools ?? false;
-    const toolPlacement = splitDeferredTools(context, model.compat?.supportsToolSearch ?? false);
+    const supportsAdditionalTools = model.compat?.supportsAdditionalTools ?? false;
+    const supportsToolSearch = model.compat?.supportsToolSearch ?? false;
+    const transcriptTools = resolveTranscriptTools(context.messages, supportsAdditionalTools || supportsToolSearch);
     const checkpoint = options?.nativeCompactionCheckpoint;
     const checkpointInput = checkpoint ? [...(checkpoint.retainedInput ?? []), checkpoint.item] : [];
     const requestContext = options?.nativeCompaction
@@ -489,12 +490,10 @@ function buildRequestBody(model, context, options, cacheSessionId, grammarToolIn
     const messages = convertResponsesMessages(model, requestContext, CODEX_TOOL_CALL_PROVIDERS, {
         includeSystemPrompt: false,
         grammarToolInputProperties,
-        deferredTools: toolPlacement.deferred,
-        toolOptions: {
-            strict: null,
-            supportsStrictMode,
-            supportsOpenAIGrammarTools,
-        },
+        supportsMidConvoSystemMessages: model.compat?.supportsMidConvoSystemMessages ?? false,
+        supportsAdditionalTools,
+        supportsToolSearch,
+        toolOptions: { strict: null, supportsStrictMode, supportsOpenAIGrammarTools },
     });
     if (checkpoint) {
         if (checkpoint.provider !== model.provider || model.api !== "openai-codex-responses") {
@@ -510,11 +509,13 @@ function buildRequestBody(model, context, options, cacheSessionId, grammarToolIn
     if (options?.nativeCompaction) {
         messages.push({ type: "compaction_trigger" });
     }
+    const initialSystemMessage = getInitialSystemMessage(context.messages);
+    const instructions = initialSystemMessage ? getSystemMessageText(initialSystemMessage) : "";
     const body = {
         model: model.id,
         store: false,
         stream: true,
-        instructions: context.systemPrompt || "You are a helpful assistant.",
+        instructions: instructions || "You are a helpful assistant.",
         input: messages,
         text: { verbosity: options?.textVerbosity || "low" },
         include: ["reasoning.encrypted_content"],
@@ -528,8 +529,8 @@ function buildRequestBody(model, context, options, cacheSessionId, grammarToolIn
     if (options?.serviceTier !== undefined) {
         body.service_tier = options.serviceTier;
     }
-    if (toolPlacement.immediate.length > 0) {
-        body.tools = convertResponsesTools(toolPlacement.immediate, {
+    if (transcriptTools.requestTools.length > 0) {
+        body.tools = convertResponsesTools(transcriptTools.requestTools, {
             strict: null,
             supportsStrictMode,
             supportsOpenAIGrammarTools,
@@ -537,7 +538,9 @@ function buildRequestBody(model, context, options, cacheSessionId, grammarToolIn
     }
     if (options?.reasoningEffort !== undefined) {
         const effort = options.reasoningEffort === "none"
-            ? (model.thinkingLevelMap?.off ?? "none")
+            ? model.thinkingLevelMap?.off === undefined
+                ? "none"
+                : model.thinkingLevelMap.off
             : (model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort);
         if (effort !== null) {
             body.reasoning = {
@@ -546,6 +549,9 @@ function buildRequestBody(model, context, options, cacheSessionId, grammarToolIn
             };
         }
     }
+    else if (model.reasoning && model.thinkingLevelMap?.off !== null) {
+        body.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
+    }
     return body;
 }
 function getServiceTierCostMultiplier(model, serviceTier) {
@@ -595,7 +601,7 @@ function resolveCodexWebSocketUrl(baseUrl) {
 // Response Processing
 // ============================================================================
 async function processStream(response, output, stream, model, grammarToolInputProperties, options) {
-    await processResponsesStream(mapCodexEvents(parseSSE(response, options?.signal), options?.onNativeCompactionItem), output, stream, model, {
+    await processResponsesStream(mapCodexEvents(parseSSE(response, options?.signal), output, model, options?.onProviderStreamEvent, options?.onNativeCompactionItem), output, stream, model, {
         serviceTier: options?.serviceTier,
         grammarToolInputProperties,
         resolveServiceTier: resolveCodexServiceTier,
@@ -624,8 +630,17 @@ class CodexProtocolError extends Error {
         this.cause = options?.cause;
     }
 }
+class ProviderStreamEventCallbackError extends Error {
+    constructor(cause) {
+        super(formatThrownValue(cause));
+        this.name = "ProviderStreamEventCallbackError";
+        this.cause = cause;
+    }
+}
 function isCodexNonTransportError(error) {
-    return error instanceof CodexApiError || error instanceof CodexProtocolError;
+    return (error instanceof CodexApiError ||
+        error instanceof CodexProtocolError ||
+        error instanceof ProviderStreamEventCallbackError);
 }
 function isWebSocketConnectionLimitReachedError(error) {
     return error instanceof CodexApiError && error.code === WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE;
@@ -650,8 +665,15 @@ function extractCodexEventError(event) {
                 : undefined,
     };
 }
-async function* mapCodexEvents(events, onNativeCompactionItem) {
+async function* mapCodexEvents(events, output, model, onProviderStreamEvent, onNativeCompactionItem) {
     for await (const event of events) {
+        try {
+            await onProviderStreamEvent?.(event, model);
+        }
+        catch (error) {
+            // Keep callback failures out of Codex's WebSocket retry and SSE fallback path.
+            throw new ProviderStreamEventCallbackError(error);
+        }
         const type = typeof event.type === "string" ? event.type : undefined;
         if (!type)
             continue;
@@ -675,6 +697,9 @@ async function* mapCodexEvents(events, onNativeCompactionItem) {
         }
         if (type === "response.done" || type === "response.completed" || type === "response.incomplete") {
             const response = event.response;
+            if (typeof response?.end_turn === "boolean") {
+                output.endTurn = response.end_turn;
+            }
             const normalizedResponse = response
                 ? { ...response, status: normalizeCodexStatus(response.status) }
                 : response;
@@ -711,9 +736,10 @@ async function* parseSSE(response, signal) {
             if (signal?.aborted) {
                 throw new Error("Request was aborted");
             }
-            if (done)
-                break;
-            buffer += decoder.decode(value, { stream: true });
+            buffer += done ? decoder.decode() : decoder.decode(value, { stream: true });
+            // Treat EOF as terminating the residual SSE frame.
+            if (done && buffer.trim())
+                buffer += "\n\n";
             let idx = buffer.indexOf("\n\n");
             while (idx !== -1) {
                 const chunk = buffer.slice(0, idx);
@@ -738,6 +764,8 @@ async function* parseSSE(response, signal) {
                 }
                 idx = buffer.indexOf("\n\n");
             }
+            if (done)
+                break;
         }
     }
     finally {
@@ -800,14 +828,14 @@ export function closeOpenAICodexWebSocketSessions(sessionId) {
         closeWebSocketSilently(entry.socket, 1000, "debug_close");
     };
     if (sessionId) {
-        const entry = websocketSessionCache.get(sessionId);
-        if (entry)
+        for (const entry of websocketSessionCache.get(sessionId)?.values() ?? [])
             closeEntry(entry);
         websocketSessionCache.delete(sessionId);
         return;
     }
-    for (const entry of websocketSessionCache.values()) {
-        closeEntry(entry);
+    for (const accountEntries of websocketSessionCache.values()) {
+        for (const entry of accountEntries.values())
+            closeEntry(entry);
     }
     websocketSessionCache.clear();
 }
@@ -891,7 +919,7 @@ function closeWebSocketSilently(socket, code = 1000, reason = "done") {
     }
     catch { }
 }
-function scheduleSessionWebSocketExpiry(sessionId, entry) {
+function scheduleSessionWebSocketExpiry(sessionId, accountId, entry) {
     if (entry.idleTimer) {
         clearTimeout(entry.idleTimer);
     }
@@ -899,7 +927,11 @@ function scheduleSessionWebSocketExpiry(sessionId, entry) {
         if (entry.busy)
             return;
         closeWebSocketSilently(entry.socket, 1000, "idle_timeout");
-        websocketSessionCache.delete(sessionId);
+        const accountEntries = websocketSessionCache.get(sessionId);
+        if (accountEntries?.get(accountId) === entry)
+            accountEntries.delete(accountId);
+        if (accountEntries?.size === 0)
+            websocketSessionCache.delete(sessionId);
     }, SESSION_WEBSOCKET_CACHE_TTL_MS);
 }
 async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS, env) {
@@ -970,7 +1002,7 @@ async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT
         }
     });
 }
-async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutMs, env) {
+async function acquireWebSocket(url, headers, sessionId, accountId, signal, connectTimeoutMs, env) {
     if (!sessionId) {
         const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
         return {
@@ -979,7 +1011,8 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
             release: () => closeWebSocketSilently(socket),
         };
     }
-    const cached = websocketSessionCache.get(sessionId);
+    let accountEntries = websocketSessionCache.get(sessionId);
+    const cached = accountEntries?.get(accountId);
     if (cached) {
         if (cached.idleTimer) {
             clearTimeout(cached.idleTimer);
@@ -987,7 +1020,9 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
         }
         if (!cached.busy && isWebSocketSessionExpired(cached)) {
             closeWebSocketSilently(cached.socket, 1000, "connection_age_limit");
-            websocketSessionCache.delete(sessionId);
+            accountEntries?.delete(accountId);
+            if (accountEntries?.size === 0)
+                websocketSessionCache.delete(sessionId);
         }
         else if (!cached.busy && isWebSocketReusable(cached.socket)) {
             cached.busy = true;
@@ -998,11 +1033,15 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
                 release: ({ keep } = {}) => {
                     if (!keep || !isWebSocketReusable(cached.socket)) {
                         closeWebSocketSilently(cached.socket);
-                        websocketSessionCache.delete(sessionId);
+                        const currentEntries = websocketSessionCache.get(sessionId);
+                        if (currentEntries?.get(accountId) === cached)
+                            currentEntries.delete(accountId);
+                        if (currentEntries?.size === 0)
+                            websocketSessionCache.delete(sessionId);
                         return;
                     }
                     cached.busy = false;
-                    scheduleSessionWebSocketExpiry(sessionId, cached);
+                    scheduleSessionWebSocketExpiry(sessionId, accountId, cached);
                 },
             };
         }
@@ -1018,12 +1057,19 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
         }
         if (!isWebSocketReusable(cached.socket)) {
             closeWebSocketSilently(cached.socket);
-            websocketSessionCache.delete(sessionId);
+            accountEntries?.delete(accountId);
+            if (accountEntries?.size === 0)
+                websocketSessionCache.delete(sessionId);
         }
     }
     const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
     const entry = { socket, busy: true, createdAt: Date.now() };
-    websocketSessionCache.set(sessionId, entry);
+    accountEntries = websocketSessionCache.get(sessionId);
+    if (!accountEntries) {
+        accountEntries = new Map();
+        websocketSessionCache.set(sessionId, accountEntries);
+    }
+    accountEntries.set(accountId, entry);
     return {
         socket,
         entry,
@@ -1033,13 +1079,15 @@ async function acquireWebSocket(url, headers, sessionId, signal, connectTimeoutM
                 closeWebSocketSilently(entry.socket);
                 if (entry.idleTimer)
                     clearTimeout(entry.idleTimer);
-                if (websocketSessionCache.get(sessionId) === entry) {
+                const currentEntries = websocketSessionCache.get(sessionId);
+                if (currentEntries?.get(accountId) === entry)
+                    currentEntries.delete(accountId);
+                if (currentEntries?.size === 0)
                     websocketSessionCache.delete(sessionId);
-                }
                 return;
             }
             entry.busy = false;
-            scheduleSessionWebSocketExpiry(sessionId, entry);
+            scheduleSessionWebSocketExpiry(sessionId, accountId, entry);
         },
     };
 }
@@ -1259,8 +1307,8 @@ async function* startWebSocketOutputOnFirstEvent(events, onStart) {
         yield event;
     }
 }
-async function processWebSocketStream(url, body, headers, output, stream, model, onStart, idleTimeoutMs, websocketConnectTimeoutMs, cacheSessionId, grammarToolInputProperties, options) {
-    const { socket, entry, reused, release } = await acquireWebSocket(url, headers, cacheSessionId, options?.signal, websocketConnectTimeoutMs, options?.env);
+async function processWebSocketStream(url, body, headers, output, stream, model, onStart, idleTimeoutMs, websocketConnectTimeoutMs, cacheSessionId, accountId, grammarToolInputProperties, options) {
+    const { socket, entry, reused, release } = await acquireWebSocket(url, headers, cacheSessionId, accountId, options?.signal, websocketConnectTimeoutMs, options?.env);
     let keepConnection = true;
     const useCachedContext = options?.transport === "websocket-cached" || options?.transport === "auto";
     // ChatGPT Codex Responses rejects `store: true` ("Store must be set to false").
@@ -1292,7 +1340,7 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
     }
     try {
         socket.send(JSON.stringify({ type: "response.create", ...requestBody }));
-        await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal, idleTimeoutMs), options?.onNativeCompactionItem), onStart), output, stream, model, {
+        await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal, idleTimeoutMs), output, model, options?.onProviderStreamEvent, options?.onNativeCompactionItem), onStart), output, stream, model, {
             serviceTier: options?.serviceTier,
             grammarToolInputProperties,
             resolveServiceTier: resolveCodexServiceTier,
@@ -1306,7 +1354,7 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
             entry.continuation = undefined;
         }
         else if (useCachedContext && entry && output.responseId) {
-            const responseItems = convertResponsesMessages(model, { messages: [output] }, CODEX_TOOL_CALL_PROVIDERS, {
+            const responseItems = convertResponsesMessages(model, normalizeContext({ messages: [output] }), CODEX_TOOL_CALL_PROVIDERS, {
                 includeSystemPrompt: false,
                 grammarToolInputProperties,
             }).filter((item) => item.type !== "function_call_output" && item.type !== "custom_tool_call_output");
@@ -1394,8 +1442,7 @@ function buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token)
         headers.delete("chatgpt-account-id");
     }
     headers.set("originator", "pi");
-    const userAgent = _os ? `pi (${_os.platform()} ${_os.release()}; ${_os.arch()})` : "pi (browser)";
-    headers.set("User-Agent", userAgent);
+    headers.set("User-Agent", getPiUserAgent());
     return headers;
 }
 function buildSSEHeaders(initHeaders, additionalHeaders, accountId, token, sessionId) {