@giovannijecha/jecode 0.8.4 → 0.8.6

package/dist/providers/ollama.js

@@ -1,186 +1,64 @@
-// Ollama, spoken through its OpenAI-compatible Chat Completions endpoint.
-//
-// One provider covers both deployments. An explicit session endpoint wins;
-// otherwise a configured key selects Ollama Cloud and no key selects the local
-// daemon. There is no default model — the catalogue is whatever the host has
-// pulled or the subscription grants — so the model has to be named with
-// --model.
+// Ollama Cloud through its OpenAI-compatible streaming Chat Completions API.
 import { requireSupportedEffort } from "../effort.js";
-import { getJson, postJson, postSse } from "./http.js";
+import { postSse } from "./http.js";
 import { listModels } from "./catalog.js";
 import { keyFor } from "../credentials.js";
 import { assembleOllama } from "./ollama-stream.js";
-import { OLLAMA_CLOUD_HOST, OLLAMA_LOCAL_HOST, ollamaConnectionKind, parseOllamaEndpoint, } from "./ollama-endpoint.js";
+import { ollamaContextWindow } from "./ollama-context.js";
+import { isRetryableGenerationFailure, isRetryableReadFailure, throwProviderError, } from "./failure.js";
+import { OLLAMA_CLOUD_HOST } from "./ollama-endpoint.js";
 import { fromWireReply, stopNotice, toWireMessages, toWireTool } from "./ollama-wire.js";
 const KEY = "OLLAMA_API_KEY";
+const ID = "ollama";
 // Ollama also accepts `none`; Jecode's product-wide reasoning floor is `low`.
 const OLLAMA_EFFORTS = ["low", "medium", "high"];
-let configuredHost;
-const CONTEXT_CACHE_MS = 30_000;
-const runtimeContextByEndpoint = new Map();
-const modelContextByEndpoint = new Map();
-/** Set the endpoint selected for this process. Undefined restores key-aware inference. */
-export function configureOllama(host) {
-    configuredHost = host === undefined ? undefined : parseOllamaEndpoint(host).baseUrl;
-}
-export function ollamaConnection() {
-    const inferred = configuredHost === undefined;
-    const endpoint = parseOllamaEndpoint(configuredHost ?? (apiKey() === undefined ? OLLAMA_LOCAL_HOST : OLLAMA_CLOUD_HOST));
-    return { ...endpoint, kind: ollamaConnectionKind(endpoint), inferred };
-}
 export const ollama = {
-    id: "ollama",
+    id: ID,
     defaultModel: "",
     auth: { kind: "api-key", keyVar: KEY },
-    // The only provider whose key is conditional: a daemon on this machine is
-    // reached over loopback and asks for nothing, so demanding a key there
-    // would be an invented requirement.
     blocked() {
+        return keyFor(KEY) === undefined ? `${KEY} is not set` : undefined;
+    },
+    async models(signal, onStatus) {
         try {
-            const at = endpoint();
-            if (apiKey() !== undefined || at.loopback)
-                return undefined;
-            return `${KEY} is not set (required by ${at.baseUrl})`;
+            return await listModels(`${OLLAMA_CLOUD_HOST}/v1/models`, headers(), signal, onStatus, (error) => isRetryableReadFailure(ID, error));
         }
         catch (error) {
-            return error.message;
+            throwProviderError(ID, signal, error);
         }
     },
-    // Whatever the daemon has pulled, or whatever the subscription grants.
-    models(signal, onStatus) {
-        const at = endpoint();
-        return listModels(`${at.baseUrl}/v1/models`, headers(at), signal, onStatus);
-    },
     async efforts() {
         return OLLAMA_EFFORTS;
     },
     async contextWindow(model, signal, onStatus) {
-        const at = endpoint();
-        const cacheKey = `${at.baseUrl}\u0000${model}`;
-        const runtime = cachedContext(runtimeContextByEndpoint, cacheKey);
-        if (runtime !== undefined)
-            return runtime;
-        const modelCapacity = cachedContext(modelContextByEndpoint, cacheKey);
-        const observed = await nativeContextWindow(at, model, modelCapacity, signal, onStatus);
-        if (observed?.runtime === true) {
-            rememberContext(runtimeContextByEndpoint, cacheKey, observed.value);
-        }
-        else if (observed !== undefined && modelCapacity === undefined) {
-            rememberContext(modelContextByEndpoint, cacheKey, observed.value);
-        }
-        return observed?.value;
+        return ollamaContextWindow(model, headers(), signal, onStatus);
     },
-    location: () => {
+    async send(req) {
+        const effort = requireSupportedEffort(req.model, req.effort, OLLAMA_EFFORTS);
         try {
-            return endpoint().loopback ? "local" : "cloud";
+            const events = await postSse(`${OLLAMA_CLOUD_HOST}/v1/chat/completions`, headers(), {
+                model: req.model,
+                messages: toWireMessages(req.system, req.messages),
+                tools: req.tools.map(toWireTool),
+                max_tokens: req.maxTokens,
+                reasoning_effort: effort,
+                stream: true,
+                stream_options: { include_usage: true },
+            }, req.maxTokens, req.signal, req.onStatus, undefined, (error) => isRetryableGenerationFailure(ID, error));
+            const reply = await assembleOllama(events, req.onStream);
+            const notice = stopNotice(reply);
+            if (notice !== undefined)
+                req.onStream?.({ kind: "text", text: `\n${notice}` });
+            return fromWireReply(reply);
         }
-        catch {
-            return "cloud";
+        catch (error) {
+            throwProviderError(ID, req.signal, error);
         }
     },
-    async send(req) {
-        const at = endpoint();
-        const effort = requireSupportedEffort(req.model, req.effort, OLLAMA_EFFORTS);
-        // The OpenAI-compatible endpoint accepts this vocabulary for thinking
-        // models. Invalid levels are rejected locally instead of being rewritten.
-        const events = await postSse(`${at.baseUrl}/v1/chat/completions`, headers(at), {
-            model: req.model,
-            messages: toWireMessages(req.system, req.messages),
-            tools: req.tools.map(toWireTool),
-            max_tokens: req.maxTokens,
-            reasoning_effort: effort,
-            stream: true,
-            stream_options: { include_usage: true },
-        }, req.maxTokens, req.signal, req.onStatus);
-        const reply = await assembleOllama(events, req.onStream);
-        const notice = stopNotice(reply);
-        if (notice !== undefined)
-            req.onStream?.({ kind: "text", text: `\n${notice}` });
-        return fromWireReply(reply);
-    },
 };
-async function nativeContextWindow(at, model, fallback, signal, onStatus) {
-    try {
-        const running = await getJson(`${at.baseUrl}/api/ps`, headers(at), signal, onStatus);
-        const allocated = runningContext(running, model);
-        if (allocated !== undefined)
-            return { value: usableContext(allocated), runtime: true };
-    }
-    catch (error) {
-        throwIfAborted(signal, error);
-    }
-    if (fallback !== undefined)
-        return { value: fallback, runtime: false };
-    try {
-        const details = await postJson(`${at.baseUrl}/api/show`, headers(at), { model }, signal, onStatus);
-        const capacity = modelCapacity(details);
-        return capacity === undefined
-            ? undefined
-            : { value: usableContext(capacity), runtime: false };
-    }
-    catch (error) {
-        throwIfAborted(signal, error);
-        return undefined;
-    }
-}
-function cachedContext(cache, key) {
-    const cached = cache.get(key);
-    if (cached === undefined)
-        return undefined;
-    if (cached.expiresAt > Date.now())
-        return cached.value;
-    cache.delete(key);
-    return undefined;
-}
-function rememberContext(cache, key, value) {
-    cache.set(key, { value, expiresAt: Date.now() + CONTEXT_CACHE_MS });
-}
-function runningContext(value, model) {
-    if (!record(value) || !Array.isArray(value["models"]))
-        return undefined;
-    for (const entry of value["models"]) {
-        if (!record(entry))
-            continue;
-        if (entry["name"] !== model && entry["model"] !== model)
-            continue;
-        if (validTokenCount(entry["context_length"]))
-            return entry["context_length"];
-    }
-    return undefined;
-}
-function modelCapacity(value) {
-    if (!record(value) || !record(value["model_info"]))
-        return undefined;
-    const capacities = Object.entries(value["model_info"])
-        .filter(([name, count]) => name.endsWith(".context_length") && validTokenCount(count))
-        .map(([, count]) => count);
-    return capacities.length === 0 ? undefined : Math.max(...capacities);
-}
-function validTokenCount(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) &&
-        value >= 4_096 && value <= 10_000_000;
-}
-function usableContext(tokens) {
-    return Object.freeze({ tokens: Math.floor(tokens * 95 / 100) });
-}
-function record(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function throwIfAborted(signal, error) {
-    if (signal?.aborted === true)
-        throw error;
-}
-function endpoint() {
-    return ollamaConnection();
-}
-function apiKey() {
-    return keyFor(KEY);
-}
-function headers(at) {
-    if (at.loopback)
-        return {};
-    const key = apiKey();
-    if (key !== undefined)
-        return { authorization: `Bearer ${key}` };
-    throw new Error(`${KEY} is not set (required by ${at.baseUrl})`);
+function headers() {
+    const key = keyFor(KEY);
+    if (key === undefined)
+        throw new Error(`${KEY} is not set`);
+    return { authorization: `Bearer ${key}` };
 }

package/dist/providers/openai-codex.js

@@ -2,10 +2,12 @@
 import { randomUUID } from "node:crypto";
 import { openAICodexAccount } from "../accounts.js";
 import { openAIAuthorization } from "../openai-account.js";
+import { providerLabel } from "../provider-label.js";
 import { applicationVersion } from "../version.js";
 import { EFFORTS, isEffort, requireSupportedEffort } from "../effort.js";
+import { isRetryableGenerationFailure, isRetryableReadFailure, throwProviderError, } from "./failure.js";
 import { getJson, postSse } from "./http.js";
-import { assembleOpenAI } from "./openai-stream.js";
+import { assembleOpenAI, openAIStreamProgress } from "./openai-stream.js";
 import { fromWireResponse, stopNotice, toWireItems, toWireTool, } from "./openai-wire.js";
 const ID = "openai-codex";
 const BASE = "https://chatgpt.com/backend-api/codex";
@@ -13,7 +15,6 @@ const BASE = "https://chatgpt.com/backend-api/codex";
 // own catalogue updater uses this sentinel to request the complete current
 // manifest; Jecode then keeps only entries explicitly visible in that manifest.
 const CATALOG_COMPATIBILITY_VERSION = "99.99.99";
-const SESSION_ID = randomUUID();
 const MAX_CATALOG_ITEMS = 4_000;
 const MAX_MODELS = 1_000;
 const MAX_MODEL_CHARS = 256;
@@ -23,66 +24,89 @@ let contextByModel = new Map();
 export const openaiCodex = {
     id: ID,
     defaultModel: "",
-    auth: { kind: "oauth", account: ID, label: "ChatGPT" },
+    auth: { kind: "oauth", account: ID, label: providerLabel(ID) },
     blocked() {
-        return openAICodexAccount() === undefined ? "ChatGPT account is not connected" : undefined;
+        return openAICodexAccount() === undefined ? `${providerLabel(ID)} is not connected` : undefined;
     },
-    location: () => "cloud",
     async models(signal, onStatus) {
-        const catalog = await loadCatalog(signal, onStatus);
-        rememberCatalog(catalog);
-        return catalog.ids;
+        try {
+            const catalog = await loadCatalog(signal, onStatus);
+            rememberCatalog(catalog);
+            return catalog.ids;
+        }
+        catch (error) {
+            throwProviderError(ID, signal, error);
+        }
     },
     async efforts(model, signal, onStatus) {
         const cached = effortByModel.get(model);
         if (cached !== undefined)
             return cached;
-        const catalog = await loadCatalog(signal, onStatus);
-        rememberCatalog(catalog);
-        return effortByModel.get(model) ?? fallbackEfforts(model);
+        try {
+            const catalog = await loadCatalog(signal, onStatus);
+            rememberCatalog(catalog);
+            return effortByModel.get(model) ?? fallbackEfforts(model);
+        }
+        catch (error) {
+            throwProviderError(ID, signal, error);
+        }
     },
     async contextWindow(model, signal, onStatus) {
         if (contextByModel.has(model))
             return contextByModel.get(model);
-        const catalog = await loadCatalog(signal, onStatus);
-        rememberCatalog(catalog);
-        const context = contextByModel.get(model);
-        if (!contextByModel.has(model))
-            contextByModel.set(model, undefined);
-        return context;
+        try {
+            const catalog = await loadCatalog(signal, onStatus);
+            rememberCatalog(catalog);
+            const context = contextByModel.get(model);
+            if (!contextByModel.has(model))
+                contextByModel.set(model, undefined);
+            return context;
+        }
+        catch (error) {
+            throwProviderError(ID, signal, error);
+        }
     },
     async send(req) {
         const efforts = effortByModel.get(req.model) ?? fallbackEfforts(req.model);
         const effort = requireSupportedEffort(req.model, req.effort, efforts);
-        return withAuthorization(async (authorization) => {
-            const events = await postSse(`${BASE}/responses`, {
-                ...headers(authorization, randomUUID()),
-                "openai-beta": "responses=experimental",
-            }, {
-                model: req.model,
-                store: false,
-                stream: true,
-                instructions: req.system,
-                input: req.messages.flatMap((message) => toWireItems(message, ID)),
-                tools: req.tools.map(toWireTool),
-                tool_choice: "auto",
-                parallel_tool_calls: true,
-                reasoning: { effort, summary: "auto" },
-                text: { verbosity: "low" },
-                include: ["reasoning.encrypted_content"],
-                prompt_cache_key: SESSION_ID,
-            }, req.maxTokens, req.signal, req.onStatus);
-            const data = await assembleOpenAI(events, req.onStream, req.onStatus);
-            const notice = stopNotice(data);
-            if (notice !== undefined)
-                req.onStream?.({ kind: "text", text: `\n${notice}` });
-            return fromWireResponse(data, ID);
-        }, req.signal, req.onStatus);
+        const sessionId = req.identity?.conversationId ?? randomUUID();
+        const cacheKey = req.identity?.cacheKey ?? sessionId;
+        try {
+            return await withAuthorization(async (authorization) => {
+                const events = await postSse(`${BASE}/responses`, {
+                    ...headers(authorization, sessionId, randomUUID()),
+                    "openai-beta": "responses=experimental",
+                }, {
+                    model: req.model,
+                    store: false,
+                    stream: true,
+                    instructions: req.system,
+                    input: req.messages.flatMap((message) => toWireItems(message, ID)),
+                    tools: req.tools.map(toWireTool),
+                    tool_choice: "auto",
+                    parallel_tool_calls: true,
+                    reasoning: { effort, summary: "auto" },
+                    text: { verbosity: "low" },
+                    include: ["reasoning.encrypted_content"],
+                    ...(req.identity?.purpose === "compaction"
+                        ? {}
+                        : { prompt_cache_key: cacheKey }),
+                }, req.maxTokens, req.signal, req.onStatus, openAIStreamProgress, (error) => isRetryableGenerationFailure(ID, error));
+                const data = await assembleOpenAI(events, req.onStream, req.onStatus);
+                const notice = stopNotice(data);
+                if (notice !== undefined)
+                    req.onStream?.({ kind: "text", text: `\n${notice}` });
+                return fromWireResponse(data, ID);
+            }, req.signal, req.onStatus);
+        }
+        catch (error) {
+            throwProviderError(ID, req.signal, error);
+        }
     },
 };
 async function loadCatalog(signal, onStatus) {
     return withAuthorization(async (authorization) => {
-        const body = await getJson(`${BASE}/models?client_version=${CATALOG_COMPATIBILITY_VERSION}`, headers(authorization, randomUUID()), signal, onStatus);
+        const body = await getJson(`${BASE}/models?client_version=${CATALOG_COMPATIBILITY_VERSION}`, headers(authorization, randomUUID(), randomUUID()), signal, onStatus, (error) => isRetryableReadFailure(ID, error));
         return modelCatalog(body);
     }, signal, onStatus);
 }
@@ -102,21 +126,21 @@ async function withAuthorization(operation, signal, onStatus) {
         return operation(authorization);
     }
 }
-function headers(authorization, requestId) {
+function headers(authorization, sessionId, requestId) {
     const version = applicationVersion();
     return {
         authorization: `Bearer ${authorization.accessToken}`,
         "chatgpt-account-id": authorization.accountId,
         originator: "jecode",
         "user-agent": `jecode/${version} (${process.platform}; ${process.arch})`,
-        "session-id": SESSION_ID,
+        "session-id": sessionId,
         "x-client-request-id": requestId,
     };
 }
 function modelCatalog(value) {
     const source = record(value) && Array.isArray(value["models"]) ? value["models"] : undefined;
     if (source === undefined)
-        throw new Error("OpenAI Codex did not return a model list");
+        throw new Error(`${providerLabel(ID)} did not return a model list`);
     const seen = new Set();
     const models = source
         .slice(0, MAX_CATALOG_ITEMS)
@@ -185,6 +209,8 @@ function reasoningLevels(entry, model) {
     return efforts.length === 0 ? fallbackEfforts(model) : efforts;
 }
 function fallbackEfforts(model) {
+    if (/^gpt-6-astra(?:-|$)/.test(model))
+        return EFFORTS;
     if (/^gpt-5\.6-(?:sol|terra|luna)(?:-|$)/.test(model))
         return EFFORTS;
     return XHIGH_EFFORTS;

package/dist/providers/openai-stream.js

@@ -4,6 +4,7 @@
 // response in `response.completed`. The ChatGPT Codex backend can instead send
 // an empty final `output` after complete `response.output_item.done` events, so
 // those streamed items remain the fallback when the final envelope is empty.
+import { providerWireError } from "./failure.js";
 export async function assembleOpenAI(events, onStream, onStatus) {
     const items = [];
     const announcedTools = { identities: new Set(), anonymous: false };
@@ -69,6 +70,9 @@ export async function assembleOpenAI(events, onStream, onStatus) {
                     if (isFunctionCall(event.item)) {
                         announceTool(event, event.item, announcedTools, onStream, status);
                     }
+                    else if (itemType(event.item) === "reasoning") {
+                        status("Working");
+                    }
                     items.push(event.item);
                 }
                 break;
@@ -82,16 +86,36 @@ export async function assembleOpenAI(events, onStream, onStatus) {
                 };
             case "response.failed": {
                 const response = event.response;
-                throw new Error(`openai stream error: ${response?.error?.message ?? "unspecified"}`);
+                throw providerWireError("openai stream error", response?.error?.message, {
+                    code: response?.error?.code,
+                    type: response?.error?.type,
+                });
             }
             case "error":
-                throw new Error(`openai stream error: ${event.error?.message ?? event.message ?? "unspecified"}`);
+                throw providerWireError("openai stream error", event.error?.message ?? event.message, { code: event.error?.code, type: event.error?.type });
             default:
                 break;
         }
     }
     throw new Error("openai stream ended before a terminal response event");
 }
+/** State-only keepalives prove transport liveness, not forward model progress. */
+export function openAIStreamProgress(raw) {
+    if (typeof raw !== "object" || raw === null)
+        return false;
+    const type = raw["type"];
+    if (typeof type !== "string")
+        return false;
+    if (type === "response.created")
+        return true;
+    if (type === "response.done" ||
+        type === "response.completed" ||
+        type === "response.incomplete" ||
+        type === "response.failed" ||
+        type === "error")
+        return true;
+    return /\.(?:added|delta|done)$/u.test(type);
+}
 function isFunctionCall(item) {
     return typeof item === "object" && item !== null &&
         item["type"] === "function_call";

package/dist/providers/openai.js

@@ -2,15 +2,20 @@
 //
 // Responses wire contract verified against the official API reference on
 // 2026-08-29. Keep final response events authoritative over display deltas.
+import { randomUUID } from "node:crypto";
+import { applicationVersion } from "../version.js";
 import { postSse } from "./http.js";
 import { listModels } from "./catalog.js";
 import { keyFor } from "../credentials.js";
 import { EFFORTS, requireSupportedEffort } from "../effort.js";
-import { assembleOpenAI } from "./openai-stream.js";
+import { isRetryableGenerationFailure, isRetryableReadFailure, throwProviderError, } from "./failure.js";
+import { assembleOpenAI, openAIStreamProgress } from "./openai-stream.js";
 import { fromWireResponse, stopNotice, toWireItems, toWireTool, } from "./openai-wire.js";
 const ENDPOINT = "https://api.openai.com/v1/responses";
 const MODELS = "https://api.openai.com/v1/models";
 const KEY = "OPENAI_API_KEY";
+const ID = "openai";
+const ASTRA_MODEL = /^gpt-6-astra(?:-|$)/;
 const RESPONSES_REASONING_MODEL = /^(?:gpt-5(?:[.-]|$)|o(?:1|3|4)(?:[.-]|$)|codex-mini(?:[.-]|$))/;
 // Jecode's transport always streams and always declares local tools. Hide
 // catalog entries that cannot satisfy either half of that contract.
@@ -20,11 +25,14 @@ const XHIGH_EFFORTS = ["low", "medium", "high", "xhigh"];
 const PRO_EFFORTS = ["medium", "high", "xhigh"];
 const HIGH_ONLY_EFFORT = ["high"];
 export function supportsOpenAIModel(model) {
-    return RESPONSES_REASONING_MODEL.test(model) && !INCOMPATIBLE_MODEL.test(model);
+    return ASTRA_MODEL.test(model) ||
+        (RESPONSES_REASONING_MODEL.test(model) && !INCOMPATIBLE_MODEL.test(model));
 }
 export function openAIEfforts(model) {
     if (!supportsOpenAIModel(model))
         return [];
+    if (ASTRA_MODEL.test(model))
+        return EFFORTS;
     if (/^gpt-5-pro(?:-|$)/.test(model))
         return HIGH_ONLY_EFFORT;
     if (/^gpt-5\.[2-5]-pro(?:-|$)/.test(model))
@@ -39,6 +47,8 @@ export function openAIEfforts(model) {
 }
 /** Conservative capacities for the reasoning families accepted by this transport. */
 export function openAIContextWindow(model) {
+    if (ASTRA_MODEL.test(model))
+        return usableContext(1_050_000);
     if (/^gpt-5\.6(?:[.-]|$)/.test(model))
         return usableContext(1_050_000);
     if (/^gpt-5(?:[.-]|$)/.test(model))
@@ -52,7 +62,7 @@ function usableContext(tokens) {
     return Object.freeze({ tokens: Math.floor(tokens * 95 / 100) });
 }
 export const openai = {
-    id: "openai",
+    id: ID,
     defaultModel: "gpt-5",
     auth: { kind: "api-key", keyVar: KEY },
     blocked() {
@@ -61,10 +71,15 @@ export const openai = {
     // The endpoint answers in no order worth keeping, so descending puts the
     // highest-numbered family — usually the newest — at the top of the menu.
     async models(signal, onStatus) {
-        const ids = await listModels(MODELS, headers(requireKey()), signal, onStatus);
-        return ids
-            .filter(supportsOpenAIModel)
-            .sort((a, b) => b.localeCompare(a));
+        try {
+            const ids = await listModels(MODELS, headers(requireKey()), signal, onStatus, (error) => isRetryableReadFailure(ID, error));
+            return ids
+                .filter(supportsOpenAIModel)
+                .sort((a, b) => b.localeCompare(a));
+        }
+        catch (error) {
+            throwProviderError(ID, signal, error);
+        }
     },
     async efforts(model) {
         return openAIEfforts(model);
@@ -72,26 +87,33 @@ export const openai = {
     async contextWindow(model) {
         return openAIContextWindow(model);
     },
-    location: () => "cloud",
     async send(req) {
         const key = requireKey();
         const effort = requireSupportedEffort(req.model, req.effort, openAIEfforts(req.model));
-        const events = await postSse(ENDPOINT, headers(key), {
-            model: req.model,
-            instructions: req.system,
-            input: req.messages.flatMap((message) => toWireItems(message)),
-            tools: req.tools.map(toWireTool),
-            max_output_tokens: req.maxTokens,
-            reasoning: { effort, summary: "auto" },
-            store: false,
-            include: ["reasoning.encrypted_content"],
-            stream: true,
-        }, req.maxTokens, req.signal, req.onStatus);
-        const data = await assembleOpenAI(events, req.onStream, req.onStatus);
-        const notice = stopNotice(data);
-        if (notice !== undefined)
-            req.onStream?.({ kind: "text", text: `\n${notice}` });
-        return fromWireResponse(data);
+        try {
+            const events = await postSse(ENDPOINT, headers(key), {
+                model: req.model,
+                instructions: req.system,
+                input: req.messages.flatMap((message) => toWireItems(message)),
+                tools: req.tools.map(toWireTool),
+                max_output_tokens: req.maxTokens,
+                reasoning: { effort, summary: "auto" },
+                store: false,
+                include: ["reasoning.encrypted_content"],
+                stream: true,
+                ...(req.identity?.purpose === "turn"
+                    ? { prompt_cache_key: req.identity.cacheKey }
+                    : {}),
+            }, req.maxTokens, req.signal, req.onStatus, openAIStreamProgress, (error) => isRetryableGenerationFailure(ID, error));
+            const data = await assembleOpenAI(events, req.onStream, req.onStatus);
+            const notice = stopNotice(data);
+            if (notice !== undefined)
+                req.onStream?.({ kind: "text", text: `\n${notice}` });
+            return fromWireResponse(data);
+        }
+        catch (error) {
+            throwProviderError(ID, req.signal, error);
+        }
     },
 };
 function apiKey() {
@@ -104,5 +126,9 @@ function requireKey() {
     return key;
 }
 function headers(key) {
-    return { authorization: `Bearer ${key}` };
+    return {
+        authorization: `Bearer ${key}`,
+        "user-agent": `jecode/${applicationVersion()} (${process.platform}; ${process.arch})`,
+        "x-client-request-id": randomUUID(),
+    };
 }