antechamber 0.0.0-stage → 0.1.0

package/dist/config.js

@@ -0,0 +1,40 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+/** Environment variable prefix for all antechamber settings. */
+export const ENV_PREFIX = "ANTECHAMBER_";
+/** Prefix used before the project was renamed; still honoured as a fallback. */
+const LEGACY_ENV_PREFIX = "OCPI_";
+/**
+ * Reads `ANTECHAMBER_<name>`, falling back to the deprecated `OCPI_<name>`.
+ * Blank values count as unset.
+ */
+export function envSetting(name, env = process.env) {
+    for (const key of [ENV_PREFIX + name, LEGACY_ENV_PREFIX + name]) {
+        const value = env[key];
+        if (value !== undefined && value.trim() !== "")
+            return value;
+    }
+    return undefined;
+}
+/**
+ * Default registry/state directory. Prefers `~/.config/antechamber`; when only
+ * the pre-rename directory exists it keeps using that so existing session
+ * mappings survive the upgrade.
+ */
+export function defaultStateDir(home = homedir(), exists = existsSync) {
+    const config = join(home, ".config");
+    const current = join(config, "antechamber");
+    const legacy = join(config, "openchamber-pi-connector");
+    if (!exists(current) && exists(legacy))
+        return legacy;
+    return current;
+}
+/** Agent executable spawned per session: OmO by default, plain pi when configured. */
+export function agentBinary(env = process.env) {
+    return envSetting("PI_BINARY", env) ?? "omo";
+}
+/** True when the configured backend is upstream pi rather than OmO. */
+export function isPlainPi(env = process.env) {
+    return basename(agentBinary(env)).replace(/\.(exe|cmd)$/i, "") === "pi";
+}

package/dist/http.d.ts

@@ -0,0 +1,18 @@
+/** Shared HTTP body, response, authentication, and CORS plumbing. */
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare function serverPassword(): string | undefined;
+export declare function isLoopbackHost(host: string): boolean;
+export declare function errorBody(name: string, message: string): {
+    name: string;
+    data: {
+        message: string;
+    };
+};
+export declare function json(res: ServerResponse, status: number, body: unknown): void;
+export declare class Http {
+    private readonly credentials;
+    private readonly maxBodyBytes;
+    constructor();
+    route(req: IncomingMessage, res: ServerResponse, handle: () => Promise<void>): Promise<void>;
+    body(req: IncomingMessage): Promise<unknown>;
+}

package/dist/http.js

@@ -0,0 +1,168 @@
+/** Shared HTTP body, response, authentication, and CORS plumbing. */
+import { createHash, timingSafeEqual } from "node:crypto";
+import { ApprovalInputError } from "./approvals.js";
+import { envSetting } from "./config.js";
+const DEFAULT_MAX_BODY_BYTES = 10 * 1024 * 1024;
+class RequestBodyError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = status === 413 ? "PayloadTooLargeError" : "InvalidRequestError";
+    }
+}
+export function serverPassword() {
+    return process.env.OPENCODE_SERVER_PASSWORD || envSetting("SERVER_PASSWORD");
+}
+export function isLoopbackHost(host) {
+    if (["localhost", "::1", "[::1]"].includes(host.toLowerCase()))
+        return true;
+    return /^127(?:\.\d{1,3}){3}$/.test(host) && host.split(".").every((part) => Number(part) <= 255);
+}
+function allowedOrigin(origin) {
+    try {
+        const url = new URL(origin);
+        if (!/^https?:\/\/[^/?#]+$/.test(origin) ||
+            url.pathname !== "/" ||
+            url.username !== "" ||
+            url.password !== "" ||
+            url.search !== "" ||
+            url.hash !== "")
+            return false;
+        return (["localhost", "127.0.0.1", "[::1]"].includes(url.hostname) ||
+            (envSetting("ALLOWED_ORIGINS") ?? "").split(",").some((entry) => entry.trim() === origin));
+    }
+    catch {
+        return false;
+    }
+}
+export function errorBody(name, message) {
+    return { name, data: { message } };
+}
+export function json(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, { "Content-Type": "application/json" }).end(payload);
+}
+export class Http {
+    credentials;
+    maxBodyBytes;
+    constructor() {
+        const maxBodyBytes = Number(envSetting("MAX_BODY_BYTES"));
+        this.maxBodyBytes = Number.isSafeInteger(maxBodyBytes) && maxBodyBytes > 0 ? maxBodyBytes : DEFAULT_MAX_BODY_BYTES;
+        const password = serverPassword();
+        this.credentials =
+            password === undefined
+                ? undefined
+                : createHash("sha256")
+                    .update(`${process.env.OPENCODE_SERVER_USERNAME || "opencode"}:${password}`)
+                    .digest();
+    }
+    async route(req, res, handle) {
+        res.setHeader("Vary", "Origin");
+        const origin = req.headers.origin;
+        if (origin !== undefined) {
+            if (allowedOrigin(origin)) {
+                res.setHeader("Access-Control-Allow-Origin", origin);
+                res.setHeader("Access-Control-Allow-Credentials", "true");
+            }
+            else if (this.credentials === undefined) {
+                // Without a password the Origin check is the only guard against
+                // drive-by browser requests. With one, the password is the boundary:
+                // OpenChamber's proxy forwards its own clients' Origin (LAN pages,
+                // the desktop app), which must not be rejected.
+                json(res, 403, errorBody("ForbiddenError", "Origin is not allowed"));
+                return;
+            }
+        }
+        if (this.credentials !== undefined) {
+            const match = req.headers.authorization?.match(/^Basic\s+([A-Za-z0-9+/]+=*)$/i);
+            const supplied = createHash("sha256")
+                .update(Buffer.from(match?.[1] ?? "", "base64"))
+                .digest();
+            if (!match || !timingSafeEqual(this.credentials, supplied)) {
+                res.setHeader("WWW-Authenticate", 'Basic realm="OpenCode"');
+                json(res, 401, errorBody("UnauthorizedError", "Authentication required"));
+                return;
+            }
+        }
+        res.setHeader("Access-Control-Allow-Methods", "GET,POST,PUT,PATCH,DELETE,OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, x-opencode-directory");
+        if (req.method === "OPTIONS") {
+            res.writeHead(204).end();
+            return;
+        }
+        try {
+            await handle();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (err instanceof RequestBodyError && err.status === 413) {
+                res.setHeader("Connection", "close");
+                res.once("finish", () => req.destroy());
+            }
+            json(res, err instanceof RequestBodyError ? err.status : err instanceof ApprovalInputError ? 400 : 500, errorBody(err instanceof RequestBodyError
+                ? err.name
+                : err instanceof ApprovalInputError
+                    ? "InvalidRequestError"
+                    : "UnknownError", message));
+        }
+    }
+    body(req) {
+        if (Number(req.headers["content-length"]) > this.maxBodyBytes) {
+            req.pause();
+            return Promise.reject(new RequestBodyError(413, `Request body exceeds ${this.maxBodyBytes} bytes`));
+        }
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            let bytes = 0;
+            const cleanup = () => {
+                req.off("data", onData);
+                req.off("end", onEnd);
+                req.off("error", onError);
+                req.off("aborted", onAborted);
+            };
+            const onError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            const onAborted = () => onError(new RequestBodyError(400, "Request body was aborted"));
+            const onData = (chunk) => {
+                bytes += chunk.length;
+                if (bytes > this.maxBodyBytes) {
+                    req.pause();
+                    chunks.length = 0;
+                    onError(new RequestBodyError(413, `Request body exceeds ${this.maxBodyBytes} bytes`));
+                    return;
+                }
+                chunks.push(chunk);
+            };
+            const onEnd = () => {
+                cleanup();
+                if (bytes === 0) {
+                    resolve({});
+                    return;
+                }
+                let body;
+                try {
+                    body = JSON.parse(Buffer.concat(chunks, bytes).toString("utf8"));
+                }
+                catch {
+                    reject(new RequestBodyError(400, "Request body must be valid JSON"));
+                    return;
+                }
+                if (body === null ||
+                    typeof body !== "object" ||
+                    Array.isArray(body) ||
+                    Object.getPrototypeOf(body) !== Object.prototype) {
+                    reject(new RequestBodyError(400, "Request body must be a JSON object"));
+                    return;
+                }
+                resolve(body);
+            };
+            req.on("data", onData);
+            req.once("end", onEnd);
+            req.once("error", onError);
+            req.once("aborted", onAborted);
+        });
+    }
+}

package/dist/lifecycle.d.ts

@@ -0,0 +1,43 @@
+import type { ManagedSession } from "./sessions.js";
+/** Time and scheduling seams shared by the reaper and process shutdown tests. */
+export interface LifecycleClock {
+    now(): number;
+    setInterval(callback: () => void, ms: number): ReturnType<typeof setInterval>;
+    clearInterval(timer: ReturnType<typeof setInterval>): void;
+    setTimeout(callback: () => void, ms: number): ReturnType<typeof setTimeout>;
+    clearTimeout(timer: ReturnType<typeof setTimeout>): void;
+}
+export declare const systemClock: LifecycleClock;
+export interface LifecycleOptions {
+    clock?: LifecycleClock;
+    idleTimeoutMs?: number;
+    maxLive?: number;
+    reaperIntervalMs?: number;
+}
+/** Serializes admission, reaping, removal and shutdown, including in-flight spawns. */
+export declare class SessionLifecycle {
+    private sessions;
+    readonly clock: LifecycleClock;
+    private readonly idleTimeoutMs;
+    private readonly maxLive;
+    private readonly reaperIntervalMs;
+    private readonly timer;
+    private readonly used;
+    private readonly active;
+    private readonly disposing;
+    private tail;
+    private stopped;
+    private stopping;
+    constructor(sessions: () => Iterable<ManagedSession>, options?: LifecycleOptions);
+    touch(s: ManagedSession): void;
+    private idle;
+    /** Protect the caller across awaits, including admission of a dormant session. */
+    use<T>(s: ManagedSession, action: () => Promise<T>): Promise<T>;
+    run<T>(action: () => Promise<T>): Promise<T>;
+    private enqueue;
+    /** Called inside run(), before a process is spawned. */
+    makeRoom(): Promise<void>;
+    dormant(s: ManagedSession): Promise<void>;
+    reap(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/lifecycle.js

@@ -0,0 +1,138 @@
+import { ENV_PREFIX, envSetting } from "./config.js";
+const MAX_REAPER_INTERVAL_MS = 15_000;
+export const systemClock = {
+    now: Date.now,
+    setInterval,
+    clearInterval,
+    setTimeout,
+    clearTimeout,
+};
+function positiveEnv(name, fallback) {
+    const value = Number(envSetting(name) ?? fallback);
+    if (!Number.isSafeInteger(value) || value <= 0)
+        throw new Error(`${ENV_PREFIX}${name} must be a positive integer`);
+    return value;
+}
+/** Serializes admission, reaping, removal and shutdown, including in-flight spawns. */
+export class SessionLifecycle {
+    sessions;
+    clock;
+    idleTimeoutMs;
+    maxLive;
+    reaperIntervalMs;
+    timer;
+    used = new WeakMap();
+    active = new WeakMap();
+    disposing = new Set();
+    tail = Promise.resolve();
+    stopped = false;
+    stopping;
+    constructor(sessions, options = {}) {
+        this.sessions = sessions;
+        this.clock = options.clock ?? systemClock;
+        this.idleTimeoutMs = options.idleTimeoutMs ?? positiveEnv("IDLE_TIMEOUT_MS", 900_000);
+        this.maxLive = options.maxLive ?? positiveEnv("MAX_LIVE", 8);
+        this.reaperIntervalMs =
+            options.reaperIntervalMs ?? Math.min(MAX_REAPER_INTERVAL_MS, Math.max(1_000, Math.floor(this.idleTimeoutMs / 4)));
+        if (!Number.isSafeInteger(this.reaperIntervalMs) || this.reaperIntervalMs <= 0) {
+            throw new Error("reaperIntervalMs must be a positive integer");
+        }
+        this.timer = this.clock.setInterval(() => {
+            void this.reap().catch((error) => console.error("[lifecycle] reaper failed:", error));
+        }, this.reaperIntervalMs);
+        this.timer.unref();
+    }
+    touch(s) {
+        this.used.set(s, this.clock.now());
+    }
+    idle(s) {
+        return (!this.active.has(s) &&
+            s.pi !== undefined &&
+            !s.pi.isBusy &&
+            s.status.type === "idle" &&
+            !s.hasPendingInteraction() &&
+            !s.hasRunningChildren() &&
+            s.piSessionId !== undefined &&
+            s.piPath !== undefined);
+    }
+    /** Protect the caller across awaits, including admission of a dormant session. */
+    async use(s, action) {
+        if (this.stopped)
+            throw new Error("session manager is stopping");
+        this.active.set(s, (this.active.get(s) ?? 0) + 1);
+        this.touch(s);
+        try {
+            return await action();
+        }
+        finally {
+            const remaining = (this.active.get(s) ?? 1) - 1;
+            if (remaining === 0)
+                this.active.delete(s);
+            else
+                this.active.set(s, remaining);
+            this.touch(s);
+        }
+    }
+    run(action) {
+        if (this.stopped)
+            return Promise.reject(new Error("session manager is stopping"));
+        return this.enqueue(action);
+    }
+    enqueue(action) {
+        const next = this.tail.then(action);
+        this.tail = next.catch(() => undefined);
+        return next;
+    }
+    /** Called inside run(), before a process is spawned. */
+    async makeRoom() {
+        while ([...this.sessions()].filter((s) => s.pi !== undefined).length >= this.maxLive) {
+            const candidate = [...this.sessions()]
+                .filter((s) => this.idle(s))
+                .sort((a, b) => (this.used.get(a) ?? 0) - (this.used.get(b) ?? 0))[0];
+            if (candidate === undefined) {
+                throw new Error(`${ENV_PREFIX}MAX_LIVE=${this.maxLive} reached: no disposable idle session`);
+            }
+            await this.dormant(candidate);
+        }
+    }
+    async dormant(s) {
+        const pi = s.pi;
+        if (pi === undefined)
+            return;
+        if (s.piSessionId !== undefined && s.piPath !== undefined) {
+            s.restored = { piSessionId: s.piSessionId, piPath: s.piPath };
+        }
+        s.unwirePi?.();
+        s.pi = undefined; // Old exit listeners must not mutate a revived session.
+        const disposing = pi.dispose();
+        this.disposing.add(disposing);
+        try {
+            await disposing;
+        }
+        finally {
+            this.disposing.delete(disposing);
+        }
+    }
+    reap() {
+        if (this.stopped)
+            return Promise.resolve();
+        return this.run(async () => {
+            const now = this.clock.now();
+            for (const s of this.sessions()) {
+                if (this.idle(s) && now - (this.used.get(s) ?? now) >= this.idleTimeoutMs) {
+                    await this.dormant(s);
+                }
+            }
+        });
+    }
+    stop() {
+        if (this.stopping !== undefined)
+            return this.stopping;
+        this.stopped = true;
+        this.clock.clearInterval(this.timer);
+        this.stopping = this.enqueue(async () => {
+            await Promise.all([...[...this.sessions()].map((s) => this.dormant(s)), ...this.disposing]);
+        });
+        return this.stopping;
+    }
+}

package/dist/misc-routes.d.ts

@@ -0,0 +1,8 @@
+export { errorBody } from "./http.js";
+/** One shared failure latch for HTTP and agent-event diagnostics. */
+export declare function debugLog(line: string): void;
+interface RouteResult {
+    status: number;
+    body: unknown;
+}
+export declare function miscRoute(method: string, path: string, url: URL, directory: string): Promise<RouteResult | undefined>;

package/dist/misc-routes.js

@@ -0,0 +1,119 @@
+import { appendFileSync } from "node:fs";
+import { opendir, realpath } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { envSetting } from "./config.js";
+import { errorBody } from "./http.js";
+export { errorBody } from "./http.js";
+let loggingDisabled = false;
+const MAX_DIRECTORY_ENTRIES = 1000;
+const MAX_SEARCH_DIRECTORIES = 1024;
+const MAX_SEARCH_DEPTH = 32;
+const MAX_SEARCH_RESULTS = 1000;
+/** One shared failure latch for HTTP and agent-event diagnostics. */
+export function debugLog(line) {
+    if (!envSetting("DEBUG") || loggingDisabled)
+        return;
+    try {
+        appendFileSync(envSetting("DEBUG_LOG") ?? join(tmpdir(), `antechamber-debug-${process.getuid?.() ?? "user"}.log`), line + "\n", { flag: "a", mode: 0o600 });
+    }
+    catch (error) {
+        loggingDisabled = true;
+        console.error(`[debug] logging disabled: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function unsupported(message) {
+    return { status: 400, body: errorBody("UnsupportedError", message) };
+}
+async function confinedDirectory(root, path) {
+    const candidate = resolve(root, path);
+    const rel = relative(root, candidate);
+    if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+        return undefined;
+    try {
+        const actual = await realpath(candidate);
+        const actualRel = relative(root, actual);
+        return actualRel === ".." || actualRel.startsWith(`..${sep}`) || isAbsolute(actualRel) ? undefined : actual;
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+            throw error;
+        return undefined;
+    }
+}
+export async function miscRoute(method, path, url, directory) {
+    if (method === "GET" && ["/skill", "/lsp", "/formatter", "/experimental/tool/ids"].includes(path)) {
+        return { status: 200, body: [] };
+    }
+    if (method === "GET" && ["/provider/auth", "/mcp"].includes(path))
+        return { status: 200, body: {} };
+    if ((method === "PUT" && /^\/auth\/[^/]+$/.test(path)) ||
+        (method === "POST" && /^\/provider\/[^/]+\/oauth\/(authorize|callback)$/.test(path)) ||
+        (method === "PATCH" && path === "/config")) {
+        return unsupported("Not supported with OmO; configure providers in OmO");
+    }
+    if ((["POST", "DELETE"].includes(method) &&
+        /^\/mcp\/[^/]+\/(connect|disconnect|auth(?:\/(?:callback|authenticate))?)$/.test(path)) ||
+        (method === "POST" && path === "/experimental/control-plane/move-session")) {
+        return unsupported("Not supported with OmO; configure MCP and session directories in OmO");
+    }
+    if (method !== "GET" || !["/file", "/find/file"].includes(path))
+        return undefined;
+    const root = await realpath(directory);
+    if (path === "/file") {
+        const target = await confinedDirectory(root, url.searchParams.get("path") ?? "");
+        if (target === undefined)
+            return unsupported("Path must remain inside the session directory");
+        const body = [];
+        let scanned = 0;
+        for await (const entry of await opendir(target)) {
+            if (++scanned > MAX_DIRECTORY_ENTRIES)
+                break;
+            if (entry.isSymbolicLink() || entry.name === ".git" || (!entry.isFile() && !entry.isDirectory()))
+                continue;
+            const absolute = resolve(target, entry.name);
+            body.push({
+                name: entry.name,
+                path: relative(root, absolute).split(sep).join("/"),
+                absolute,
+                type: entry.isDirectory() ? "directory" : "file",
+                ignored: false,
+            });
+        }
+        body.sort((a, b) => a.path.localeCompare(b.path));
+        return { status: 200, body };
+    }
+    const query = url.searchParams.get("query") ?? "";
+    if (isAbsolute(query) ||
+        query.split(/[\\/]/).includes("..") ||
+        (url.searchParams.has("path") && (await confinedDirectory(root, url.searchParams.get("path") ?? "")) === undefined)) {
+        return unsupported("Path must remain inside the session directory");
+    }
+    const limitValue = Number(url.searchParams.get("limit") ?? "100");
+    const limit = Number.isFinite(limitValue) ? Math.min(MAX_SEARCH_RESULTS, Math.max(0, Math.floor(limitValue))) : 100;
+    const dirs = url.searchParams.get("dirs") !== "false" && url.searchParams.get("type") !== "file";
+    const onlyDirs = url.searchParams.get("type") === "directory";
+    const files = [];
+    let visited = 0;
+    const lowerQuery = query.toLowerCase();
+    async function visit(directory, depth) {
+        if (visited >= MAX_SEARCH_DIRECTORIES || depth > MAX_SEARCH_DEPTH || files.length >= limit)
+            return;
+        visited++;
+        let scanned = 0;
+        for await (const entry of await opendir(directory)) {
+            if (++scanned > MAX_DIRECTORY_ENTRIES || files.length >= limit || visited >= MAX_SEARCH_DIRECTORIES)
+                return;
+            if (entry.isSymbolicLink() || entry.name === ".git")
+                continue;
+            const absolute = resolve(directory, entry.name);
+            const path = relative(root, absolute).split(sep).join("/");
+            if (((entry.isFile() && !onlyDirs) || (entry.isDirectory() && dirs)) && path.toLowerCase().includes(lowerQuery))
+                files.push(path);
+            if (entry.isDirectory() && entry.name !== "node_modules")
+                await visit(absolute, depth + 1);
+        }
+    }
+    await visit(root, 0);
+    return { status: 200, body: files.sort() };
+}

package/dist/pi-event-translation.d.ts

@@ -0,0 +1,65 @@
+/** Pi message/part translation and the live event bridge, with explicit manager services. */
+import type { OCAssistantMessage, OCMessageWithParts, OCEvent, OCSessionStatus, OCPart } from "./types.js";
+import type { ManagedSession } from "./sessions.js";
+import type { SessionStore } from "./session-store.js";
+import type { SubagentBridge } from "./subagents.js";
+import { type TodoUpdated } from "./todo-bridge.js";
+export interface PiUsage {
+    input?: number;
+    output?: number;
+    reasoning?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    cost?: {
+        total?: number;
+    };
+}
+export declare function id(prefix: string): string;
+/**
+ * pi reports the requested `model` and, once the provider has answered, the
+ * concrete `responseModel` it actually served. The latter is the truth.
+ */
+export declare function piModelId(responseModel: unknown, model: unknown): unknown;
+export declare function piStopReason(stopReason: string | undefined, errorMessage?: string): Pick<OCAssistantMessage, "finish" | "error">;
+export declare function textOf(content: Array<Record<string, unknown>> | undefined): string;
+export declare function newPart(kind: "text" | "reasoning", sessionID: string, messageID: string): OCPart;
+export declare function applyUsage(msg: OCAssistantMessage, usage: PiUsage | undefined): void;
+interface PiEventServices {
+    readonly emit: (directory: string, event: OCEvent | TodoUpdated) => void;
+    readonly subagents: SubagentBridge;
+    readonly store: Pick<SessionStore, "update">;
+    readonly dirtyDiffs: Set<string>;
+    readonly ensureMessages: (s: ManagedSession) => OCMessageWithParts[];
+    readonly applyNativeTitle: (s: ManagedSession, value: unknown) => void;
+    readonly applyPiModel: (s: ManagedSession, provider: unknown, modelId: unknown) => boolean;
+    readonly emitDiff: (s: ManagedSession) => void;
+    readonly persistMeta: (s: ManagedSession) => void;
+}
+/** Translates per-session events; registry and lifecycle operations stay with SessionManager. */
+export declare class PiEventTranslator {
+    private services;
+    constructor(services: PiEventServices);
+    setStatus(s: ManagedSession, status: OCSessionStatus): void;
+    emitPart(s: ManagedSession, part: OCPart, delta?: string): void;
+    deliverInput(s: ManagedSession, messageID: string): void;
+    private reconcileUser;
+    onPiEvent(s: ManagedSession, ev: Record<string, unknown>): void;
+    private finishStreaming;
+    private onMessageUpdate;
+    private onProviderTools;
+    /**
+     * pi toolcall events → OpenCode tool parts (M2). Live-observed shapes
+     * (probe, 2026-09-21):
+     *   toolcall_start {contentIndex, id, toolName}
+     *   toolcall_delta {contentIndex, delta}          — JSON argument fragments
+     *   toolcall_end   {contentIndex, toolCall:{id, name, arguments}}
+     * Results arrive separately in turn_end.toolResults
+     * [{toolCallId, toolName, content:[{type:"text",text}], isError}].
+     */
+    private onToolcallEvent;
+    /** turn_end.toolResults → finalize tool parts (completed / error). */
+    private applyToolResults;
+    /** Tool parts that never received a result (abort, crash) must not spin forever. */
+    private finalizeDanglingTools;
+}
+export {};