@draht/ai 2026.7.30 → 2026.10.4-2

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

@@ -1,20 +1,14 @@
-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 { getDrahtUserAgent } from "../utils/draht-user-agent.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 { 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 { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
@@ -152,6 +146,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",
@@ -176,10 +171,10 @@ export const stream = (model, context, options) => {
                 throw new Error(`No API key for provider: ${model.provider}`);
             }
             const accountId = extractAccountId(apiKey);
-            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;
@@ -209,7 +204,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");
                         }
@@ -239,7 +234,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,
@@ -365,7 +360,10 @@ export const streamSimple = (model, context, options) => {
     if (!apiKey) {
         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;
     const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
     return stream(model, context, {
@@ -376,25 +374,27 @@ export const streamSimple = (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 messages = convertResponsesMessages(model, context, 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 },
     });
+    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"],
@@ -408,8 +408,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,
@@ -417,7 +417,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 = {
@@ -426,6 +428,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) {
@@ -475,7 +480,7 @@ function resolveCodexWebSocketUrl(baseUrl) {
 // Response Processing
 // ============================================================================
 async function processStream(response, output, stream, model, grammarToolInputProperties, options) {
-    await processResponsesStream(mapCodexEvents(parseSSE(response, options?.signal)), output, stream, model, {
+    await processResponsesStream(mapCodexEvents(parseSSE(response, options?.signal), output, model, options?.onProviderStreamEvent), output, stream, model, {
         serviceTier: options?.serviceTier,
         grammarToolInputProperties,
         resolveServiceTier: resolveCodexServiceTier,
@@ -483,6 +488,8 @@ async function processStream(response, output, stream, model, grammarToolInputPr
     });
 }
 class CodexApiError extends Error {
+    code;
+    payload;
     constructor(message, options) {
         super(message);
         this.name = "CodexApiError";
@@ -492,6 +499,7 @@ class CodexApiError extends Error {
     }
 }
 class CodexProtocolError extends Error {
+    payload;
     constructor(message, options) {
         super(message);
         this.name = "CodexProtocolError";
@@ -499,8 +507,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;
@@ -519,8 +536,15 @@ function extractCodexEventError(event) {
                 : undefined,
     };
 }
-async function* mapCodexEvents(events) {
+async function* mapCodexEvents(events, output, model, onProviderStreamEvent) {
     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;
@@ -539,6 +563,9 @@ async function* mapCodexEvents(events) {
         }
         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;
@@ -575,9 +602,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);
@@ -602,6 +630,8 @@ async function* parseSSE(response, signal) {
                 }
                 idx = buffer.indexOf("\n\n");
             }
+            if (done)
+                break;
         }
     }
     finally {
@@ -664,14 +694,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();
 }
@@ -726,6 +756,9 @@ async function getWebSocketConstructor(env) {
     return ctor;
 }
 class WebSocketCloseError extends Error {
+    code;
+    reason;
+    wasClean;
     constructor(message, options) {
         super(message);
         this.name = "WebSocketCloseError";
@@ -752,7 +785,7 @@ function closeWebSocketSilently(socket, code = 1000, reason = "done") {
     }
     catch { }
 }
-function scheduleSessionWebSocketExpiry(sessionId, entry) {
+function scheduleSessionWebSocketExpiry(sessionId, accountId, entry) {
     if (entry.idleTimer) {
         clearTimeout(entry.idleTimer);
     }
@@ -760,7 +793,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) {
@@ -831,7 +868,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 {
@@ -840,7 +877,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);
@@ -848,7 +886,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;
@@ -859,11 +899,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);
                 },
             };
         }
@@ -879,12 +923,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,
@@ -894,13 +945,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);
         },
     };
 }
@@ -1120,8 +1173,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").
@@ -1153,7 +1206,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)), onStart), output, stream, model, {
+        await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal, idleTimeoutMs), output, model, options?.onProviderStreamEvent), onStart), output, stream, model, {
             serviceTier: options?.serviceTier,
             grammarToolInputProperties,
             resolveServiceTier: resolveCodexServiceTier,
@@ -1163,7 +1216,7 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
             keepConnection = false;
         }
         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");
@@ -1241,9 +1294,8 @@ function buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token)
     }
     headers.set("Authorization", `Bearer ${token}`);
     headers.set("chatgpt-account-id", accountId);
-    headers.set("originator", "pi");
-    const userAgent = _os ? `pi (${_os.platform()} ${_os.release()}; ${_os.arch()})` : "pi (browser)";
-    headers.set("User-Agent", userAgent);
+    headers.set("originator", "draht");
+    headers.set("User-Agent", getDrahtUserAgent());
     return headers;
 }
 function buildSSEHeaders(initHeaders, additionalHeaders, accountId, token, sessionId) {