@code-yeongyu/senpi-ai 2026.9.30 → 2026.10.1

package/dist/api/mistral-conversations.js

@@ -5,6 +5,8 @@ import { headersToRecord } from "../utils/headers.js";
 import { parseStreamingJson } from "../utils/json-parse.js";
 import { getPiUserAgent } from "../utils/pi-user-agent.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
+import { getSystemMessageText, renderSystemMessageUpdate } from "../utils/text.js";
+import { getCurrentTools, resolveTranscript } from "../utils/transcript.js";
 import { getJsonSchemaToolParameters, resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
 import { applyExtraBody, buildBaseOptions, MISTRAL_RESERVED_BODY_KEYS } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
@@ -15,6 +17,7 @@ const MAX_MISTRAL_ERROR_BODY_CHARS = 4000;
  */
 export const stream = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
+    const normalizedContext = resolveTranscript(context, model.compat?.supportsMidConvoSystemMessages);
     (async () => {
         const output = createOutput(model);
         try {
@@ -23,18 +26,20 @@ export const stream = (model, context, options) => {
                 throw new Error(`No API key for provider: ${model.provider}`);
             }
             const normalizeMistralToolCallId = createMistralToolCallIdNormalizer();
-            const preserveThinking = options?.promptMode === "reasoning" || options?.reasoningEffort !== undefined;
-            const transformedMessages = transformMessages(context.messages, model, (id) => normalizeMistralToolCallId(id), {
+            // `reasoning_effort: "none"` is the thinking-off wire form for effort-mapped models, so it must not replay thinking.
+            const preserveThinking = options?.promptMode === "reasoning" ||
+                (options?.reasoningEffort !== undefined && options.reasoningEffort !== "none");
+            const transformedMessages = transformMessages(normalizedContext.messages, model, (id) => normalizeMistralToolCallId(id), {
                 preserveThinking,
             });
-            let payload = buildChatPayload(model, context, transformedMessages, options);
+            let payload = buildChatPayload(model, normalizedContext, transformedMessages, options);
             const nextPayload = await options?.onPayload?.(payload, model);
             if (nextPayload !== undefined) {
                 payload = nextPayload;
             }
             const mistralStream = await requestMistralStream(model, payload, apiKey, options);
             stream.push({ type: "start", partial: output });
-            await consumeChatStream(model, output, stream, mistralStream);
+            await consumeChatStream(model, output, stream, mistralStream, options?.onProviderStreamEvent);
             if (options?.signal?.aborted) {
                 throw new Error("Request was aborted");
             }
@@ -74,11 +79,17 @@ export const streamSimple = (model, context, options) => {
     };
     const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
     const reasoning = clampedReasoning === "off" ? undefined : clampedReasoning;
-    const shouldUseReasoning = model.reasoning && reasoning !== undefined;
+    // Models with a thinking level map use `reasoning_effort`; other reasoning models use `prompt_mode`.
+    const effortMap = model.reasoning ? model.thinkingLevelMap : undefined;
+    const reasoningEffort = effortMap
+        ? reasoning
+            ? (effortMap[reasoning] ?? "high")
+            : (effortMap.off ?? undefined)
+        : undefined;
     return stream(model, context, {
         ...base,
-        promptMode: shouldUseReasoning && usesPromptModeReasoning(model) ? "reasoning" : undefined,
-        reasoningEffort: shouldUseReasoning && usesReasoningEffort(model) ? mapReasoningEffort(model, reasoning) : undefined,
+        promptMode: model.reasoning && !effortMap && reasoning ? "reasoning" : undefined,
+        reasoningEffort: reasoningEffort,
     });
 };
 function createOutput(model) {
@@ -357,8 +368,9 @@ function buildChatPayload(model, context, messages, options) {
         stream: true,
         messages: toChatMessages(messages, model.input.includes("image")),
     };
-    if (context.tools?.length)
-        payload.tools = toFunctionTools(context.tools);
+    const currentTools = getCurrentTools(context.messages);
+    if (currentTools.length > 0)
+        payload.tools = toFunctionTools(currentTools);
     if (options?.temperature !== undefined)
         payload.temperature = options.temperature;
     if (options?.maxTokens !== undefined)
@@ -371,12 +383,6 @@ function buildChatPayload(model, context, messages, options) {
         payload.reasoningEffort = options.reasoningEffort;
     if (shouldUsePromptCaching(options))
         payload.promptCacheKey = options.sessionId;
-    if (context.systemPrompt) {
-        payload.messages.unshift({
-            role: "system",
-            content: sanitizeSurrogates(context.systemPrompt),
-        });
-    }
     applyExtraBody(payload, options?.extraBody, MISTRAL_RESERVED_BODY_KEYS);
     return payload;
 }
@@ -395,7 +401,7 @@ function getMistralCachedPromptTokens(usage, promptTokens) {
     const cachedTokens = typeof rawCachedTokens === "number" && Number.isFinite(rawCachedTokens) ? rawCachedTokens : 0;
     return Math.min(promptTokens, Math.max(0, cachedTokens));
 }
-async function consumeChatStream(model, output, stream, mistralStream) {
+async function consumeChatStream(model, output, stream, mistralStream, onProviderStreamEvent) {
     let currentBlock = null;
     const blocks = output.content;
     const blockIndex = () => blocks.length - 1;
@@ -423,6 +429,7 @@ async function consumeChatStream(model, output, stream, mistralStream) {
     };
     for await (const event of mistralStream) {
         const chunk = event.data;
+        await onProviderStreamEvent?.(chunk, model);
         // Mistral's streamed CompletionChunk carries an id field. Keep the first non-empty one,
         // mirroring how OpenAI-style streaming exposes a stable response identifier per stream.
         output.responseId ||= chunk.id;
@@ -455,6 +462,10 @@ async function consumeChatStream(model, output, stream, mistralStream) {
             for (const item of contentItems) {
                 if (typeof item === "string") {
                     const textDelta = sanitizeSurrogates(item);
+                    // GLM models on Mistral send empty content deltas around thinking and tool calls.
+                    // Opening a block for them splits thinking into multiple blocks, which Mistral rejects on replay.
+                    if (!textDelta)
+                        continue;
                     if (currentBlock?.type !== "text") {
                         finishCurrentBlock(currentBlock);
                         currentBlock = { type: "text", text: "" };
@@ -495,6 +506,8 @@ async function consumeChatStream(model, output, stream, mistralStream) {
                 }
                 if (item.type === "text") {
                     const textDelta = sanitizeSurrogates(item.text ?? "");
+                    if (!textDelta)
+                        continue;
                     if (currentBlock?.type !== "text") {
                         finishCurrentBlock(currentBlock);
                         currentBlock = { type: "text", text: "" };
@@ -601,9 +614,15 @@ function stripSymbolKeys(value) {
 }
 function toChatMessages(messages, supportsImages) {
     const result = [];
-    for (const msg of messages) {
+    for (const [index, msg] of messages.entries()) {
         if (msg.role === "configurationUpdate")
             continue;
+        if (msg.role === "system") {
+            const text = index === 0 ? getSystemMessageText(msg) : renderSystemMessageUpdate(msg);
+            if (text.length > 0)
+                result.push({ role: "system", content: sanitizeSurrogates(text) });
+            continue;
+        }
         if (msg.role === "user") {
             if (typeof msg.content === "string") {
                 result.push({ role: "user", content: sanitizeSurrogates(msg.content) });
@@ -708,18 +727,6 @@ function buildToolResultText(text, hasImages, supportsImages, isError) {
     }
     return isError ? "[tool error] (no tool output)" : "(no tool output)";
 }
-function usesReasoningEffort(model) {
-    return (model.id === "mistral-small-2603" ||
-        model.id === "mistral-small-latest" ||
-        model.id.startsWith("mistral-medium-") ||
-        model.id === "zai-glm-5-2");
-}
-function usesPromptModeReasoning(model) {
-    return model.reasoning && !usesReasoningEffort(model);
-}
-function mapReasoningEffort(model, level) {
-    return (model.thinkingLevelMap?.[level] ?? "high");
-}
 function mapToolChoice(choice) {
     if (!choice)
         return undefined;

package/dist/api/openai-codex-responses.d.ts

@@ -5,7 +5,7 @@ import { type CodexReasoningSummaryInput } from "./openai-codex-responses/reason
 export interface OpenAICodexResponsesOptions extends StreamOptions {
     reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
     reasoningSummary?: CodexReasoningSummaryInput;
-    serviceTier?: ResponseCreateParamsStreaming["service_tier"] | "fast";
+    serviceTier?: ResponseCreateParamsStreaming["service_tier"] | "fast" | "ultrafast";
     textVerbosity?: "low" | "medium" | "high";
     toolChoice?: "auto" | "none" | "required";
 }

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

@@ -11,19 +11,20 @@ import { clampThinkingLevel, supportsMax, supportsXhigh } from "../models.js";
 import { registerSessionResourceCleanup } from "../session-resources.js";
 import { combineAbortSignals } from "../utils/abort-signals.js";
 import { extractChatGptSubscriptionAccountId } from "../utils/chatgpt-subscription-auth.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 { appendRetryAfterMsMarker, extract429RetryAfterMs } from "../utils/retry-hint.js";
+import { getSystemMessageText } from "../utils/text.js";
+import { getDeclaredTools, getInitialSystemMessage, normalizeContext, resolveTranscript } from "../utils/transcript.js";
 import { uuidv7 } from "../utils/uuid.js";
 import { createGrammarToolInputProperties } from "./constrained-sampling.js";
 import { clearWebSocketFallbackState, getOrCreateWebSocketDebugStats, getWebSocketDebugStats, isWebSocketSseFallbackActive, recordWebSocketFailure, recordWebSocketSseFallback, } from "./openai-codex-responses/fallback-state.js";
 import { buildCodexReasoning } from "./openai-codex-responses/reasoning.js";
 import { applyChatGptSubscriptionCacheAffinityHeaders, clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
-import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
+import { convertResponsesMessages, convertResponsesTools, processResponsesStream, resolveResponsesDeferredToolsMode, resolveResponsesToolPlacement, } from "./openai-responses-shared.js";
 import { applyExtraBody, buildBaseOptions, clampMaxForOpenAI, OPENAI_RESPONSES_RESERVED_BODY_KEYS, } from "./simple-options.js";
 import { startWebSocketLiveness } from "./websocket-liveness.js";
 import { createWebSocketTransportFailure } from "./websocket-transport-failure.js";
@@ -137,6 +138,7 @@ function copyBytesToArrayBuffer(bytes) {
 // ============================================================================
 export const stream = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
+    const normalizedContext = resolveTranscript(context, model.compat?.supportsMidConvoSystemMessages);
     (async () => {
         const output = {
             role: "assistant",
@@ -161,17 +163,18 @@ 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;
             }
             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 routingHint = buildCodexRoutingHint(body.model, body.service_tier);
+            const sseHeaders = buildSSEHeaders(model.headers, options?.headers, accountId, apiKey, routingHint, codexSessionId);
+            const websocketHeaders = buildWebSocketHeaders(model.headers, options?.headers, accountId, apiKey, routingHint, websocketRequestId);
             const bodyJson = JSON.stringify(body);
             const httpTimeoutMs = normalizeTimeoutMs(options?.timeoutMs);
             const websocketConnectTimeoutMs = normalizeTimeoutMs(options?.websocketConnectTimeoutMs);
@@ -224,7 +227,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,
@@ -387,7 +390,7 @@ 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 requestedReasoningEffort = options?.reasoningEffort;
     const mappedReasoningEffort = requestedReasoningEffort === undefined
         ? undefined
@@ -398,30 +401,26 @@ function buildRequestBody(model, context, options, cacheSessionId, grammarToolIn
     const reasoningRequested = requestedReasoningEffort !== undefined && requestedReasoningEffort !== "none" && reasoningEffort !== null;
     const supportsStrictMode = model.compat?.supportsStrictMode ?? true;
     const supportsOpenAIGrammarTools = model.compat?.supportsOpenAIGrammarTools ?? false;
-    const deferredToolsMode = model.compat?.supportsAdditionalTools
-        ? "additional-tools"
-        : model.compat?.supportsToolSearch
-            ? "tool-search"
-            : undefined;
-    const toolPlacement = splitDeferredTools(context, deferredToolsMode !== undefined);
+    const supportsAdditionalTools = model.compat?.supportsAdditionalTools ?? false;
+    const supportsToolSearch = model.compat?.supportsToolSearch ?? false;
+    const toolPlacement = resolveResponsesToolPlacement(context.messages, resolveResponsesDeferredToolsMode(model.compat) !== undefined);
     const messages = convertResponsesMessages(model, context, CODEX_TOOL_CALL_PROVIDERS, {
         includeSystemPrompt: false,
         preserveThinking: reasoningRequested,
         preserveTextSignatures: true,
         grammarToolInputProperties,
-        deferredTools: toolPlacement.deferred,
-        deferredToolsMode,
-        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"],
@@ -435,8 +434,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 (toolPlacement.requestTools.length > 0) {
+        body.tools = convertResponsesTools(toolPlacement.requestTools, {
             strict: null,
             supportsStrictMode,
             supportsOpenAIGrammarTools,
@@ -450,6 +449,10 @@ function buildRequestBody(model, context, options, cacheSessionId, grammarToolIn
 }
 function getServiceTierCostMultiplier(model, serviceTier) {
     switch (serviceTier) {
+        case "ultrafast":
+            // OpenAI publishes an Ultrafast price for GPT-6 Astra only: 6x Standard on every
+            // token class and context tier. Any other model keeps its base rate.
+            return model.id === "gpt-6-astra" ? 6 : 1;
         case "flex":
             return 0.5;
         case "priority":
@@ -471,7 +474,10 @@ function applyServiceTierPricing(usage, serviceTier, model) {
 }
 function resolveCodexServiceTier(responseServiceTier, requestServiceTier) {
     if (responseServiceTier === "default" &&
-        (requestServiceTier === "flex" || requestServiceTier === "priority" || requestServiceTier === "fast")) {
+        (requestServiceTier === "flex" ||
+            requestServiceTier === "priority" ||
+            requestServiceTier === "fast" ||
+            requestServiceTier === "ultrafast")) {
         return requestServiceTier;
     }
     return responseServiceTier ?? requestServiceTier;
@@ -497,7 +503,7 @@ function resolveCodexWebSocketUrl(baseUrl) {
 // Response Processing
 // ============================================================================
 async function processStream(response, output, stream, model, grammarToolInputProperties, options) {
-    await processResponsesStream(mapCodexEvents(parseSSE(response, options?.signal), output), output, stream, model, {
+    await processResponsesStream(mapCodexEvents(parseSSE(response, options?.signal), output, model, options?.onProviderStreamEvent), output, stream, model, {
         serviceTier: options?.serviceTier,
         grammarToolInputProperties,
         resolveServiceTier: resolveCodexServiceTier,
@@ -521,8 +527,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 asRecord(value) {
     return value && typeof value === "object" ? value : null;
@@ -554,8 +569,15 @@ function isPreviousResponseNotFoundError(error) {
 function isWebSocketConnectionLimitReachedError(error) {
     return error instanceof CodexApiError && error.code === WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE;
 }
-async function* mapCodexEvents(events, output) {
+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;
@@ -897,7 +919,15 @@ async function acquireWebSocket(url, headers, sessionId, accountId, signal, conn
         };
     }
     let accountEntries = websocketSessionCache.get(sessionId);
-    const cached = accountEntries?.get(accountId);
+    let cached = accountEntries?.get(accountId);
+    const routingHint = headers.get("x-codex-routing-hint");
+    if (cached && cached.routingHint !== routingHint) {
+        closeWebSocketSilently(cached.socket, 1000, "routing_hint_changed");
+        accountEntries?.delete(accountId);
+        if (accountEntries?.size === 0)
+            websocketSessionCache.delete(sessionId);
+        cached = undefined;
+    }
     if (cached) {
         unparkSessionWebSocket(cached);
         if (!cached.busy && isWebSocketSessionExpired(cached)) {
@@ -944,7 +974,7 @@ async function acquireWebSocket(url, headers, sessionId, accountId, signal, conn
         }
     }
     const socket = await connectWebSocket(url, headers, signal, connectTimeoutMs, env);
-    const entry = { socket, busy: true, createdAt: Date.now() };
+    const entry = { socket, busy: true, createdAt: Date.now(), routingHint };
     accountEntries = websocketSessionCache.get(sessionId);
     if (!accountEntries) {
         accountEntries = new Map();
@@ -1199,7 +1229,7 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
             recordWebSocketRequestStats(stats, requestBody, reused && !recoveredStalePreviousResponse, useCachedContext);
             try {
                 socket.send(JSON.stringify({ type: "response.create", ...requestBody }));
-                await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal, idleTimeoutMs), output), 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,
@@ -1225,7 +1255,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");
@@ -1279,7 +1309,11 @@ async function parseErrorResponse(response) {
 function extractAccountId(token) {
     return extractChatGptSubscriptionAccountId(token);
 }
-function buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token) {
+/** codex's `x-codex-routing-hint`: `model=<id>`, plus `;tier=<tier>` when the request names a service tier. */
+function buildCodexRoutingHint(modelId, serviceTier) {
+    return serviceTier ? `model=${modelId};tier=${serviceTier}` : `model=${modelId}`;
+}
+function buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token, routingHint) {
     const headers = new Headers(initHeaders);
     for (const [key, value] of Object.entries(additionalHeaders || {})) {
         if (value === null) {
@@ -1300,18 +1334,19 @@ function buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token)
     headers.set("originator", identity);
     const userAgent = _os ? `${identity} (${_os.platform()} ${_os.release()}; ${_os.arch()})` : `${identity} (browser)`;
     headers.set("User-Agent", userAgent);
+    headers.set("x-codex-routing-hint", routingHint);
     return headers;
 }
-function buildSSEHeaders(initHeaders, additionalHeaders, accountId, token, sessionId) {
-    const headers = buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token);
+function buildSSEHeaders(initHeaders, additionalHeaders, accountId, token, routingHint, sessionId) {
+    const headers = buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token, routingHint);
     headers.set("OpenAI-Beta", "responses=experimental");
     headers.set("accept", "text/event-stream");
     headers.set("content-type", "application/json");
     applyChatGptSubscriptionCacheAffinityHeaders(headers, sessionId);
     return headers;
 }
-function buildWebSocketHeaders(initHeaders, additionalHeaders, accountId, token, requestId) {
-    const headers = buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token);
+function buildWebSocketHeaders(initHeaders, additionalHeaders, accountId, token, routingHint, requestId) {
+    const headers = buildBaseCodexHeaders(initHeaders, additionalHeaders, accountId, token, routingHint);
     headers.delete("accept");
     headers.delete("content-type");
     headers.delete("OpenAI-Beta");

package/dist/api/openai-completions.d.ts

@@ -1,7 +1,8 @@
 import OpenAI from "openai";
 import type { ChatCompletionMessageParam } from "openai/resources/chat/completions.js";
-import type { Context, Model, SimpleStreamOptions, StreamFunction, StreamOptions, ThinkingBudgets } from "../types.ts";
+import type { Model, SimpleStreamOptions, StreamFunction, StreamOptions, ThinkingBudgets } from "../types.ts";
 import { type ResolvedOpenAICompletionsCompat } from "../utils/prompt-cache-ttl.ts";
+import { type TranscriptContext } from "../utils/transcript.ts";
 export { getOpenAICompletionsCompat as getCompat, type ResolvedOpenAICompletionsCompat, } from "../utils/prompt-cache-ttl.ts";
 export interface OpenAICompletionsOptions extends StreamOptions {
     toolChoice?: OpenAI.Chat.Completions.ChatCompletionToolChoiceOption;
@@ -15,5 +16,5 @@ export interface ConvertCompletionsMessagesOptions {
 }
 export declare const stream: StreamFunction<"openai-completions", OpenAICompletionsOptions>;
 export declare const streamSimple: StreamFunction<"openai-completions", SimpleStreamOptions>;
-export declare function convertMessages(model: Model<"openai-completions">, context: Context, compat: ResolvedOpenAICompletionsCompat, options?: ConvertCompletionsMessagesOptions): ChatCompletionMessageParam[];
+export declare function convertMessages(model: Model<"openai-completions">, context: TranscriptContext, compat: ResolvedOpenAICompletionsCompat, options?: ConvertCompletionsMessagesOptions): ChatCompletionMessageParam[];
 //# sourceMappingURL=openai-completions.d.ts.map