@giovannijecha/jecode 0.8.5 → 0.8.7

package/dist/providers/ollama-context.js

@@ -0,0 +1,42 @@
+// Cloud model capacity, with bounded metadata and conservative safety headroom.
+import { postJson } from "./http.js";
+import { OLLAMA_CLOUD_HOST } from "./ollama-endpoint.js";
+const CACHE_MS = 30_000;
+const capacities = new Map();
+export async function ollamaContextWindow(model, headers, signal, onStatus) {
+    signal?.throwIfAborted();
+    const cached = capacities.get(model);
+    if (cached !== undefined && cached.expiresAt > Date.now())
+        return cached.value;
+    capacities.delete(model);
+    try {
+        const details = await postJson(`${OLLAMA_CLOUD_HOST}/api/show`, headers, { model }, signal, onStatus);
+        const tokens = modelCapacity(details);
+        if (tokens === undefined)
+            return undefined;
+        const value = Object.freeze({ tokens: Math.floor(tokens * 95 / 100) });
+        capacities.set(model, { value, expiresAt: Date.now() + CACHE_MS });
+        return value;
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw error;
+        // Missing metadata leaves budgeting to the controller's safe fallback.
+        return undefined;
+    }
+}
+function modelCapacity(value) {
+    if (!record(value) || !record(value["model_info"]))
+        return undefined;
+    const counts = Object.entries(value["model_info"])
+        .filter(([name, count]) => name.endsWith(".context_length") && validTokenCount(count))
+        .map(([, count]) => count);
+    return counts.length === 0 ? undefined : Math.max(...counts);
+}
+function validTokenCount(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) &&
+        value >= 4_096 && value <= 10_000_000;
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/providers/ollama-endpoint.js

@@ -1,40 +1,13 @@
-// Turning an Ollama host into one safe, normalized endpoint.
-export const OLLAMA_LOCAL_HOST = "http://127.0.0.1:11434";
+// The fixed API endpoint and recognition of its retired saved setting.
 export const OLLAMA_CLOUD_HOST = "https://ollama.com";
-export function parseOllamaEndpoint(value) {
-    let url;
+/** Recognize old official-cloud values without making endpoints configurable. */
+export function isLegacyOllamaCloudHost(value) {
+    if (typeof value !== "string")
+        return false;
     try {
-        url = new URL(value.trim());
+        return new URL(value.trim()).href.replace(/\/+$/, "") === OLLAMA_CLOUD_HOST;
     }
     catch {
-        throw new Error("Ollama endpoint must be an absolute HTTP(S) URL");
+        return false;
     }
-    if (url.protocol !== "http:" && url.protocol !== "https:") {
-        throw new Error("Ollama endpoint must use HTTP or HTTPS");
-    }
-    if (url.username !== "" || url.password !== "") {
-        throw new Error("Ollama endpoint must not contain credentials");
-    }
-    if (url.search !== "" || url.hash !== "") {
-        throw new Error("Ollama endpoint must not contain a query or fragment");
-    }
-    const loopback = isExactLoopback(url.hostname);
-    if (url.protocol === "http:" && !loopback) {
-        throw new Error("Ollama endpoint must use HTTPS unless it is an exact loopback address");
-    }
-    const pathname = url.pathname.replace(/\/+$/, "");
-    return {
-        baseUrl: `${url.origin}${pathname === "" ? "" : pathname}`,
-        loopback,
-    };
-}
-export function ollamaConnectionKind(endpoint) {
-    if (endpoint.baseUrl === OLLAMA_CLOUD_HOST)
-        return "cloud";
-    if (endpoint.baseUrl === OLLAMA_LOCAL_HOST)
-        return "local";
-    return "custom";
-}
-function isExactLoopback(hostname) {
-    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
 }

package/dist/providers/ollama-wire.js

@@ -107,6 +107,6 @@ function normalizeUsage(reply) {
 }
 export function stopNotice(reply) {
     return reply.finishReason === "length"
-        ? "[truncated: hit the output limit — raise --max-tokens]"
+        ? "[truncated: hit the output limit — raise max output tokens in /settings]"
         : undefined;
 }

package/dist/providers/ollama.js

@@ -1,58 +1,28 @@
-// 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 { ollamaContextWindow } from "./ollama-context.js";
 import { isRetryableGenerationFailure, isRetryableReadFailure, throwProviderError, } from "./failure.js";
-import { OLLAMA_CLOUD_HOST, OLLAMA_LOCAL_HOST, ollamaConnectionKind, parseOllamaEndpoint, } from "./ollama-endpoint.js";
+import { OLLAMA_CLOUD_HOST } from "./ollama-endpoint.js";
 import { fromWireReply, stopNotice, toWireMessages, toWireTool } from "./ollama-wire.js";
+import { measureOllamaInput } from "./input-measurement.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: 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() {
-        try {
-            const at = endpoint();
-            if (apiKey() !== undefined || at.loopback)
-                return undefined;
-            return `${KEY} is not set (required by ${at.baseUrl})`;
-        }
-        catch (error) {
-            return error.message;
-        }
+        return keyFor(KEY) === undefined ? `${KEY} is not set` : undefined;
     },
-    // Whatever the daemon has pulled, or whatever the subscription grants.
     async models(signal, onStatus) {
         try {
-            const at = endpoint();
-            return await listModels(`${at.baseUrl}/v1/models`, headers(at), signal, onStatus, (error) => isRetryableReadFailure(ID, error));
+            return await listModels(`${OLLAMA_CLOUD_HOST}/v1/models`, headers(), signal, onStatus, (error) => isRetryableReadFailure(ID, error));
         }
         catch (error) {
             throwProviderError(ID, signal, error);
@@ -62,36 +32,13 @@ export const ollama = {
         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;
-    },
-    location: () => {
-        try {
-            return endpoint().loopback ? "local" : "cloud";
-        }
-        catch {
-            return "cloud";
-        }
+        return ollamaContextWindow(model, headers(), signal, onStatus);
     },
+    measureInput: measureOllamaInput,
     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.
         try {
-            const events = await postSse(`${at.baseUrl}/v1/chat/completions`, headers(at), {
+            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),
@@ -111,88 +58,9 @@ export const ollama = {
         }
     },
 };
-async function nativeContextWindow(at, model, fallback, signal, onStatus) {
-    try {
-        const running = await getJson(`${at.baseUrl}/api/ps`, headers(at), signal, onStatus, (error) => isRetryableReadFailure(ID, error));
-        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,12 +2,14 @@
 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, openAIStreamProgress } from "./openai-stream.js";
 import { fromWireResponse, stopNotice, toWireItems, toWireTool, } from "./openai-wire.js";
+import { measureResponsesInput, responsesTokenization } from "./input-measurement.js";
 const ID = "openai-codex";
 const BASE = "https://chatgpt.com/backend-api/codex";
 // Jecode's product version is unrelated to the Codex protocol gate. OpenAI's
@@ -23,11 +25,10 @@ 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) {
         try {
             const catalog = await loadCatalog(signal, onStatus);
@@ -66,6 +67,8 @@ export const openaiCodex = {
             throwProviderError(ID, signal, error);
         }
     },
+    measureInput: (request, signal) => measureResponsesInput(request, ID, signal),
+    inputTokenization: (model) => responsesTokenization(model, ID),
     async send(req) {
         const efforts = effortByModel.get(req.model) ?? fallbackEfforts(req.model);
         const effort = requireSupportedEffort(req.model, req.effort, efforts);
@@ -140,7 +143,7 @@ function headers(authorization, sessionId, 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)

package/dist/providers/openai-stream.js

@@ -5,9 +5,16 @@
 // 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";
+import { OpenAISummary } from "./openai-summary.js";
 export async function assembleOpenAI(events, onStream, onStatus) {
     const items = [];
     const announcedTools = { identities: new Set(), anonymous: false };
+    const summary = new OpenAISummary();
+    const display = (event) => {
+        if (event.kind !== "thinking")
+            summary.reset();
+        onStream?.(event);
+    };
     let refusal = false;
     let activity;
     const status = (next) => {
@@ -27,32 +34,36 @@ export async function assembleOpenAI(events, onStream, onStatus) {
             case "response.output_text.delta":
                 if (typeof event.delta === "string") {
                     status("Responding");
-                    onStream?.({ kind: "text", text: event.delta });
+                    display({ 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}` });
+                    display({ kind: "text", text: `${refusal ? "" : "[refused] "}${event.delta}` });
                     refusal = true;
                 }
                 break;
-            case "response.reasoning_summary_text.delta":
-                if (typeof event.delta === "string") {
+            case "response.reasoning_summary_text.delta": {
+                const text = summary.delta(event);
+                if (text !== undefined) {
                     status("Thinking");
-                    onStream?.({ kind: "thinking", text: event.delta });
+                    display({ kind: "thinking", text });
                 }
                 break;
+            }
             case "response.reasoning_summary_part.added":
+                summary.end();
                 status("Thinking");
                 break;
             case "response.reasoning_summary_text.done":
             case "response.reasoning_summary_part.done":
+                summary.end();
                 status("Working");
                 break;
             case "response.output_item.added":
                 if (isFunctionCall(event.item)) {
-                    announceTool(event, event.item, announcedTools, onStream, status);
+                    announceTool(event, event.item, announcedTools, display, status);
                 }
                 else if (itemType(event.item) === "reasoning") {
                     status("Thinking");
@@ -63,14 +74,15 @@ export async function assembleOpenAI(events, onStream, onStatus) {
                 break;
             case "response.function_call_arguments.delta":
             case "response.function_call_arguments.done":
-                announceTool(event, undefined, announcedTools, onStream, status);
+                announceTool(event, undefined, announcedTools, display, status);
                 break;
             case "response.output_item.done":
                 if (event.item !== undefined) {
                     if (isFunctionCall(event.item)) {
-                        announceTool(event, event.item, announcedTools, onStream, status);
+                        announceTool(event, event.item, announcedTools, display, status);
                     }
                     else if (itemType(event.item) === "reasoning") {
+                        summary.end();
                         status("Working");
                     }
                     items.push(event.item);

package/dist/providers/openai-summary.js

@@ -0,0 +1,37 @@
+// Display boundaries between Responses summary parts; provider replay stays untouched.
+export class OpenAISummary {
+    #part;
+    #ended = false;
+    #tail = "";
+    reset() {
+        this.#part = undefined;
+        this.#ended = false;
+        this.#tail = "";
+    }
+    end() { this.#ended = true; }
+    delta(event) {
+        if (typeof event.delta !== "string" || event.delta === "")
+            return undefined;
+        const part = {
+            item: typeof event.item_id === "string" ? event.item_id : undefined,
+            output: index(event.output_index),
+            summary: index(event.summary_index),
+        };
+        const previous = this.#part;
+        const changed = previous !== undefined && ["item", "output", "summary"].some(key => (part[key] !== undefined && previous[key] !== undefined && part[key] !== previous[key]));
+        // Completion events cover older/idless streams. Identity changes also cover
+        // streams that omit those events. Wait for text so empty parts add no rows.
+        const boundary = previous !== undefined && (this.#ended || changed);
+        const trailing = this.#tail.match(/\n{0,2}$/u)?.[0].length ?? 0;
+        const leading = event.delta.match(/^\n{0,2}/u)?.[0].length ?? 0;
+        const prefix = boundary ? "\n".repeat(Math.max(0, 2 - trailing - leading)) : "";
+        const text = prefix + event.delta;
+        this.#tail = (this.#tail + text).slice(-2);
+        this.#part = part;
+        this.#ended = false;
+        return text;
+    }
+}
+function index(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}

package/dist/providers/openai-wire.js

@@ -45,7 +45,7 @@ export function stopNotice(data) {
         return data.status === "incomplete" ? "[incomplete response]" : undefined;
     }
     return reason === "max_output_tokens"
-        ? "[truncated: hit max_output_tokens — raise --max-tokens]"
+        ? "[truncated: hit max_output_tokens — raise max output tokens in /settings]"
         : `[incomplete: ${reason}]`;
 }
 export function fromWireResponse(data, providerId = "openai") {

package/dist/providers/openai.js

@@ -11,6 +11,7 @@ import { EFFORTS, requireSupportedEffort } from "../effort.js";
 import { isRetryableGenerationFailure, isRetryableReadFailure, throwProviderError, } from "./failure.js";
 import { assembleOpenAI, openAIStreamProgress } from "./openai-stream.js";
 import { fromWireResponse, stopNotice, toWireItems, toWireTool, } from "./openai-wire.js";
+import { measureResponsesInput, responsesTokenization } from "./input-measurement.js";
 const ENDPOINT = "https://api.openai.com/v1/responses";
 const MODELS = "https://api.openai.com/v1/models";
 const KEY = "OPENAI_API_KEY";
@@ -87,7 +88,8 @@ export const openai = {
     async contextWindow(model) {
         return openAIContextWindow(model);
     },
-    location: () => "cloud",
+    measureInput: (request, signal) => measureResponsesInput(request, ID, signal),
+    inputTokenization: (model) => responsesTokenization(model, ID),
     async send(req) {
         const key = requireKey();
         const effort = requireSupportedEffort(req.model, req.effort, openAIEfforts(req.model));

package/dist/sessions/bucket.js

@@ -0,0 +1,55 @@
+// Stable workspace identity and directory anchors shared by session operations.
+import { createHash } from "node:crypto";
+import { realpath } from "node:fs/promises";
+import * as path from "node:path";
+import { assertDirectoryAnchor, captureDirectDirectory, preparePrivateDirectory, } from "../directory-anchor.js";
+import { DIRECTORY_MODE, SESSION_NAME } from "./files.js";
+export class SessionBucket {
+    workspaceRoot;
+    workspaceDigest;
+    anchor;
+    #root;
+    constructor(workspaceRoot, root, anchor) {
+        this.workspaceRoot = workspaceRoot;
+        this.workspaceDigest = digestWorkspace(workspaceRoot);
+        this.#root = root;
+        this.anchor = anchor;
+        Object.freeze(this);
+    }
+    static async open(workspaceRoot, sessionsRoot) {
+        const canonical = await realpath(path.resolve(workspaceRoot));
+        const digest = digestWorkspace(canonical);
+        const root = await preparePrivateDirectory(path.resolve(sessionsRoot), "session storage root", DIRECTORY_MODE);
+        const anchor = await preparePrivateDirectory(path.join(root.path, digest), "workspace session directory", DIRECTORY_MODE);
+        return new SessionBucket(canonical, root, anchor);
+    }
+    directory(id) {
+        return path.join(this.anchor.path, id);
+    }
+    async captureSession(id) {
+        await this.assert();
+        return captureDirectDirectory(this.directory(id), "session directory");
+    }
+    async assertSession(anchor) {
+        await Promise.all([this.assert(), assertDirectoryAnchor(anchor)]);
+    }
+    async assert() {
+        await Promise.all([assertDirectoryAnchor(this.#root), assertDirectoryAnchor(this.anchor)]);
+    }
+    assertWorkspace(meta, id) {
+        if (meta.id !== id || meta.workspaceDigest !== this.workspaceDigest ||
+            workspaceKey(meta.workspaceRoot) !== workspaceKey(this.workspaceRoot))
+            throw new Error("session belongs to a different workspace");
+    }
+}
+function digestWorkspace(workspaceRoot) {
+    return createHash("sha256").update(workspaceKey(workspaceRoot)).digest("hex");
+}
+export function workspaceKey(workspaceRoot) {
+    const normalized = path.normalize(workspaceRoot);
+    return process.platform === "win32" ? normalized.toLocaleLowerCase("en-US") : normalized;
+}
+export function assertSessionId(id) {
+    if (!SESSION_NAME.test(id))
+        throw new Error("session id is invalid");
+}