@draht/ai 2026.7.13 → 2026.9.5-1

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

@@ -1,19 +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 { uuidv7 } from "../utils/uuid.js";
+import { createGrammarToolInputProperties } from "./constrained-sampling.js";
 import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
 import { buildBaseOptions } from "./simple-options.js";
@@ -32,6 +28,7 @@ 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";
+const PREVIOUS_RESPONSE_NOT_FOUND_CODE = "previous_response_not_found";
 const CODEX_RESPONSE_STATUSES = new Set([
     "completed",
     "incomplete",
@@ -40,6 +37,14 @@ const CODEX_RESPONSE_STATUSES = new Set([
     "queued",
     "in_progress",
 ]);
+function assertSuccessfulOutput(output) {
+    if (output.stopReason === "pending") {
+        throw new Error("Codex stream ended without a stop reason");
+    }
+    if (output.stopReason === "error" || output.stopReason === "aborted") {
+        throw new Error(output.errorMessage || "An unknown error occurred");
+    }
+}
 // ============================================================================
 // Retry Helpers
 // ============================================================================
@@ -77,9 +82,14 @@ function getRetryAfterDelayMs(headers) {
     }
     return undefined;
 }
-function capRetryDelayMs(delayMs, options) {
+class RetryDelayExceededError extends Error {
+}
+function validateRetryDelayMs(delayMs, options) {
     const maxRetryDelayMs = options?.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
-    return maxRetryDelayMs > 0 ? Math.min(delayMs, maxRetryDelayMs) : delayMs;
+    if (maxRetryDelayMs > 0 && delayMs > maxRetryDelayMs) {
+        throw new RetryDelayExceededError(`Server requested ${Math.ceil(delayMs / 1000)}s retry delay (max: ${Math.ceil(maxRetryDelayMs / 1000)}s)`);
+    }
+    return delayMs;
 }
 function sleep(ms, signal) {
     return new Promise((resolve, reject) => {
@@ -150,7 +160,7 @@ export const stream = (model, context, options) => {
                 totalTokens: 0,
                 cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
             },
-            stopReason: "stop",
+            stopReason: "pending",
             timestamp: Date.now(),
         };
         try {
@@ -159,34 +169,44 @@ export const stream = (model, context, options) => {
                 throw new Error(`No API key for provider: ${model.provider}`);
             }
             const accountId = extractAccountId(apiKey);
-            let body = buildRequestBody(model, context, options);
+            const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, model.compat?.supportsOpenAIGrammarTools ?? false);
+            const cacheSessionId = options?.cacheRetention === "none" ? undefined : options?.sessionId;
+            const codexSessionId = clampOpenAIPromptCacheKey(cacheSessionId);
+            let body = buildRequestBody(model, context, options, codexSessionId, grammarToolInputProperties);
             const nextBody = await options?.onPayload?.(body, model);
             if (nextBody !== undefined) {
                 body = nextBody;
             }
-            const websocketRequestId = options?.sessionId || createCodexRequestId();
-            const sseHeaders = buildSSEHeaders(model.headers, options?.headers, accountId, apiKey, options?.sessionId);
+            const websocketRequestId = codexSessionId || uuidv7();
+            const sseHeaders = buildSSEHeaders(model.headers, options?.headers, accountId, apiKey, codexSessionId);
             const websocketHeaders = buildWebSocketHeaders(model.headers, options?.headers, accountId, apiKey, websocketRequestId);
             const bodyJson = JSON.stringify(body);
             const httpTimeoutMs = normalizeTimeoutMs(options?.timeoutMs);
             const websocketConnectTimeoutMs = normalizeTimeoutMs(options?.websocketConnectTimeoutMs);
             const transport = options?.transport || "auto";
-            const websocketDisabledForSession = transport !== "sse" && isWebSocketSseFallbackActive(options?.sessionId);
+            let startEmitted = false;
+            const websocketDisabledForSession = transport !== "sse" && isWebSocketSseFallbackActive(cacheSessionId);
             if (websocketDisabledForSession) {
-                recordWebSocketSseFallback(options?.sessionId);
+                recordWebSocketSseFallback(cacheSessionId);
             }
             if (transport !== "sse" && !websocketDisabledForSession) {
                 let websocketStarted = false;
                 let retriedWebSocketConnectionLimit = false;
+                let retriedMissingWebSocketContinuation = false;
                 while (true) {
                     websocketStarted = false;
                     try {
                         await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), body, websocketHeaders, output, stream, model, () => {
                             websocketStarted = true;
-                        }, httpTimeoutMs, websocketConnectTimeoutMs, options);
+                            if (!startEmitted) {
+                                startEmitted = true;
+                                stream.push({ type: "start", partial: output });
+                            }
+                        }, httpTimeoutMs, websocketConnectTimeoutMs, cacheSessionId, accountId, grammarToolInputProperties, options);
                         if (options?.signal?.aborted) {
                             throw new Error("Request was aborted");
                         }
+                        assertSuccessfulOutput(output);
                         stream.push({
                             type: "done",
                             reason: output.stopReason,
@@ -198,6 +218,11 @@ export const stream = (model, context, options) => {
                     catch (error) {
                         const aborted = options?.signal?.aborted;
                         const connectionLimitBeforeStart = !websocketStarted && isWebSocketConnectionLimitReachedError(error);
+                        const previousResponseNotFound = isPreviousResponseNotFoundError(error);
+                        if (!aborted && previousResponseNotFound && !retriedMissingWebSocketContinuation) {
+                            retriedMissingWebSocketContinuation = true;
+                            continue;
+                        }
                         if (!aborted && connectionLimitBeforeStart && !retriedWebSocketConnectionLimit) {
                             retriedWebSocketConnectionLimit = true;
                             continue;
@@ -212,11 +237,11 @@ export const stream = (model, context, options) => {
                             phase: websocketStarted ? "after_message_stream_start" : "before_message_stream_start",
                             requestBytes: new TextEncoder().encode(bodyJson).byteLength,
                         }));
-                        recordWebSocketFailure(options?.sessionId, error);
+                        recordWebSocketFailure(cacheSessionId, error);
                         if (websocketStarted) {
                             throw error;
                         }
-                        recordWebSocketSseFallback(options?.sessionId);
+                        recordWebSocketSseFallback(cacheSessionId);
                         break;
                     }
                 }
@@ -241,7 +266,7 @@ export const stream = (model, context, options) => {
                     const headerTimeoutSignal = httpTimeoutMs !== undefined && httpTimeoutMs > 0 ? AbortSignal.timeout(httpTimeoutMs) : undefined;
                     const combinedSignal = combineAbortSignals([options?.signal, headerTimeoutSignal]);
                     try {
-                        response = await fetch(resolveCodexUrl(model.baseUrl), {
+                        response = await (options?.fetch ?? globalThis.fetch)(resolveCodexUrl(model.baseUrl), {
                             method: "POST",
                             headers: sseHeaders,
                             body: sseBody,
@@ -266,9 +291,7 @@ export const stream = (model, context, options) => {
                         const retryAfterDelayMs = getRetryAfterDelayMs(response.headers);
                         const delayMs = retryAfterDelayMs === undefined
                             ? BASE_DELAY_MS * 2 ** attempt
-                            : response.status === 429
-                                ? capRetryDelayMs(retryAfterDelayMs, options)
-                                : retryAfterDelayMs;
+                            : validateRetryDelayMs(retryAfterDelayMs, options);
                         await sleep(delayMs, options?.signal);
                         continue;
                     }
@@ -288,7 +311,9 @@ export const stream = (model, context, options) => {
                     }
                     lastError = error instanceof Error ? error : new Error(String(error));
                     // Network errors are retryable
-                    if (attempt < maxRetries && !lastError.message.includes("usage limit")) {
+                    if (attempt < maxRetries &&
+                        !(lastError instanceof RetryDelayExceededError) &&
+                        !lastError.message.includes("usage limit")) {
                         const delayMs = BASE_DELAY_MS * 2 ** attempt;
                         await sleep(delayMs, options?.signal);
                         continue;
@@ -302,18 +327,23 @@ export const stream = (model, context, options) => {
             if (!response.body) {
                 throw new Error("No response body");
             }
-            stream.push({ type: "start", partial: output });
-            await processStream(response, output, stream, model, options);
+            if (!startEmitted) {
+                startEmitted = true;
+                stream.push({ type: "start", partial: output });
+            }
+            await processStream(response, output, stream, model, grammarToolInputProperties, options);
             if (options?.signal?.aborted) {
                 throw new Error("Request was aborted");
             }
+            assertSuccessfulOutput(output);
             stream.push({ type: "done", reason: output.stopReason, message: output });
             stream.end();
         }
         catch (error) {
             for (const block of output.content) {
-                // partialJson is only a streaming scratch buffer; never persist it.
+                // Streaming scratch buffers are only used during parsing; never persist them.
                 delete block.partialJson;
+                delete block.customInput;
             }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
             output.errorMessage = formatProviderError(normalizeProviderError(error));
@@ -328,7 +358,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, {
@@ -339,9 +372,19 @@ export const streamSimple = (model, context, options) => {
 // ============================================================================
 // Request Building
 // ============================================================================
-function buildRequestBody(model, context, options) {
+function buildRequestBody(model, context, options, cacheSessionId, grammarToolInputProperties = createGrammarToolInputProperties(context.tools, 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 messages = convertResponsesMessages(model, context, CODEX_TOOL_CALL_PROVIDERS, {
         includeSystemPrompt: false,
+        grammarToolInputProperties,
+        deferredTools: toolPlacement.deferred,
+        toolOptions: {
+            strict: null,
+            supportsStrictMode,
+            supportsOpenAIGrammarTools,
+        },
     });
     const body = {
         model: model.id,
@@ -351,8 +394,8 @@ function buildRequestBody(model, context, options) {
         input: messages,
         text: { verbosity: options?.textVerbosity || "low" },
         include: ["reasoning.encrypted_content"],
-        prompt_cache_key: clampOpenAIPromptCacheKey(options?.sessionId),
-        tool_choice: "auto",
+        prompt_cache_key: cacheSessionId,
+        tool_choice: options?.toolChoice ?? "auto",
         parallel_tool_calls: true,
     };
     if (options?.temperature !== undefined) {
@@ -361,8 +404,12 @@ function buildRequestBody(model, context, options) {
     if (options?.serviceTier !== undefined) {
         body.service_tier = options.serviceTier;
     }
-    if (context.tools && context.tools.length > 0) {
-        body.tools = convertResponsesTools(context.tools, { strict: null });
+    if (toolPlacement.immediate.length > 0) {
+        body.tools = convertResponsesTools(toolPlacement.immediate, {
+            strict: null,
+            supportsStrictMode,
+            supportsOpenAIGrammarTools,
+        });
     }
     if (options?.reasoningEffort !== undefined) {
         const effort = options.reasoningEffort === "none"
@@ -423,9 +470,10 @@ function resolveCodexWebSocketUrl(baseUrl) {
 // ============================================================================
 // Response Processing
 // ============================================================================
-async function processStream(response, output, stream, model, options) {
+async function processStream(response, output, stream, model, grammarToolInputProperties, options) {
     await processResponsesStream(mapCodexEvents(parseSSE(response, options?.signal)), output, stream, model, {
         serviceTier: options?.serviceTier,
+        grammarToolInputProperties,
         resolveServiceTier: resolveCodexServiceTier,
         applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),
     });
@@ -453,6 +501,9 @@ function isCodexNonTransportError(error) {
 function isWebSocketConnectionLimitReachedError(error) {
     return error instanceof CodexApiError && error.code === WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE;
 }
+function isPreviousResponseNotFoundError(error) {
+    return error instanceof CodexApiError && error.code === PREVIOUS_RESPONSE_NOT_FOUND_CODE;
+}
 function extractCodexEventError(event) {
     const nested = event.error && typeof event.error === "object" ? event.error : undefined;
     return {
@@ -520,9 +571,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);
@@ -547,6 +599,8 @@ async function* parseSSE(response, signal) {
                 }
                 idx = buffer.indexOf("\n\n");
             }
+            if (done)
+                break;
         }
     }
     finally {
@@ -609,14 +663,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();
 }
@@ -697,7 +751,7 @@ function closeWebSocketSilently(socket, code = 1000, reason = "done") {
     }
     catch { }
 }
-function scheduleSessionWebSocketExpiry(sessionId, entry) {
+function scheduleSessionWebSocketExpiry(sessionId, accountId, entry) {
     if (entry.idleTimer) {
         clearTimeout(entry.idleTimer);
     }
@@ -705,7 +759,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) {
@@ -776,7 +834,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 {
@@ -785,7 +843,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);
@@ -793,7 +852,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;
@@ -804,11 +865,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);
                 },
             };
         }
@@ -824,12 +889,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,
@@ -839,13 +911,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);
         },
     };
 }
@@ -1055,26 +1129,25 @@ function buildCachedWebSocketRequestBody(entry, body) {
         input: delta,
     };
 }
-async function* startWebSocketOutputOnFirstEvent(events, output, stream, onStart) {
+async function* startWebSocketOutputOnFirstEvent(events, onStart) {
     let started = false;
     for await (const event of events) {
         if (!started) {
             started = true;
             onStart();
-            stream.push({ type: "start", partial: output });
         }
         yield event;
     }
 }
-async function processWebSocketStream(url, body, headers, output, stream, model, onStart, idleTimeoutMs, websocketConnectTimeoutMs, options) {
-    const { socket, entry, reused, release } = await acquireWebSocket(url, headers, options?.sessionId, 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").
     // WebSocket continuation still works via connection-scoped previous_response_id state.
     const fullBody = body;
     const requestBody = useCachedContext && entry ? buildCachedWebSocketRequestBody(entry, fullBody) : fullBody;
-    const stats = options?.sessionId ? getOrCreateWebSocketDebugStats(options.sessionId) : undefined;
+    const stats = cacheSessionId ? getOrCreateWebSocketDebugStats(cacheSessionId) : undefined;
     if (stats) {
         stats.requests++;
         if (reused)
@@ -1099,8 +1172,9 @@ 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)), output, stream, onStart), output, stream, model, {
+        await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal, idleTimeoutMs)), onStart), output, stream, model, {
             serviceTier: options?.serviceTier,
+            grammarToolInputProperties,
             resolveServiceTier: resolveCodexServiceTier,
             applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),
         });
@@ -1110,7 +1184,8 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
         else if (useCachedContext && entry && output.responseId) {
             const responseItems = convertResponsesMessages(model, { messages: [output] }, CODEX_TOOL_CALL_PROVIDERS, {
                 includeSystemPrompt: false,
-            }).filter((item) => item.type !== "function_call_output");
+                grammarToolInputProperties,
+            }).filter((item) => item.type !== "function_call_output" && item.type !== "custom_tool_call_output");
             entry.continuation = {
                 lastRequestBody: fullBody,
                 lastResponseId: output.responseId,
@@ -1173,12 +1248,6 @@ function extractAccountId(token) {
         throw new Error("Failed to extract accountId from token");
     }
 }
-function createCodexRequestId() {
-    if (typeof globalThis.crypto?.randomUUID === "function") {
-        return globalThis.crypto.randomUUID();
-    }
-    return `codex_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-}
 function buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token) {
     const headers = new Headers(initHeaders);
     for (const [key, value] of Object.entries(additionalHeaders || {})) {
@@ -1192,8 +1261,7 @@ 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("User-Agent", getPiUserAgent());
     return headers;
 }
 function buildSSEHeaders(initHeaders, additionalHeaders, accountId, token, sessionId) {