@giovannijecha/jecode 0.7.2 → 0.7.4

package/dist/conversation.js

@@ -25,32 +25,25 @@ export class ConversationTree {
         return new ConversationTree([], 0);
     }
     static restore(nodes, activeNodeId) {
-        let tree = ConversationTree.empty();
+        if (nodes.length > CONVERSATION_LIMITS.nodes) {
+            throw new Error("conversation reached its session limit — start /new");
+        }
+        const restored = [];
         for (let index = 0; index < nodes.length; index++) {
             const node = nodes[index];
             if (node === undefined || node.id !== index + 1) {
                 throw new Error("session contains a non-sequential conversation node");
             }
-            tree = tree.select(node.parentId).commit({
-                parentId: node.parentId,
-                createdAt: node.createdAt,
-                identity: node.identity,
-                messages: node.messages,
-                blocks: node.blocks,
-                ...(node.context === undefined ? {} : { context: node.context }),
-                ...(node.failure === undefined ? {} : { failure: node.failure }),
-            }, node.settlement);
-            const restored = tree.activeNode;
-            if (restored === undefined || restored.id !== node.id) {
-                throw new Error("session conversation could not be restored");
-            }
-            if (node.revision > 1) {
-                const copy = [...tree.#nodes];
-                copy[node.id - 1] = ownedNode({ ...restored, revision: node.revision });
-                tree = new ConversationTree(copy, node.id);
-            }
+            const owned = ownedNode({ ...node, blocks: settledBlocks(node.blocks) });
+            assertTurn(owned);
+            assertPersistableNode(owned);
+            restored.push(owned);
         }
-        return tree.select(activeNodeId);
+        assertBounds(restored);
+        if (!validNodeId(activeNodeId) ||
+            (activeNodeId !== 0 && restored[activeNodeId - 1]?.id !== activeNodeId))
+            throw new Error("conversation node does not exist");
+        return new ConversationTree(restored, activeNodeId);
     }
     /** Commit or extend the one prospective leaf turn. */
     commit(draft, settlement) {
@@ -236,12 +229,13 @@ function assertBounds(nodes) {
     let messageCodeUnits = 0;
     let transcriptCodeUnits = 0;
     let contextCodeUnits = 0;
+    const contextOwners = [];
     for (const node of nodes) {
         messageCodeUnits += JSON.stringify(node.messages).length;
         transcriptCodeUnits += JSON.stringify(node.blocks).length;
         contextCodeUnits += node.context?.summary.length ?? 0;
         if (node.context !== undefined)
-            assertContextPath(nodes, node);
+            contextOwners.push(node);
     }
     if (messageCodeUnits > CONVERSATION_LIMITS.messageCodeUnits) {
         throw new Error("conversation model history reached its session limit — start /new");
@@ -252,18 +246,41 @@ function assertBounds(nodes) {
     if (contextCodeUnits > CONVERSATION_LIMITS.contextCodeUnits) {
         throw new Error("conversation context summaries reached their session limit — start /new");
     }
+    assertContextPaths(nodes, contextOwners);
 }
-function assertContextPath(nodes, owner) {
-    const context = owner.context;
-    const boundary = nodes[context.throughNodeId - 1];
-    if (boundary === undefined || !validContextAnchor(context, boundary.messages.length)) {
-        throw new Error("turn context checkpoint is invalid");
+function assertContextPaths(nodes, owners) {
+    if (owners.length === 0)
+        return;
+    const children = Array.from({ length: nodes.length + 1 }, () => []);
+    for (const node of nodes)
+        children[node.parentId]?.push(node.id);
+    const entered = new Uint32Array(nodes.length + 1);
+    const exited = new Uint32Array(nodes.length + 1);
+    const stack = [{ id: 0, exit: false }];
+    let clock = 0;
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current.exit) {
+            exited[current.id] = clock++;
+            continue;
+        }
+        entered[current.id] = clock++;
+        stack.push({ id: current.id, exit: true });
+        const descendants = children[current.id];
+        for (let index = descendants.length - 1; index >= 0; index--) {
+            stack.push({ id: descendants[index], exit: false });
+        }
+    }
+    for (const owner of owners) {
+        const context = owner.context;
+        const boundary = nodes[context.throughNodeId - 1];
+        if (boundary === undefined || !validContextAnchor(context, boundary.messages.length)) {
+            throw new Error("turn context checkpoint is invalid");
+        }
+        if (entered[boundary.id] > entered[owner.id] ||
+            exited[owner.id] > exited[boundary.id])
+            throw new Error("turn context checkpoint is outside its branch");
     }
-    let id = owner.id;
-    while (id !== 0 && id !== boundary.id)
-        id = nodes[id - 1]?.parentId ?? 0;
-    if (id !== boundary.id)
-        throw new Error("turn context checkpoint is outside its branch");
 }
 function validNodeId(value) {
     return Number.isSafeInteger(value) && value >= 0;

package/dist/oauth-http.js

@@ -2,6 +2,7 @@
 //
 // These requests never redirect, never retry, and never retain an unbounded
 // response. Authorization codes and refresh tokens must not leak into errors.
+import { leadingText } from "./text-boundary.js";
 const AUTH_ORIGIN = "https://auth.openai.com";
 const TIMEOUT_MS = 15_000;
 const MAX_BODY_CHARS = 64_000;
@@ -96,7 +97,7 @@ function errorDetail(value, secrets) {
     let safe = detail.replace(/[\r\n]+/g, " ");
     for (const secret of secrets)
         safe = safe.replaceAll(secret, "[credential redacted]");
-    return ` · ${safe.slice(0, 300)}`;
+    return ` · ${leadingText(safe, 300)}`;
 }
 function bodySecrets(body) {
     const values = body.contentType === "application/x-www-form-urlencoded"

package/dist/openai-oauth-callback.js

@@ -2,6 +2,7 @@
 import { timingSafeEqual } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { createServer } from "node:http";
+import { leadingText } from "./text-boundary.js";
 const CALLBACK_PORTS = [1455, 1457];
 export const OPENAI_CALLBACK_PATH = "/auth/callback";
 export async function openAICallback(state) {
@@ -42,7 +43,7 @@ export async function openAICallback(state) {
         const authError = incoming.searchParams.get("error_description") ?? incoming.searchParams.get("error");
         const authorizationCode = incoming.searchParams.get("code");
         if (authError !== null) {
-            rejectCode(new Error(`ChatGPT sign-in was rejected · ${authError.slice(0, 300)}`));
+            rejectCode(new Error(`ChatGPT sign-in was rejected · ${leadingText(authError, 300)}`));
         }
         else if (authorizationCode === null || authorizationCode === "") {
             rejectCode(new Error("ChatGPT sign-in returned no authorization code"));

package/dist/providers/anthropic.js

@@ -80,7 +80,7 @@ export const anthropic = {
                 effort: requireSupportedEffort(req.model, req.effort, efforts),
             };
         }
-        const events = await postSse(ENDPOINT, headers(key), body, req.signal, req.onStatus);
+        const events = await postSse(ENDPOINT, headers(key), body, req.maxTokens, req.signal, req.onStatus);
         const data = await assembleAnthropic(events, req.onStream);
         // A refusal or a truncation never arrives as streamed text, so it has to
         // be announced separately or the user watches the turn end in silence.

package/dist/providers/http.js

@@ -1,7 +1,9 @@
 // The entire HTTP layer: one bounded request, then either a JSON body or an
 // event stream. Only idempotent reads retry. Once a POST starts or response
 // bytes flow, a failure is surfaced rather than silently replayed.
+import { leadingText } from "../text-boundary.js";
 import { readSseJson } from "./sse.js";
+import { sseStreamCharacterLimit } from "./stream-limits.js";
 const RETRYABLE = new Set([408, 409, 429, 500, 502, 503, 504]);
 const MAX_JSON_CHARS = 5_000_000;
 const MAX_ERROR_CHARS = 2_000;
@@ -30,14 +32,15 @@ async function asJson(url, res) {
         return JSON.parse(text);
     }
     catch {
-        throw httpError(`${url} returned non-JSON`, res.status, text.slice(0, 500));
+        throw httpError(`${url} returned non-JSON`, res.status, leadingText(text, 500));
     }
 }
-export async function postSse(url, headers, body, signal, onStatus) {
+export async function postSse(url, headers, body, maxOutputTokens, signal, onStatus) {
+    const maximumChars = sseStreamCharacterLimit(maxOutputTokens);
     const res = await request(url, { accept: "text/event-stream", ...headers }, body, signal, onStatus);
     if (res.body === null)
         throw httpError(`${url} returned no body`, res.status);
-    return readSseJson(withIdleTimeout(url, res.body));
+    return readSseJson(withIdleTimeout(url, res.body), maximumChars);
 }
 async function request(url, headers, body, signal, onStatus) {
     const maxRetries = body === undefined ? GET_RETRIES : 0;
@@ -105,13 +108,13 @@ async function boundedText(url, res, max) {
             if (done) {
                 text += decoder.decode();
                 return text.length > max
-                    ? { text: text.slice(0, max), truncated: true }
+                    ? { text: leadingText(text, max), truncated: true }
                     : { text, truncated: false };
             }
             text += decoder.decode(value, { stream: true });
             if (text.length > max) {
                 await reader.cancel().catch(() => undefined);
-                return { text: text.slice(0, max), truncated: true };
+                return { text: leadingText(text, max), truncated: true };
             }
         }
     }

package/dist/providers/ollama.js

@@ -88,7 +88,7 @@ export const ollama = {
             max_tokens: req.maxTokens,
             reasoning_effort: effort,
             stream: true,
-        }, req.signal, req.onStatus);
+        }, req.maxTokens, req.signal, req.onStatus);
         const reply = await assembleOllama(events, req.onStream);
         const notice = stopNotice(reply);
         if (notice !== undefined)

package/dist/providers/openai-codex.js

@@ -71,7 +71,7 @@ export const openaiCodex = {
                 text: { verbosity: "low" },
                 include: ["reasoning.encrypted_content"],
                 prompt_cache_key: SESSION_ID,
-            }, req.signal, req.onStatus);
+            }, req.maxTokens, req.signal, req.onStatus);
             const data = await assembleOpenAI(events, req.onStream);
             const notice = stopNotice(data);
             if (notice !== undefined)
@@ -152,8 +152,6 @@ function modelContextWindow(entry) {
         return undefined;
     const percent = percentage(entry["effective_context_window_percent"]) ?? 95;
     const tokens = Math.floor(resolved * percent / 100);
-    if (!validTokenCount(tokens))
-        return undefined;
     const automatic = Math.floor(resolved * 9 / 10);
     const advertised = tokenCount(entry["auto_compact_token_limit"]);
     return Object.freeze({

package/dist/providers/openai.js

@@ -86,7 +86,7 @@ export const openai = {
             store: false,
             include: ["reasoning.encrypted_content"],
             stream: true,
-        }, req.signal, req.onStatus);
+        }, req.maxTokens, req.signal, req.onStatus);
         const data = await assembleOpenAI(events, req.onStream);
         const notice = stopNotice(data);
         if (notice !== undefined)

package/dist/providers/sse.js

@@ -3,41 +3,30 @@
 // The format is small: `field: value` lines, a blank line ends an event. Only
 // `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, MAX_SSE_STREAM_CHARS, } from "./stream-limits.js";
-export async function* readSseJson(body) {
+import { addBounded, MAX_SSE_EVENT_CHARS, } from "./stream-limits.js";
+export async function* readSseJson(body, maximumChars) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
-    let buffer = "";
+    const parser = new SseEventParser();
     let finished = false;
     let total = 0;
-    const append = (text) => {
-        total = addBounded(total, text.length, MAX_SSE_STREAM_CHARS, "SSE stream");
-        buffer += text;
-    };
     try {
         for (;;) {
             const { done, value } = await reader.read();
             if (done)
                 break;
-            append(decoder.decode(value, { stream: true }));
-            for (;;) {
-                const boundary = findBoundary(buffer);
-                if (boundary === undefined)
-                    break;
-                assertEventSize(boundary.start);
-                const chunk = buffer.slice(0, boundary.start);
-                buffer = buffer.slice(boundary.end);
-                const payload = parseData(chunk);
-                if (payload !== undefined)
-                    yield payload;
-            }
-            assertEventSize(buffer.length);
+            const text = decoder.decode(value, { stream: true });
+            total = addBounded(total, text.length, maximumChars, "SSE stream");
+            for (const payload of parser.push(text))
+                yield payload;
         }
         // A stream that ends without a trailing blank line still owes us its last
         // event.
-        append(decoder.decode());
-        assertEventSize(buffer.length);
-        const payload = parseData(buffer);
+        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;
@@ -48,28 +37,116 @@ export async function* readSseJson(body) {
         reader.releaseLock();
     }
 }
+// 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.
+class TextParts {
+    #groups = [];
+    #pieces = [];
+    #lastCodeUnit = "";
+    length = 0;
+    append(text) {
+        if (text === "")
+            return;
+        this.#pieces.push(text);
+        this.#lastCodeUnit = text.at(-1);
+        this.length += text.length;
+        if (this.#pieces.length >= 256)
+            this.#flush();
+    }
+    take() {
+        this.#flush();
+        const text = this.#groups.length === 1 ? this.#groups[0] : this.#groups.join("");
+        this.#groups.length = 0;
+        this.#lastCodeUnit = "";
+        this.length = 0;
+        return text;
+    }
+    endsWithCarriageReturn() {
+        return this.#lastCodeUnit === "\r";
+    }
+    #flush() {
+        if (this.#pieces.length === 0)
+            return;
+        this.#groups.push(this.#pieces.length === 1 ? this.#pieces[0] : this.#pieces.join(""));
+        this.#pieces = [];
+    }
+}
+export class SseEventParser {
+    #line = new TextParts();
+    #data = [];
+    #eventLength = 0;
+    #hasLine = false;
+    #pendingTerminatorLength = 0;
+    *push(text) {
+        let start = 0;
+        for (;;) {
+            const newline = text.indexOf("\n", start);
+            if (newline === -1) {
+                this.#line.append(text.slice(start));
+                this.#assertPendingLineSize();
+                return;
+            }
+            this.#line.append(text.slice(start, newline));
+            const rawLine = this.#line.take();
+            const crlf = rawLine.endsWith("\r");
+            const line = crlf ? rawLine.slice(0, -1) : rawLine;
+            if (line === "") {
+                const payload = this.#finishEvent();
+                if (payload !== undefined)
+                    yield payload;
+            }
+            else {
+                this.#appendLine(line, crlf ? 2 : 1);
+            }
+            start = newline + 1;
+        }
+    }
+    finish() {
+        const line = this.#line.take();
+        if (line !== "") {
+            this.#appendLine(line, 0);
+        }
+        else if (this.#hasLine) {
+            // A single trailing line terminator is part of an unterminated event.
+            assertEventSize(this.#eventLength + this.#pendingTerminatorLength);
+        }
+        return this.#finishEvent();
+    }
+    #appendLine(line, terminatorLength) {
+        const separatorLength = this.#hasLine ? this.#pendingTerminatorLength : 0;
+        assertEventSize(this.#eventLength + separatorLength + line.length);
+        this.#eventLength += separatorLength + line.length;
+        this.#hasLine = true;
+        this.#pendingTerminatorLength = terminatorLength;
+        if (line.startsWith("data:")) {
+            this.#data.push(line.slice("data:".length).trimStart());
+        }
+    }
+    #assertPendingLineSize() {
+        const separatorLength = this.#hasLine ? this.#pendingTerminatorLength : 0;
+        const remaining = MAX_SSE_EVENT_CHARS - this.#eventLength - separatorLength;
+        // One trailing CR may turn out to be part of a split CRLF terminator.
+        const splitCrlf = this.#line.length === remaining + 1 && this.#line.endsWithCarriageReturn();
+        if (this.#line.length > remaining && !splitCrlf) {
+            assertEventSize(MAX_SSE_EVENT_CHARS + 1);
+        }
+    }
+    #finishEvent() {
+        const data = this.#data.join("\n");
+        this.#data = [];
+        this.#eventLength = 0;
+        this.#hasLine = false;
+        this.#pendingTerminatorLength = 0;
+        return parseData(data);
+    }
+}
 function assertEventSize(length) {
     if (length > MAX_SSE_EVENT_CHARS) {
         throw new Error(`SSE event exceeded ${MAX_SSE_EVENT_CHARS} characters`);
     }
 }
-// Handles both LF and CRLF framing without normalising the buffer first — a
-// normalising pass would have to cope with a \r\n split across two chunks.
-function findBoundary(buffer) {
-    const lf = buffer.indexOf("\n\n");
-    const crlf = buffer.indexOf("\r\n\r\n");
-    if (lf === -1 && crlf === -1)
-        return undefined;
-    if (crlf !== -1 && (lf === -1 || crlf < lf))
-        return { start: crlf, end: crlf + 4 };
-    return { start: lf, end: lf + 2 };
-}
-function parseData(chunk) {
-    const data = chunk
-        .split(/\r?\n/)
-        .filter((line) => line.startsWith("data:"))
-        .map((line) => line.slice("data:".length).trimStart())
-        .join("\n");
+function parseData(data) {
     if (data === "" || data === "[DONE]")
         return undefined;
     try {

package/dist/providers/stream-limits.js

@@ -1,8 +1,20 @@
 // Response streams are remote input. Bound the pieces that otherwise grow
-// independently of the request's output-token setting.
+// independently, while letting a larger requested output carry its necessarily
+// larger framing, terminal envelope, and opaque reasoning payloads.
 export const MAX_SSE_EVENT_CHARS = 1_000_000;
-export const MAX_SSE_STREAM_CHARS = 4_000_000;
+export const MAX_SSE_STREAM_CHARS = 256_000_000;
 export const MAX_TOOL_ARGUMENT_CHARS = 1_000_000;
+const MIN_SSE_STREAM_CHARS = 4_000_000;
+const SSE_CHARS_PER_OUTPUT_TOKEN = 512;
+export function sseStreamCharacterLimit(maxOutputTokens) {
+    if (!Number.isSafeInteger(maxOutputTokens) || maxOutputTokens <= 0) {
+        throw new Error("max output tokens must be a positive safe integer");
+    }
+    const scaled = maxOutputTokens > Math.floor(MAX_SSE_STREAM_CHARS / SSE_CHARS_PER_OUTPUT_TOKEN)
+        ? MAX_SSE_STREAM_CHARS
+        : maxOutputTokens * SSE_CHARS_PER_OUTPUT_TOKEN;
+    return Math.max(MIN_SSE_STREAM_CHARS, scaled);
+}
 export function addBounded(total, added, maximum, label) {
     if (added > maximum - total) {
         throw new Error(`${label} exceeded ${maximum} characters`);

package/dist/sessions/store.js

@@ -8,6 +8,7 @@ import { chmod, lstat, mkdir, open, opendir, readFile, readdir, realpath, rename
 import * as path from "node:path";
 import { atomicWrite } from "../atomic.js";
 import { CONVERSATION_LIMITS, ConversationTree } from "../conversation.js";
+import { leadingText } from "../text-boundary.js";
 import { userDataPath } from "../user-data.js";
 import { decodeHead, decodeMeta, decodeNode, encodeHead, encodeMeta, encodeNode, SESSION_FILE_LIMITS, SESSION_SCHEMA, } from "./codec.js";
 import { leaseOwner, leaseToken, pidIsAlive, removeLease, sessionLease, } from "./lease.js";
@@ -367,7 +368,7 @@ function firstUserText(conversation) {
         const text = message.content.find((block) => block.kind === "text")?.text
             .replace(/\s+/gu, " ").trim();
         if (text !== undefined && text !== "")
-            return text.slice(0, 160);
+            return leadingText(text, 160);
     }
     return "Untitled session";
 }

package/dist/text-boundary.js

@@ -0,0 +1,47 @@
+// Shared grapheme boundaries for every projection of user-visible text.
+const SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+export function segmentGraphemes(text) {
+    return SEGMENTER.segment(text);
+}
+export function graphemes(text) {
+    const out = [];
+    for (const { segment } of segmentGraphemes(text))
+        out.push(segment);
+    return out;
+}
+/** Largest complete grapheme boundary no greater than a UTF-16 offset. */
+export function graphemeFloor(text, offset) {
+    const target = Math.max(0, Math.min(text.length, offset));
+    if (target === 0 || target === text.length)
+        return target;
+    const containing = segmentGraphemes(text).containing(target);
+    if (containing === undefined || containing.index === target)
+        return target;
+    return containing.index;
+}
+/** Smallest complete grapheme boundary no less than a UTF-16 offset. */
+export function graphemeCeiling(text, offset) {
+    const target = Math.max(0, Math.min(text.length, offset));
+    if (target === 0 || target === text.length)
+        return target;
+    const containing = segmentGraphemes(text).containing(target);
+    if (containing === undefined || containing.index === target)
+        return target;
+    return containing.index + containing.segment.length;
+}
+/** Keep a bounded prefix without returning part of a user-perceived character. */
+export function leadingText(text, maxCodeUnits) {
+    if (maxCodeUnits <= 0)
+        return "";
+    if (text.length <= maxCodeUnits)
+        return text;
+    return text.slice(0, graphemeFloor(text, maxCodeUnits));
+}
+/** Keep a bounded suffix without returning part of a user-perceived character. */
+export function trailingText(text, maxCodeUnits) {
+    if (maxCodeUnits <= 0)
+        return "";
+    if (text.length <= maxCodeUnits)
+        return text;
+    return text.slice(graphemeCeiling(text, text.length - maxCodeUnits));
+}

package/dist/timeline.js

@@ -3,6 +3,7 @@
 // Selecting a node changes only the in-memory path. The next real user turn
 // is what persists a branch, so opening or cancelling this control plane can
 // never create empty history.
+import { leadingText } from "./text-boundary.js";
 import { usageFromHistory } from "./usage.js";
 import { heading } from "./tui/picker.js";
 export function timelinePicker(conversation, palette) {
@@ -83,7 +84,7 @@ function preview(node) {
         const text = message.content.find((block) => block.kind === "text")?.text
             .replace(/\s+/gu, " ").trim();
         if (text !== undefined && text !== "")
-            return text.slice(0, 160);
+            return leadingText(text, 160);
     }
     return "Untitled turn";
 }