@giovannijecha/jecode 0.8.2 → 0.8.4

package/dist/providers/openai-stream.js

@@ -4,40 +4,70 @@
 // 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) {
+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);
                     }
                     items.push(event.item);
                 }
@@ -66,7 +96,12 @@ 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 +117,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-wire.js

@@ -1,6 +1,7 @@
 // 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.
+import { toolInputFromJson } from "./tool-input.js";
 import { wireTokenCount } from "./wire-usage.js";
 export function toWireTool(tool) {
     return {
@@ -73,7 +74,7 @@ export function fromWireResponse(data, providerId = "openai") {
                     kind: "tool_call",
                     id: item.call_id,
                     name: item.name,
-                    input: parseArguments(item.arguments),
+                    ...toolInputFromJson(item.arguments),
                 });
             }
             else {
@@ -106,18 +107,3 @@ function normalizeUsage(data) {
         reasoningTokens: wireTokenCount(usage.output_tokens_details?.reasoning_tokens),
     };
 }
-// Arguments arrive as a JSON string and models vary in how they escape it, so
-// this always goes through a real parse — never string matching.
-function parseArguments(text) {
-    if (text === undefined || text === "")
-        return {};
-    try {
-        const parsed = JSON.parse(text);
-        return typeof parsed === "object" && parsed !== null
-            ? parsed
-            : {};
-    }
-    catch {
-        return {};
-    }
-}

package/dist/providers/openai.js

@@ -87,7 +87,7 @@ export const openai = {
             include: ["reasoning.encrypted_content"],
             stream: true,
         }, req.maxTokens, req.signal, req.onStatus);
-        const data = await assembleOpenAI(events, req.onStream);
+        const data = await assembleOpenAI(events, req.onStream, req.onStatus);
         const notice = stopNotice(data);
         if (notice !== undefined)
             req.onStream?.({ kind: "text", text: `\n${notice}` });

package/dist/providers/sse.js

@@ -4,31 +4,44 @@
 // `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;
     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 { done, value } = await deadline.wait(reader.read());
+                    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)
                 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 {
@@ -37,6 +50,21 @@ export async function* readSseJson(body, maximumChars) {
         reader.releaseLock();
     }
 }
+function eventDeadline(idle) {
+    if (idle === undefined)
+        return { wait: (pending) => pending, clear: () => undefined };
+    let timer;
+    const expired = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(idle.error()), idle.milliseconds);
+    });
+    return {
+        wait: (pending) => Promise.race([pending, expired]),
+        clear: () => {
+            if (timer !== undefined)
+                clearTimeout(timer);
+        },
+    };
+}
 // 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/providers/tool-input.js

@@ -0,0 +1,17 @@
+// Provider-neutral validation for tool arguments crossing a wire boundary.
+export function toolInputFromJson(text) {
+    if (text === undefined || text.trim() === "")
+        return { input: {} };
+    try {
+        return toolInputFromValue(JSON.parse(text));
+    }
+    catch {
+        return { input: {}, inputError: "tool arguments were not valid JSON" };
+    }
+}
+export function toolInputFromValue(value) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return { input: value };
+    }
+    return { input: {}, inputError: "tool arguments must be a JSON object" };
+}

package/dist/sessions/catalog.js

@@ -0,0 +1,199 @@
+// Small, head-tied projections for the resume catalogue.
+//
+// Conversation nodes remain authoritative and are fully decoded when a
+// session is selected. This auxiliary record lets listing stay independent of
+// every unselected tree's depth; a missing or suspect record falls back to the
+// strict loader and can be rebuilt without changing the session schema.
+import { Buffer } from "node:buffer";
+import { CONVERSATION_LIMITS } from "../conversation.js";
+import { leadingText } from "../text-boundary.js";
+import { decodeHead, encodeHead } from "./codec.js";
+export const SESSION_CATALOG_FILE = "catalog.json";
+export const SESSION_CHECKPOINT_FILE = ".checkpoint";
+export const SESSION_CATALOG_BYTES = 4 * 1_024;
+const CATALOG_SCHEMA = 1;
+const PREVIEW_CODE_UNITS = 160;
+export function sessionCatalog(meta, head, conversation) {
+    assertActiveHead(head, conversation);
+    const resumable = conversation.latestResumable();
+    return own({
+        version: CATALOG_SCHEMA,
+        id: meta.id,
+        workspaceDigest: meta.workspaceDigest,
+        createdAt: meta.createdAt,
+        head,
+        resumeNodeId: resumable?.activeNodeId ?? 0,
+        turns: resumable === undefined ? 0 : selectedTurnCount(resumable),
+        preview: resumable === undefined ? "" : firstUserText(resumable),
+    });
+}
+/** Advance the common linear checkpoint path without walking prior turns. */
+export function advanceSessionCatalog(previous, meta, head, conversation) {
+    assertActiveHead(head, conversation);
+    if (previous.id !== meta.id ||
+        previous.workspaceDigest !== meta.workspaceDigest ||
+        previous.createdAt !== meta.createdAt)
+        throw new Error("session catalogue does not match its metadata");
+    const active = conversation.activeNode;
+    const revisesHead = active.id === previous.head.nodeId &&
+        active.parentId === previous.head.parentId &&
+        active.revision === previous.head.revision + 1;
+    const extendsHead = active.parentId === previous.head.nodeId &&
+        active.id > previous.head.nodeId && active.revision === 1;
+    if (!revisesHead && !extendsHead)
+        return sessionCatalog(meta, head, conversation);
+    // A resumable child of an unfinished head makes that intermediate node part
+    // of the selected path. Rebuild in that uncommon case so the turn count is
+    // exact instead of assuming one visible turn was appended.
+    if (extendsHead && active.settlement !== "checkpointed" &&
+        previous.resumeNodeId !== previous.head.nodeId)
+        return sessionCatalog(meta, head, conversation);
+    if (active.settlement === "checkpointed" && previous.resumeNodeId === active.id) {
+        return sessionCatalog(meta, head, conversation);
+    }
+    const resumable = active.settlement !== "checkpointed";
+    const addsTurn = resumable && previous.resumeNodeId !== active.id;
+    const turns = previous.turns + (addsTurn ? 1 : 0);
+    const preview = turns === 0
+        ? ""
+        : previous.turns === 0
+            ? firstUserTextInNode(active)
+            : previous.preview;
+    return own({
+        version: CATALOG_SCHEMA,
+        id: meta.id,
+        workspaceDigest: meta.workspaceDigest,
+        createdAt: meta.createdAt,
+        head,
+        resumeNodeId: resumable ? active.id : previous.resumeNodeId,
+        turns,
+        preview,
+    });
+}
+export function encodeSessionCatalog(catalog) {
+    const encoded = `${JSON.stringify(catalog, null, 2)}\n`;
+    decodeSessionCatalog(JSON.parse(encoded));
+    if (Buffer.byteLength(encoded, "utf8") > SESSION_CATALOG_BYTES) {
+        throw new Error("session catalogue data is invalid or unsupported");
+    }
+    return encoded;
+}
+export function decodeSessionCatalog(value) {
+    if (!record(value) || !keys(value, "createdAt,head,id,preview,resumeNodeId,turns,version,workspaceDigest"))
+        throw invalid();
+    const head = decodeHead(value["head"]);
+    const resumeNodeId = value["resumeNodeId"];
+    const turns = value["turns"];
+    const preview = value["preview"];
+    if (value["version"] !== CATALOG_SCHEMA ||
+        !identifier(value["id"]) ||
+        !digest(value["workspaceDigest"]) ||
+        !timestamp(value["createdAt"]) ||
+        !integer(resumeNodeId, 0) || resumeNodeId > head.nodeId ||
+        !integer(turns, 0) || turns > CONVERSATION_LIMITS.nodes || turns > resumeNodeId ||
+        typeof preview !== "string" || preview.length > PREVIEW_CODE_UNITS ||
+        (resumeNodeId === 0) !== (turns === 0) ||
+        (turns === 0 ? preview !== "" : preview === ""))
+        throw invalid();
+    return Object.freeze({
+        version: CATALOG_SCHEMA,
+        id: value["id"],
+        workspaceDigest: value["workspaceDigest"],
+        createdAt: value["createdAt"],
+        head,
+        resumeNodeId,
+        turns,
+        preview,
+    });
+}
+export function catalogMatches(catalog, meta, head) {
+    return catalog.id === meta.id &&
+        catalog.workspaceDigest === meta.workspaceDigest &&
+        catalog.createdAt === meta.createdAt &&
+        sameSessionHead(catalog.head, head);
+}
+export function sameSessionHead(left, right) {
+    return left.version === right.version &&
+        left.sequence === right.sequence &&
+        left.nodeId === right.nodeId &&
+        left.parentId === right.parentId &&
+        left.revision === right.revision &&
+        left.updatedAt === right.updatedAt;
+}
+function own(value) {
+    encodeHead(value.head);
+    return decodeSessionCatalog(structuredClone(value));
+}
+function assertActiveHead(head, conversation) {
+    const active = conversation.activeNode;
+    if (active === undefined || active.id !== head.nodeId ||
+        active.parentId !== head.parentId || active.revision !== head.revision)
+        throw new Error("session catalogue does not match its conversation head");
+}
+function selectedTurnCount(conversation) {
+    let count = 0;
+    let id = conversation.activeNodeId;
+    while (id !== 0) {
+        count++;
+        id = conversation.node(id)?.parentId ?? 0;
+    }
+    return count;
+}
+function firstUserText(conversation) {
+    const path = [];
+    let id = conversation.activeNodeId;
+    while (id !== 0) {
+        const node = conversation.node(id);
+        if (node === undefined)
+            throw new Error("session catalogue path is incomplete");
+        path.push(node);
+        id = node.parentId;
+    }
+    for (let index = path.length - 1; index >= 0; index--) {
+        const preview = userTextInNode(path[index]);
+        if (preview !== undefined)
+            return preview;
+    }
+    return "Untitled session";
+}
+function firstUserTextInNode(node) {
+    return userTextInNode(node) ?? "Untitled session";
+}
+function userTextInNode(node) {
+    for (const message of node.messages) {
+        if (message.role !== "user")
+            continue;
+        const preview = textPreview(message.content.find((block) => block.kind === "text")?.text);
+        if (preview !== undefined)
+            return preview;
+    }
+    return undefined;
+}
+function textPreview(text) {
+    const normalized = text?.replace(/\s+/gu, " ").trim();
+    return normalized === undefined || normalized === ""
+        ? undefined
+        : leadingText(normalized, PREVIEW_CODE_UNITS);
+}
+function keys(value, expected) {
+    return Object.keys(value).sort().join(",") === expected;
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function integer(value, minimum) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= minimum;
+}
+function identifier(value) {
+    return typeof value === "string" && /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(value);
+}
+function digest(value) {
+    return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
+function timestamp(value) {
+    return typeof value === "string" && value.length >= 20 && value.length <= 64 &&
+        Number.isFinite(Date.parse(value));
+}
+function invalid() {
+    return new Error("session catalogue data is invalid or unsupported");
+}

package/dist/sessions/codec.js

@@ -3,9 +3,10 @@
 // can become conversation or provider input.
 import { Buffer } from "node:buffer";
 import { CONTEXT_LIMITS } from "../context/projection.js";
+import { MAX_TEXT_CODE_UNITS } from "../text-boundary.js";
 export const SESSION_SCHEMA = 4;
 export const SESSION_FILE_LIMITS = Object.freeze({
-    text: 1_048_576,
+    text: MAX_TEXT_CODE_UNITS,
     metadataBytes: 64 * 1_024,
     nodeBytes: 20 * 1_024 * 1_024,
     jsonDepth: 24,

package/dist/sessions/lease.js

@@ -9,6 +9,13 @@ export function sessionLease(id, file, token) {
     let closed = false;
     return Object.freeze({
         id,
+        assertOwned: async () => {
+            if (closed)
+                throw new Error("session lease is closed");
+            const current = await readLease(file);
+            if (current !== token)
+                throw new Error("session lease is no longer owned by this process");
+        },
         close: async () => {
             if (closed)
                 return;

package/dist/sessions/runtime.js

@@ -8,11 +8,13 @@ export class SessionPersistence {
     #store;
     #sessionId;
     #lease;
+    #snapshot;
     #failure;
-    constructor(store, sessionId, lease) {
+    constructor(store, sessionId, lease, snapshot) {
         this.#store = store;
         this.#sessionId = sessionId;
         this.#lease = lease;
+        this.#snapshot = snapshot;
     }
     static fresh(store) {
         return new SessionPersistence(store, null);
@@ -26,7 +28,7 @@ export class SessionPersistence {
                 throw new Error("session has no resumable turn");
             return Object.freeze({
                 conversation,
-                persistence: new SessionPersistence(store, id, lease),
+                persistence: new SessionPersistence(store, id, lease, snapshot),
             });
         }
         catch (error) {
@@ -51,9 +53,14 @@ export class SessionPersistence {
                 const published = await this.#store.publish(conversation, true);
                 this.#lease = published.lease;
                 this.#sessionId = published.meta.id;
+                this.#snapshot = published;
                 return;
             }
-            await this.#store.checkpoint(this.#sessionId, conversation);
+            if (this.#lease === undefined || this.#snapshot === undefined) {
+                throw new Error("session persistence has no verified owner snapshot");
+            }
+            await this.#lease.assertOwned();
+            this.#snapshot = await this.#store.checkpoint(this.#snapshot, conversation);
         }
         catch (error) {
             this.#failure = error;
@@ -64,6 +71,7 @@ export class SessionPersistence {
         await this.#lease?.close();
         this.#lease = undefined;
         this.#sessionId = null;
+        this.#snapshot = undefined;
         this.#failure = undefined;
     }
     async close() {