@giovannijecha/jecode 0.2.0 → 0.2.2

package/README.md

@@ -255,9 +255,10 @@ untrusted data.
 - Dangerous tools ask by default unless explicitly allowed for the session in
   **/permissions** or the process started with **--auto-approve**.
 - Credential fields are masked and excluded from transcripts. Approved shell
-  commands receive no credential-like environment variables, and recognized
-  credential values are redacted before tool output reaches the model, screen,
-  history, or export.
+  commands receive no secret-bearing environment variables; `SSH_AUTH_SOCK`
+  is preserved so Git and SSH can use the user's agent, which means an approved
+  command can request that agent to authenticate. Recognized credential values
+  are redacted before tool output reaches the model, screen, history, or export.
 - ChatGPT OAuth uses PKCE and an exact loopback callback or the OpenAI device
   flow. Refresh-token rotation is serialized across Jecode processes; OAuth
   tokens are withheld and redacted like API keys.

package/dist/controller.js

@@ -14,6 +14,7 @@ export const MAX_TOOL_CALLS_PER_STEP = 32;
 export async function runTurn(history, options, events, signal) {
     const specs = toolSpecs(options.tools);
     for (let step = 0; step < options.maxSteps; step++) {
+        throwIfAborted(signal);
         events.onStep?.(step + 1, options.maxSteps);
         // The message is displayed as it streams; what comes back here is the
         // assembled version, which exists to be appended to the history.
@@ -28,6 +29,7 @@ export async function runTurn(history, options, events, signal) {
             onStream: (event) => events.onStream(event),
             onStatus: (status) => events.onStatus?.(status),
         });
+        throwIfAborted(signal);
         const calls = assistant.content.filter(isToolCall);
         if (assistant.content.length === 0) {
             throw new Error(`${options.provider.id} completed without an answer or tool call`);
@@ -36,22 +38,58 @@ export async function runTurn(history, options, events, signal) {
             throw new Error(`provider returned ${calls.length} tool calls in one step (maximum ${MAX_TOOL_CALLS_PER_STEP})`);
         }
         history.push(assistant);
-        if (assistant.usage !== undefined)
-            events.onUsage?.(assistant.usage);
-        if (calls.length === 0)
+        if (calls.length === 0) {
+            if (assistant.usage !== undefined)
+                events.onUsage?.(assistant.usage);
             return; // the model is done — hand back to the user
+        }
         // Calls run one after another because approval prompts serialise anyway,
         // but every result from this step goes back in a SINGLE message. Splitting
         // them teaches the model to stop batching its calls.
         const results = [];
-        for (let index = 0; index < calls.length; index++) {
-            const call = calls[index];
-            events.onToolProgress?.(index + 1, calls.length);
-            const preview = await look(call, options);
-            events.onToolCall(call, preview);
-            const { result, summary } = await settle(call, options, events, signal, preview);
-            events.onToolResult(call, result, summary);
-            results.push(result);
+        const announced = new Set();
+        try {
+            if (assistant.usage !== undefined)
+                events.onUsage?.(assistant.usage);
+            for (let index = 0; index < calls.length; index++) {
+                throwIfAborted(signal);
+                const call = calls[index];
+                events.onToolProgress?.(index + 1, calls.length);
+                const preview = await look(call, options, signal);
+                throwIfAborted(signal);
+                announced.add(call.id);
+                events.onToolCall(call, preview);
+                const { result, summary } = await settle(call, options, events, signal, preview);
+                results.push(result);
+                events.onToolResult(call, result, summary);
+            }
+        }
+        catch (error) {
+            const interrupted = signal?.aborted === true;
+            const repairs = [];
+            for (const call of calls.slice(results.length)) {
+                const run = interrupted
+                    ? refuse(call, "interrupted before completion", "interrupted")
+                    : refuse(call, "tool processing stopped before completion", "failed");
+                repairs.push({ call, run });
+                results.push(run.result);
+            }
+            history.push({ role: "user", content: results });
+            // History repair is the invariant. UI recovery is best-effort and must
+            // never replace the original exception or leave the conversation open.
+            for (const { call, run } of repairs) {
+                if (!announced.has(call.id))
+                    continue;
+                try {
+                    events.onToolResult(call, run.result, run.summary);
+                }
+                catch {
+                    // The surface is already failing; the next turn can still proceed.
+                }
+            }
+            if (interrupted)
+                throw abortReason(signal);
+            throw error;
         }
         history.push({ role: "user", content: results });
     }
@@ -62,9 +100,13 @@ async function settle(call, options, events, signal, preview) {
     if (tool === undefined) {
         return refuse(call, `no such tool: ${call.name}`, "unknown tool");
     }
-    if (tool.dangerous && !(await events.approve(call))) {
+    throwIfAborted(signal);
+    const approved = !tool.dangerous || await events.approve(call);
+    throwIfAborted(signal);
+    if (!approved) {
         return refuse(call, "the user declined this call — ask them how to proceed", "declined");
     }
+    throwIfAborted(signal);
     return runTool(tool, call, {
         ...options.toolContext,
         signal,
@@ -85,14 +127,21 @@ function refuse(call, reason, summary) {
  * file, a match that is not there — is simply no preview. Nothing about the
  * turn depends on it, because it exists for the user, not for the model.
  */
-async function look(call, options) {
+async function look(call, options, signal) {
     const tool = findTool(options.tools, call.name);
     if (tool?.preview === undefined)
         return undefined;
     try {
-        return await tool.preview(call.input, options.toolContext);
+        return await tool.preview(call.input, { ...options.toolContext, signal });
     }
     catch {
         return undefined;
     }
 }
+function throwIfAborted(signal) {
+    if (signal?.aborted === true)
+        throw abortReason(signal);
+}
+function abortReason(signal) {
+    return signal.reason instanceof Error ? signal.reason : new Error("interrupted");
+}

package/dist/credential-safety.js

@@ -2,8 +2,20 @@
 import { credentialValues } from "./credentials.js";
 import { accountValues } from "./accounts.js";
 const REDACTED = "[credential redacted]";
+const MIN_HEURISTIC_SECRET_CHARS = 8;
+const EXPLICIT_CREDENTIAL_ENVIRONMENT_NAMES = new Set([
+    "ANTHROPIC_API_KEY",
+    "OLLAMA_API_KEY",
+    "OPENAI_API_KEY",
+]);
 const SENSITIVE_ENVIRONMENT_NAME = /(?:^|_)(?:API_?KEY|ACCESS_?KEY|PRIVATE_?KEY|KEY|TOKEN|SECRET|PASSWORD|PASSWD|PASS|PWD|CREDENTIALS?|AUTH|JWT|COOKIE|PAT)(?:_|$)/i;
 const COMPACT_SENSITIVE_ENVIRONMENT_NAME = /^(?:PGPASSWORD)$/i;
+const SAFE_ENVIRONMENT_NAMES = new Set([
+    "SSH_AUTH_SOCK",
+    "PWD",
+    "OLDPWD",
+    "PASSWORD_STORE_DIR",
+]);
 /** Preserve ordinary tool configuration while withholding credential-like values. */
 export function shellEnvironment(source = process.env) {
     const environment = {};
@@ -57,14 +69,20 @@ function sensitiveEnvironmentName(name) {
         .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
         .replace(/[^a-z0-9]+/gi, "_")
         .replace(/^_+|_+$/g, "");
+    if (SAFE_ENVIRONMENT_NAMES.has(normalized.toUpperCase()))
+        return false;
     return (SENSITIVE_ENVIRONMENT_NAME.test(normalized) ||
         COMPACT_SENSITIVE_ENVIRONMENT_NAME.test(normalized));
 }
 function secrets(source) {
     const values = new Set([...credentialValues(), ...accountValues()]);
     for (const [name, value] of Object.entries(source)) {
-        if (value !== undefined && value !== "" && sensitiveEnvironment(name, value))
+        if (value === undefined || value === "")
+            continue;
+        const explicit = EXPLICIT_CREDENTIAL_ENVIRONMENT_NAMES.has(name.toUpperCase());
+        if (explicit || (value.length >= MIN_HEURISTIC_SECRET_CHARS && sensitiveEnvironment(name, value))) {
             values.add(value);
+        }
     }
     return [...values].filter((value) => value !== "").sort((left, right) => right.length - left.length);
 }

package/dist/effort.js

@@ -0,0 +1,25 @@
+// One ordered vocabulary for reasoning depth. Providers expose the subset a
+// selected model accepts; this module only validates and reconciles that data.
+export const EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+export function isEffort(value) {
+    return typeof value === "string" && EFFORTS.includes(value);
+}
+export function requireSupportedEffort(model, requested, supported) {
+    if (supported.includes(requested))
+        return requested;
+    const choices = supported.length === 0 ? "none" : supported.join(", ");
+    throw new Error(`${model} does not support effort "${requested}" (available: ${choices})`);
+}
+/** Keep the requested depth when possible, otherwise choose the nearest lower level. */
+export function compatibleEffort(requested, supported) {
+    if (supported.length === 0)
+        return undefined;
+    if (supported.includes(requested))
+        return requested;
+    const requestedIndex = EFFORTS.indexOf(requested);
+    const candidates = EFFORTS.filter((value) => supported.includes(value));
+    if (requestedIndex < 0)
+        return candidates[0];
+    return [...candidates].reverse().find((value) => EFFORTS.indexOf(value) < requestedIndex)
+        ?? candidates[0];
+}

package/dist/openai-account.js

@@ -43,6 +43,8 @@ export async function openAIAuthorization(forceToken, signal, onStatus) {
 async function refreshAccount(forceToken, signal, onStatus) {
     if (refreshing !== undefined)
         return abortable(refreshing, signal);
+    if (signal?.aborted === true)
+        throw abortReason(signal);
     onStatus?.("Refreshing ChatGPT sign-in");
     const task = updateOpenAICodexAccount(async (current) => {
         if (current === undefined)
@@ -51,20 +53,21 @@ async function refreshAccount(forceToken, signal, onStatus) {
             return current;
         if (forceToken === undefined && !expiresSoon(current))
             return current;
-        return refreshOpenAITokens(current, signal);
-    }, signal).then((account) => {
+        return refreshOpenAITokens(current);
+    }).then((account) => {
         if (account === undefined)
             throw new Error("ChatGPT account is not connected");
         return account;
     });
     refreshing = task;
-    try {
-        return await abortable(task, signal);
-    }
-    finally {
+    void task.then(() => {
         if (refreshing === task)
             refreshing = undefined;
-    }
+    }, () => {
+        if (refreshing === task)
+            refreshing = undefined;
+    });
+    return abortable(task, signal);
 }
 function expiresSoon(account) {
     return account.expiresAt - Date.now() <= REFRESH_EARLY_MS;

package/dist/provider-commands.js

@@ -5,6 +5,7 @@ import { readSettings } from "./settings.js";
 import { authenticationNeed, ensureProviderAuthentication, } from "./credential-commands.js";
 import { providerFailure } from "./provider-errors.js";
 import { providerLabel } from "./provider-label.js";
+import { compatibleEffort } from "./effort.js";
 /**
  * The provider menu.
  *
@@ -61,6 +62,7 @@ export async function providersCommand(session, host, behavior = {}) {
         model: session.model,
         providerId: session.config.providerId,
         configModel: session.config.model,
+        effort: session.config.effort,
     };
     session.provider = chosen;
     // The model belonged to the old provider. Carrying it across would send
@@ -68,23 +70,31 @@ export async function providersCommand(session, host, behavior = {}) {
     session.model = readSettings().models?.[chosen.id] ?? chosen.defaultModel;
     session.config.providerId = chosen.id;
     session.config.model = session.model;
-    if (session.model === "" && !(await modelsCommand(session, host, { announce: false, save: false }))) {
-        session.provider = before.provider;
-        session.model = before.model;
-        session.config.providerId = before.providerId;
-        session.config.model = before.configModel;
-        return false;
+    if (session.model === "") {
+        if (!(await modelsCommand(session, host, { announce: false, save: false }))) {
+            restoreProvider(session, before);
+            return false;
+        }
+    }
+    else {
+        const alignment = await alignEffort(session, host);
+        if (!alignment.ok) {
+            restoreProvider(session, before);
+            return false;
+        }
     }
     if (behavior.save !== false) {
         const saved = readSettings();
         const models = { ...saved.models };
         if (session.model !== "")
             models[chosen.id] = session.model;
-        if (!(await saveDefaults(host, { provider: chosen.id, models }))) {
-            session.provider = before.provider;
-            session.model = before.model;
-            session.config.providerId = before.providerId;
-            session.config.model = before.configModel;
+        const patch = {
+            provider: chosen.id,
+            models,
+            ...(session.config.effort === before.effort ? {} : { effort: session.config.effort }),
+        };
+        if (!(await saveDefaults(host, patch))) {
+            restoreProvider(session, before);
             return false;
         }
     }
@@ -152,15 +162,31 @@ export async function modelsCommand(session, host, behavior = {}) {
     const chosen = ids[index];
     if (chosen === undefined)
         return false;
-    const before = { model: session.model, configModel: session.config.model };
+    const before = {
+        model: session.model,
+        configModel: session.config.model,
+        effort: session.config.effort,
+    };
     session.model = chosen;
     session.config.model = chosen;
+    const alignment = await alignEffort(session, host);
+    if (!alignment.ok) {
+        session.model = before.model;
+        session.config.model = before.configModel;
+        session.config.effort = before.effort;
+        return false;
+    }
     if (behavior.save !== false) {
         const saved = readSettings();
         const models = { ...saved.models, [provider.id]: chosen };
-        if (!(await saveDefaults(host, { models }))) {
+        const patch = {
+            models,
+            ...(session.config.effort === before.effort ? {} : { effort: session.config.effort }),
+        };
+        if (!(await saveDefaults(host, patch))) {
             session.model = before.model;
             session.config.model = before.configModel;
+            session.config.effort = before.effort;
             return false;
         }
     }
@@ -169,7 +195,34 @@ export async function modelsCommand(session, host, behavior = {}) {
     }
     return true;
 }
-/** The way to put a menu up, or nothing — and the reason, already said. */
+function restoreProvider(session, before) {
+    session.provider = before.provider;
+    session.model = before.model;
+    session.config.providerId = before.providerId;
+    session.config.model = before.configModel;
+    session.config.effort = before.effort;
+}
+async function alignEffort(session, host) {
+    if (session.provider.efforts === undefined)
+        return { ok: true };
+    let supported;
+    try {
+        supported = await session.provider.efforts(session.model, host.signal, (status) => host.status?.(status));
+    }
+    catch (error) {
+        host.emit({
+            kind: "notice",
+            text: providerFailure(session.provider, error, true),
+            tone: "error",
+        });
+        return { ok: false };
+    }
+    const adjusted = compatibleEffort(session.config.effort, supported);
+    if (adjusted === undefined || adjusted === session.config.effort)
+        return { ok: true };
+    session.config.effort = adjusted;
+    return { ok: true, adjusted };
+}
 function chooser(host) {
     if (host.choose === undefined) {
         host.emit({ kind: "notice", text: "that command needs the screen", tone: "warn" });

package/dist/providers/anthropic-stream.js

@@ -13,7 +13,8 @@ export async function assembleAnthropic(events, onStream) {
     let stopReason;
     let stopDetails;
     let usage;
-    for await (const raw of events) {
+    let complete = false;
+    stream: for await (const raw of events) {
         const event = raw;
         switch (event.type) {
             case "message_start":
@@ -51,10 +52,15 @@ export async function assembleAnthropic(events, onStream) {
             case "error": {
                 throw new Error(`anthropic stream error: ${event.error?.message ?? "unspecified"}`);
             }
+            case "message_stop":
+                complete = true;
+                break stream;
             default:
-                break; // message_start, ping, message_stop: nothing to accumulate
+                break; // ping and unknown forward-compatible events
         }
     }
+    if (!complete)
+        throw new Error("anthropic stream ended before message_stop");
     const content = [...blocks.entries()]
         .sort(([a], [b]) => a - b)
         .map(([, block]) => block);

package/dist/providers/anthropic.js

@@ -9,19 +9,27 @@
 import { postSse } from "./http.js";
 import { listModels } from "./catalog.js";
 import { keyFor } from "../credentials.js";
+import { EFFORTS, requireSupportedEffort } from "../effort.js";
 import { assembleAnthropic } from "./anthropic-stream.js";
 import { fromWireResponse, stopNotice, toWireMessage, toWireTool } from "./anthropic-wire.js";
 const ENDPOINT = "https://api.anthropic.com/v1/messages";
 const MODELS = "https://api.anthropic.com/v1/models?limit=100";
 const API_VERSION = "2023-06-01";
 const KEY = "ANTHROPIC_API_KEY";
-// Adaptive thinking and `output_config.effort` exist on the 4.6-and-later
-// families only. Older models reject both with a 400, so `/model claude-haiku-4-5`
-// would fail on send if the request shape were fixed. It follows the model.
-const ADAPTIVE = /^claude-(fable-5|opus-(5|4-[678])|sonnet-(5|4-6))/;
+const ADAPTIVE = /^claude-(?:fable-5|mythos-(?:5|preview)|opus-(?:5|4-[678])|sonnet-(?:5|4-6))(?:-|$)/;
+const MAX_WITHOUT_XHIGH = ["low", "medium", "high", "max"];
+const ANTHROPIC_45_EFFORTS = ["low", "medium", "high"];
 export function supportsAdaptiveThinking(model) {
     return ADAPTIVE.test(model);
 }
+export function anthropicEfforts(model) {
+    if (/^claude-(?:(?:opus|sonnet)-4-6|mythos-preview)(?:-|$)/.test(model)) {
+        return MAX_WITHOUT_XHIGH;
+    }
+    if (/^claude-opus-4-5(?:-|$)/.test(model))
+        return ANTHROPIC_45_EFFORTS;
+    return supportsAdaptiveThinking(model) ? EFFORTS : [];
+}
 export const anthropic = {
     id: "anthropic",
     // Sonnet is the default because it is the one that can be left running.
@@ -36,6 +44,9 @@ export const anthropic = {
     models(signal, onStatus) {
         return listModels(MODELS, headers(requireKey()), signal, onStatus);
     },
+    async efforts(model) {
+        return anthropicEfforts(model);
+    },
     location: () => "cloud",
     async send(req) {
         const key = requireKey();
@@ -49,7 +60,12 @@ export const anthropic = {
         };
         if (supportsAdaptiveThinking(req.model)) {
             body["thinking"] = { type: "adaptive", display: "summarized" };
-            body["output_config"] = { effort: req.effort };
+        }
+        const efforts = anthropicEfforts(req.model);
+        if (efforts.length > 0) {
+            body["output_config"] = {
+                effort: requireSupportedEffort(req.model, req.effort, efforts),
+            };
         }
         const events = await postSse(ENDPOINT, headers(key), body, req.signal, req.onStatus);
         const data = await assembleAnthropic(events, req.onStream);

package/dist/providers/ollama-stream.js

@@ -51,6 +51,9 @@ export async function assembleOllama(events, onStream) {
             calls.set(index, call);
         }
     }
+    if (finishReason === undefined) {
+        throw new Error("ollama stream ended before a finish reason");
+    }
     const toolCalls = [...calls.entries()]
         .sort(([a], [b]) => a - b)
         // Not every server sends an id, and the loop needs one to pair the result

package/dist/providers/ollama.js

@@ -45,6 +45,9 @@ export const ollama = {
         const at = endpoint();
         return listModels(`${at.baseUrl}/v1/models`, headers(at), signal, onStatus);
     },
+    async efforts() {
+        return [];
+    },
     location: () => {
         try {
             return endpoint().loopback ? "local" : "cloud";

package/dist/providers/openai-codex.js

@@ -3,6 +3,7 @@ import { randomUUID } from "node:crypto";
 import { openAICodexAccount } from "../accounts.js";
 import { openAIAuthorization } from "../openai-account.js";
 import { applicationVersion } from "../version.js";
+import { EFFORTS, isEffort, requireSupportedEffort } from "../effort.js";
 import { getJson, postSse } from "./http.js";
 import { assembleOpenAI } from "./openai-stream.js";
 import { fromWireResponse, stopNotice, toWireItems, toWireTool, } from "./openai-wire.js";
@@ -16,6 +17,8 @@ const SESSION_ID = randomUUID();
 const MAX_CATALOG_ITEMS = 4_000;
 const MAX_MODELS = 1_000;
 const MAX_MODEL_CHARS = 256;
+const XHIGH_EFFORTS = ["low", "medium", "high", "xhigh"];
+let effortByModel = new Map();
 export const openaiCodex = {
     id: ID,
     defaultModel: "",
@@ -25,12 +28,21 @@ export const openaiCodex = {
     },
     location: () => "cloud",
     async models(signal, onStatus) {
-        return withAuthorization(async (authorization) => {
-            const body = await getJson(`${BASE}/models?client_version=${CATALOG_COMPATIBILITY_VERSION}`, headers(authorization, randomUUID()), signal, onStatus);
-            return modelIds(body);
-        }, signal, onStatus);
+        const catalog = await loadCatalog(signal, onStatus);
+        effortByModel = catalog.efforts;
+        return catalog.ids;
+    },
+    async efforts(model, signal, onStatus) {
+        const cached = effortByModel.get(model);
+        if (cached !== undefined)
+            return cached;
+        const catalog = await loadCatalog(signal, onStatus);
+        effortByModel = catalog.efforts;
+        return effortByModel.get(model) ?? fallbackEfforts(model);
     },
     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()),
@@ -44,7 +56,7 @@ export const openaiCodex = {
                 tools: req.tools.map(toWireTool),
                 tool_choice: "auto",
                 parallel_tool_calls: true,
-                reasoning: { effort: req.effort, summary: "auto" },
+                reasoning: { effort, summary: "auto" },
                 text: { verbosity: "low" },
                 include: ["reasoning.encrypted_content"],
                 prompt_cache_key: SESSION_ID,
@@ -57,6 +69,12 @@ export const openaiCodex = {
         }, req.signal, req.onStatus);
     },
 };
+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);
+        return modelCatalog(body);
+    }, signal, onStatus);
+}
 async function withAuthorization(operation, signal, onStatus) {
     let authorization = await openAIAuthorization(undefined, signal, onStatus);
     try {
@@ -80,12 +98,12 @@ function headers(authorization, requestId) {
         "x-client-request-id": requestId,
     };
 }
-function modelIds(value) {
+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");
     const seen = new Set();
-    return source
+    const models = source
         .slice(0, MAX_CATALOG_ITEMS)
         .flatMap((entry) => {
         if (!record(entry))
@@ -98,11 +116,36 @@ function modelIds(value) {
             seen.has(id))
             return [];
         seen.add(id);
-        return [{ id, priority: typeof entry["priority"] === "number" ? entry["priority"] : 0 }];
+        return [{
+                id,
+                priority: typeof entry["priority"] === "number" ? entry["priority"] : 0,
+                efforts: reasoningLevels(entry, id),
+            }];
     })
         .sort((left, right) => left.priority - right.priority)
-        .slice(0, MAX_MODELS)
-        .map((entry) => entry.id);
+        .slice(0, MAX_MODELS);
+    return {
+        ids: models.map((entry) => entry.id),
+        efforts: new Map(models.map((entry) => [entry.id, entry.efforts])),
+    };
+}
+function reasoningLevels(entry, model) {
+    const source = entry["supported_reasoning_levels"];
+    if (!Array.isArray(source))
+        return fallbackEfforts(model);
+    const seen = new Set();
+    const efforts = source.flatMap((level) => {
+        if (!record(level) || !isEffort(level["effort"]) || seen.has(level["effort"]))
+            return [];
+        seen.add(level["effort"]);
+        return [level["effort"]];
+    });
+    return efforts.length === 0 ? fallbackEfforts(model) : efforts;
+}
+function fallbackEfforts(model) {
+    if (/^gpt-5\.6-(?:sol|terra|luna)(?:-|$)/.test(model))
+        return EFFORTS;
+    return XHIGH_EFFORTS;
 }
 function statusOf(error) {
     return typeof error === "object" && error !== null && "status" in error

package/dist/providers/openai-stream.js

@@ -42,7 +42,7 @@ export async function assembleOpenAI(events, onStream) {
                 break;
         }
     }
-    return { output: items };
+    throw new Error("openai stream ended before a terminal response event");
 }
 function reconcileOutput(completed, items) {
     if (completed === undefined)

package/dist/providers/openai-wire.js

@@ -1,11 +1,6 @@
 // Translation between the normalized vocabulary and the OpenAI Responses wire
 // shape: a flat `input` list where tool calls and their outputs are top-level
 // items keyed by `call_id`, rather than blocks nested inside a message.
-// The Responses API has no `xhigh`; collapse it onto the nearest level rather
-// than passing through a value it will reject.
-export function normalizeEffort(effort) {
-    return effort === "xhigh" || effort === "max" ? "high" : effort;
-}
 export function toWireTool(tool) {
     return {
         type: "function",