@fractaal/pi-ai 0.84.8 → 0.85.1

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

@@ -15,8 +15,10 @@ import { formatProviderError, normalizeProviderError } from "../utils/error-body
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { resolveHttpProxyUrlForTarget } from "../utils/node-http-proxy.js";
+import { isRetryableAssistantError, retryAssistantCall } from "../utils/retry.js";
 import { uuidv7 } from "../utils/uuid.js";
 import { createGrammarToolInputProperties } from "./constrained-sampling.js";
+import { retainCodexCompactionInput, trimCodexCompactionToolOutputs } from "./openai-codex-compaction-history.js";
 import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
 import { buildBaseOptions } from "./simple-options.js";
@@ -44,6 +46,7 @@ const CODEX_RESPONSE_STATUSES = new Set([
     "queued",
     "in_progress",
 ]);
+export { estimateOpenAINativeCompactionTokens } from "./openai-codex-compaction-history.js";
 export function isOpenAICodexProvider(provider) {
     if (!provider || provider.id !== "openai-codex")
         return false;
@@ -207,11 +210,15 @@ export const stream = (model, context, options) => {
             timestamp: Date.now(),
         };
         try {
-            const apiKey = options?.apiKey;
-            if (!apiKey) {
+            const transportAuth = options?.authMode === "transport";
+            if (transportAuth && (!options?.fetch || options.fetch === globalThis.fetch)) {
+                throw new Error("Codex transport auth requires a custom fetch that owns authentication");
+            }
+            const apiKey = transportAuth ? undefined : options?.apiKey;
+            if (!transportAuth && !apiKey) {
                 throw new Error(`No API key for provider: ${model.provider}`);
             }
-            const accountId = extractAccountId(apiKey);
+            const accountId = apiKey ? extractAccountId(apiKey) : undefined;
             const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, model.compat?.supportsOpenAIGrammarTools ?? false);
             const cacheSessionId = options?.cacheRetention === "none" ? undefined : options?.sessionId;
             const codexSessionId = clampOpenAIPromptCacheKey(cacheSessionId);
@@ -226,7 +233,7 @@ export const stream = (model, context, options) => {
             const bodyJson = JSON.stringify(body);
             const httpTimeoutMs = normalizeTimeoutMs(options?.timeoutMs);
             const websocketConnectTimeoutMs = normalizeTimeoutMs(options?.websocketConnectTimeoutMs);
-            const transport = options?.transport || "auto";
+            const transport = transportAuth ? "sse" : options?.transport || "auto";
             let startEmitted = false;
             const websocketDisabledForSession = transport !== "sse" && isWebSocketSseFallbackActive(cacheSessionId);
             if (websocketDisabledForSession) {
@@ -413,13 +420,14 @@ export const stream = (model, context, options) => {
 };
 function buildSimpleCodexOptions(model, context, options) {
     const apiKey = options?.apiKey;
-    if (!apiKey) {
+    if (!apiKey && options?.authMode !== "transport") {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
     const base = buildBaseOptions(model, context, options, apiKey);
     const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
     return {
         ...base,
+        authMode: options?.authMode,
         reasoningEffort: clampedReasoning === "off" ? undefined : clampedReasoning,
         nativeCompactionCheckpoint: options?.nativeCompactionCheckpoint,
     };
@@ -427,12 +435,25 @@ 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) {
     const items = [];
-    const result = await stream(model, context, {
-        ...buildSimpleCodexOptions(model, context, options),
-        transport: "sse",
-        nativeCompaction: true,
-        onNativeCompactionItem: (item) => items.push(item),
-    }).result();
+    const base = buildSimpleCodexOptions(model, context, options);
+    let transport = base.transport;
+    const produce = () => {
+        items.length = 0;
+        return stream(model, context, {
+            ...base,
+            transport,
+            // Own one bounded stream retry budget; do not multiply HTTP retries.
+            maxRetries: 0,
+            nativeCompaction: true,
+            onNativeCompactionItem: (item) => items.push(item),
+        }).result();
+    };
+    const policy = { enabled: true, maxRetries: 2, baseDelayMs: BASE_DELAY_MS };
+    let result = await retryAssistantCall(produce, policy, options?.signal);
+    if (transport !== "sse" && base.authMode !== "transport" && isRetryableAssistantError(result)) {
+        transport = "sse";
+        result = await retryAssistantCall(produce, policy, options?.signal);
+    }
     if (result.stopReason !== "stop") {
         throw new OpenAICodexNativeCompactionError(result.errorMessage || `OpenAI native compaction did not complete (${result.stopReason})`, getOpenAICodexResponseFailure(result));
     }
@@ -443,13 +464,12 @@ export async function compactOpenAICodexResponses(model, context, options) {
     if (!isOpenAINativeCompactionItem(item)) {
         throw new Error("OpenAI native compaction returned a malformed checkpoint item");
     }
-    closeOpenAICodexWebSocketSessions(options?.sessionId);
     return {
-        item: {
-            type: "compaction",
-            encrypted_content: item.encrypted_content,
-            id: typeof item.id === "string" ? item.id : undefined,
-        },
+        item: { ...item },
+        retainedInput: retainCodexCompactionInput(buildRequestBody(model, {
+            ...context,
+            messages: (options?.nativeCompactionRetainedMessages ?? context.messages).filter((message) => message.role === "user"),
+        }, base, undefined).input ?? []),
         tokensBefore: result.usage.input + result.usage.cacheRead,
         usage: result.usage,
     };
@@ -461,7 +481,12 @@ function buildRequestBody(model, context, options, cacheSessionId, grammarToolIn
     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, {
+    const checkpoint = options?.nativeCompactionCheckpoint;
+    const checkpointInput = checkpoint ? [...(checkpoint.retainedInput ?? []), checkpoint.item] : [];
+    const requestContext = options?.nativeCompaction
+        ? trimCodexCompactionToolOutputs(context, checkpointInput, model.contextWindow)
+        : context;
+    const messages = convertResponsesMessages(model, requestContext, CODEX_TOOL_CALL_PROVIDERS, {
         includeSystemPrompt: false,
         grammarToolInputProperties,
         deferredTools: toolPlacement.deferred,
@@ -471,15 +496,16 @@ function buildRequestBody(model, context, options, cacheSessionId, grammarToolIn
             supportsOpenAIGrammarTools,
         },
     });
-    const checkpoint = options?.nativeCompactionCheckpoint;
     if (checkpoint) {
-        if (checkpoint.provider !== model.provider || checkpoint.modelId !== model.id) {
-            throw new Error(`OpenAI native compaction checkpoint requires ${checkpoint.provider}/${checkpoint.modelId}; current model is ${model.provider}/${model.id}`);
+        if (checkpoint.provider !== model.provider || model.api !== "openai-codex-responses") {
+            throw new Error(`OpenAI native compaction checkpoint requires the openai-codex Responses route; current model is ${model.provider}/${model.id}`);
         }
         if (!isOpenAINativeCompactionItem(checkpoint.item)) {
             throw new Error("Stored OpenAI native compaction checkpoint is malformed");
         }
-        messages.unshift({ ...checkpoint.item });
+        messages.unshift(...(checkpoint.retainedInput ?? []), {
+            ...checkpoint.item,
+        });
     }
     if (options?.nativeCompaction) {
         messages.push({ type: "compaction_trigger" });
@@ -1266,7 +1292,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), options?.onNativeCompactionItem), onStart), output, stream, model, {
             serviceTier: options?.serviceTier,
             grammarToolInputProperties,
             resolveServiceTier: resolveCodexServiceTier,
@@ -1275,6 +1301,10 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
         if (options?.signal?.aborted) {
             keepConnection = false;
         }
+        else if (options?.nativeCompaction && entry) {
+            // The rewritten history must be sent in full, but the connection stays reusable.
+            entry.continuation = undefined;
+        }
         else if (useCachedContext && entry && output.responseId) {
             const responseItems = convertResponsesMessages(model, { messages: [output] }, CODEX_TOOL_CALL_PROVIDERS, {
                 includeSystemPrompt: false,
@@ -1354,8 +1384,15 @@ function buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token)
             headers.set(key, value);
         }
     }
-    headers.set("Authorization", `Bearer ${token}`);
-    headers.set("chatgpt-account-id", accountId);
+    if (token && accountId) {
+        headers.set("Authorization", `Bearer ${token}`);
+        headers.set("chatgpt-account-id", accountId);
+    }
+    else {
+        // The custom transport supplies its own authentication, never a copied token.
+        headers.delete("Authorization");
+        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);