@giovannijecha/jecode 0.8.3 → 0.8.5

package/dist/providers/openai-codex.js

@@ -4,8 +4,9 @@ import { openAICodexAccount } from "../accounts.js";
 import { openAIAuthorization } from "../openai-account.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 +14,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;
@@ -29,60 +29,84 @@ export const openaiCodex = {
     },
     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);
-            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,14 +126,14 @@ 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,
     };
 }
@@ -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,40 +4,74 @@
 // 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.
-export async function assembleOpenAI(events, onStream) {
+import { providerWireError } from "./failure.js";
+export async function assembleOpenAI(events, onStream, onStatus) {
     const items = [];
     const announcedTools = { identities: new Set(), anonymous: false };
     let refusal = false;
+    let activity;
+    const status = (next) => {
+        if (activity === next)
+            return;
+        activity = next;
+        onStatus?.(next);
+    };
     for await (const raw of events) {
         const event = raw;
         switch (event.type) {
+            case "response.created":
+            case "response.in_progress":
+                if (activity === undefined)
+                    status("Working");
+                break;
             case "response.output_text.delta":
-                if (typeof event.delta === "string")
+                if (typeof event.delta === "string") {
+                    status("Responding");
                     onStream?.({ kind: "text", text: event.delta });
+                }
                 break;
             case "response.refusal.delta":
                 if (typeof event.delta === "string") {
+                    status("Responding");
                     onStream?.({ kind: "text", text: `${refusal ? "" : "[refused] "}${event.delta}` });
                     refusal = true;
                 }
                 break;
             case "response.reasoning_summary_text.delta":
-                if (typeof event.delta === "string")
+                if (typeof event.delta === "string") {
+                    status("Thinking");
                     onStream?.({ kind: "thinking", text: event.delta });
+                }
+                break;
+            case "response.reasoning_summary_part.added":
+                status("Thinking");
+                break;
+            case "response.reasoning_summary_text.done":
+            case "response.reasoning_summary_part.done":
+                status("Working");
                 break;
             case "response.output_item.added":
                 if (isFunctionCall(event.item)) {
-                    announceTool(event, event.item, announcedTools, onStream);
+                    announceTool(event, event.item, announcedTools, onStream, status);
+                }
+                else if (itemType(event.item) === "reasoning") {
+                    status("Thinking");
+                }
+                else if (itemType(event.item) === "message") {
+                    status("Responding");
                 }
                 break;
             case "response.function_call_arguments.delta":
             case "response.function_call_arguments.done":
-                announceTool(event, undefined, announcedTools, onStream);
+                announceTool(event, undefined, announcedTools, onStream, status);
                 break;
             case "response.output_item.done":
                 if (event.item !== undefined) {
                     if (isFunctionCall(event.item)) {
-                        announceTool(event, event.item, announcedTools, onStream);
+                        announceTool(event, event.item, announcedTools, onStream, status);
+                    }
+                    else if (itemType(event.item) === "reasoning") {
+                        status("Working");
                     }
                     items.push(event.item);
                 }
@@ -52,21 +86,46 @@ export async function assembleOpenAI(events, onStream) {
                 };
             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";
 }
-function announceTool(event, item, announced, onStream) {
+function itemType(item) {
+    return typeof item === "object" && item !== null
+        ? item["type"]
+        : undefined;
+}
+function announceTool(event, item, announced, onStream, onStatus) {
     const identities = toolIdentities(event, item);
     if (identities.length === 0) {
         if (announced.anonymous)
@@ -82,6 +141,7 @@ function announceTool(event, item, announced, onStream) {
     }
     const rawName = item?.name ?? event.name;
     const name = typeof rawName === "string" && rawName !== "" ? rawName : undefined;
+    onStatus?.(`Preparing ${name ?? "tool"}`);
     onStream?.({ kind: "tool", ...(name === undefined ? {} : { name }) });
 }
 function toolIdentities(event, item) {

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);
@@ -76,22 +91,30 @@ export const openai = {
     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);
-        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 +127,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(),
+    };
 }

package/dist/providers/sse.js

@@ -4,39 +4,111 @@
 // `data` matters here — both providers put the event discriminator inside the
 // JSON payload, so the `event:` line is redundant and skipped.
 import { addBounded, MAX_SSE_EVENT_CHARS, } from "./stream-limits.js";
-export async function* readSseJson(body, maximumChars) {
+export async function* readSseJson(body, maximumChars, idle) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     const parser = new SseEventParser();
     let finished = false;
     let total = 0;
+    const progressDeadline = idle?.progress === undefined
+        ? undefined
+        : eventDeadline(idle.progress);
     try {
-        for (;;) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            const text = decoder.decode(value, { stream: true });
-            total = addBounded(total, text.length, maximumChars, "SSE stream");
-            for (const payload of parser.push(text))
+        let ended = false;
+        while (!ended) {
+            // One deadline spans every raw read until a complete JSON event lands.
+            // SSE comments and partial framing prove only that the socket is alive;
+            // they must not keep a model request pending forever.
+            const deadline = eventDeadline(idle);
+            const payloads = [];
+            try {
+                while (payloads.length === 0 && !ended) {
+                    const read = reader.read();
+                    const pending = progressDeadline === undefined
+                        ? read
+                        : progressDeadline.wait(read);
+                    const { done, value } = await deadline.wait(pending);
+                    if (done) {
+                        ended = true;
+                        const text = decoder.decode();
+                        total = addBounded(total, text.length, maximumChars, "SSE stream");
+                        payloads.push(...parser.push(text));
+                        const payload = parser.finish();
+                        if (payload !== undefined)
+                            payloads.push(payload);
+                        continue;
+                    }
+                    const text = decoder.decode(value, { stream: true });
+                    total = addBounded(total, text.length, maximumChars, "SSE stream");
+                    payloads.push(...parser.push(text));
+                }
+            }
+            finally {
+                deadline.clear();
+            }
+            for (const payload of payloads) {
+                if (idle?.progress?.observed(payload) === true)
+                    progressDeadline?.reset();
                 yield payload;
+            }
         }
-        // A stream that ends without a trailing blank line still owes us its last
-        // event.
-        const text = decoder.decode();
-        total = addBounded(total, text.length, maximumChars, "SSE stream");
-        for (const payload of parser.push(text))
-            yield payload;
-        const payload = parser.finish();
-        if (payload !== undefined)
-            yield payload;
         finished = true;
     }
     finally {
+        progressDeadline?.clear();
         if (!finished)
             await reader.cancel().catch(() => undefined);
         reader.releaseLock();
     }
 }
+function eventDeadline(idle) {
+    if (idle === undefined) {
+        return {
+            wait: (pending) => pending,
+            reset: () => undefined,
+            clear: () => undefined,
+        };
+    }
+    let timer;
+    let expired;
+    let rejectWait;
+    const arm = () => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+        expired = undefined;
+        timer = setTimeout(() => {
+            expired = idle.error();
+            const reject = rejectWait;
+            rejectWait = undefined;
+            reject?.(expired);
+        }, idle.milliseconds);
+    };
+    arm();
+    return {
+        wait: (pending) => {
+            if (expired !== undefined)
+                return Promise.reject(expired);
+            return new Promise((resolve, reject) => {
+                rejectWait = reject;
+                pending.then((value) => {
+                    if (rejectWait === reject)
+                        rejectWait = undefined;
+                    resolve(value);
+                }, (error) => {
+                    if (rejectWait === reject)
+                        rejectWait = undefined;
+                    reject(error);
+                });
+            });
+        },
+        reset: arm,
+        clear: () => {
+            if (timer !== undefined)
+                clearTimeout(timer);
+            rejectWait = undefined;
+        },
+    };
+}
 // Keep fragments in bounded groups. A provider may split one SSE line into
 // hundreds of thousands of tiny chunks; repeatedly flattening the growing line
 // would make parsing quadratic even if boundary scanning itself were linear.

package/dist/request-identity.js

@@ -0,0 +1,32 @@
+// Stable provider-facing conversation identity. It is routing metadata only,
+// never authorization, persistence authority, or a user-visible identifier.
+import { createHash, randomUUID } from "node:crypto";
+const ephemeralSeeds = new WeakMap();
+export function requestIdentityForSession(session) {
+    let conversation = session.persistence?.conversationId;
+    if (conversation === undefined) {
+        conversation = ephemeralSeeds.get(session);
+        if (conversation === undefined) {
+            conversation = randomUUID();
+            ephemeralSeeds.set(session, conversation);
+        }
+    }
+    return identityFromSeed(`${session.provider.id}\0${conversation}`);
+}
+export function resetRequestIdentity(session) {
+    ephemeralSeeds.delete(session);
+}
+function identityFromSeed(seed) {
+    const digest = createHash("sha256").update(seed).digest("hex");
+    const conversationId = [
+        digest.slice(0, 8),
+        digest.slice(8, 12),
+        `5${digest.slice(13, 16)}`,
+        `${variant(digest[16])}${digest.slice(17, 20)}`,
+        digest.slice(20, 32),
+    ].join("-");
+    return Object.freeze({ conversationId, cacheKey: `jecode-${digest.slice(0, 32)}` });
+}
+function variant(value) {
+    return ((Number.parseInt(value, 16) & 0x3) | 0x8).toString(16);
+}