antechamber 0.1.1 → 0.2.0

package/dist/sse.d.ts

@@ -2,18 +2,28 @@
 import type { ServerResponse } from "node:http";
 import type { OCEvent } from "./types.js";
 import type { TodoUpdated } from "./todo-bridge.js";
+export type SSESubscriber = {
+    flavor: "v1" | "v2";
+    directory?: string;
+    global: boolean;
+};
 export declare class SSE {
     private options;
-    /** SSE subscribers tagged by protocol flavor: v1 (`/event`) or v2 (`/api/event`). */
-    readonly clients: Map<ServerResponse, "v1" | "v2">;
+    /** SSE subscribers tagged by protocol flavor and explicit directory scope. */
+    readonly clients: Map<ServerResponse, SSESubscriber>;
     private v2events;
+    private nextEventID;
+    private replay;
     constructor(options: {
         defaultDirectory: string;
     }, 
-    /** SSE subscribers tagged by protocol flavor: v1 (`/event`) or v2 (`/api/event`). */
-    clients: Map<ServerResponse, "v1" | "v2">);
+    /** SSE subscribers tagged by protocol flavor and explicit directory scope. */
+    clients: Map<ServerResponse, SSESubscriber>);
     close(): void;
-    broadcast(_directory: string, event: OCEvent | TodoUpdated): void;
+    broadcast(directory: string, event: OCEvent | TodoUpdated): void;
     writeSSE(res: ServerResponse, frame: string): boolean;
-    handleSSE(res: ServerResponse, flavor: "v1" | "v2", write: (res: ServerResponse, frame: string) => boolean): void;
+    handleSSE(res: ServerResponse, subscriber: SSESubscriber, lastEventID: string | undefined, write: (res: ServerResponse, frame: string) => boolean): void;
+    private record;
+    private retain;
+    private writeRecord;
 }

package/dist/sse.js

@@ -4,12 +4,15 @@ import { errorBody, json } from "./http.js";
 import { V2EventTranslator } from "./v2.js";
 const MAX_SSE_SUBSCRIBERS = 64;
 const MAX_SSE_PENDING_BYTES = 8 * 1024 * 1024;
+const MAX_SSE_REPLAY_RECORDS = 1024;
 export class SSE {
     options;
     clients;
     v2events = new V2EventTranslator();
+    nextEventID = 0;
+    replay = [];
     constructor(options, 
-    /** SSE subscribers tagged by protocol flavor: v1 (`/event`) or v2 (`/api/event`). */
+    /** SSE subscribers tagged by protocol flavor and explicit directory scope. */
     clients) {
         this.options = options;
         this.clients = clients;
@@ -20,25 +23,25 @@ export class SSE {
             res.end();
         }
     }
-    broadcast(_directory, event) {
-        const v1Frame = `data: ${JSON.stringify(event)}\n\n`;
-        const frames = event.type === "todo.updated"
-            ? [{ id: `evt_${randomUUID()}`, type: event.type, location: { directory: _directory }, data: event.properties }]
-            : this.v2events.translate(_directory, event);
-        const v2Frames = frames.map((frame) => `data: ${JSON.stringify(frame)}\n\n`);
-        for (const [res, flavor] of this.clients) {
+    broadcast(directory, event) {
+        const v2Frames = event.type === "todo.updated"
+            ? [{ id: `evt_${randomUUID()}`, type: event.type, location: { directory }, data: event.properties }]
+            : this.v2events.translate(directory, event);
+        const records = v2Frames.length === 0
+            ? [this.record(directory, { v1: event })]
+            : v2Frames.map((v2, index) => this.record(directory, index === 0 ? { v1: event, v2 } : { v2 }));
+        for (const record of records)
+            this.retain(record);
+        for (const [res, subscriber] of this.clients) {
             if (res.writableEnded || res.destroyed) {
                 this.clients.delete(res);
                 continue;
             }
-            if (flavor === "v2") {
-                for (const frame of v2Frames) {
-                    if (!this.writeSSE(res, frame))
-                        break;
-                }
-            }
-            else {
-                this.writeSSE(res, v1Frame);
+            for (const record of records) {
+                if (!subscriber.global && subscriber.directory !== directory)
+                    continue;
+                if (!this.writeRecord(res, subscriber, record))
+                    break;
             }
         }
     }
@@ -56,7 +59,7 @@ export class SSE {
         res.destroy();
         return false;
     }
-    handleSSE(res, flavor, write) {
+    handleSSE(res, subscriber, lastEventID, write) {
         if (this.clients.size >= MAX_SSE_SUBSCRIBERS) {
             json(res, 503, errorBody("ServiceUnavailableError", "Too many SSE subscribers"));
             return;
@@ -66,7 +69,7 @@ export class SSE {
             "Cache-Control": "no-cache",
             Connection: "keep-alive",
         });
-        this.clients.set(res, flavor);
+        this.clients.set(res, subscriber);
         // OpenChamber's SSE proxy aborts an upstream that is silent for 20s, so
         // mirror real opencode's `: heartbeat` comment keepalive.
         const heartbeat = setInterval(() => {
@@ -78,15 +81,68 @@ export class SSE {
             this.clients.delete(res);
         });
         // OpenCode emits server.connected on subscribe; OpenChamber waits for it.
-        const connected = flavor === "v2"
+        const connected = subscriber.flavor === "v2"
             ? {
                 id: `evt_${Date.now()}`,
                 created: Date.now(),
                 type: "server.connected",
-                location: { directory: this.options.defaultDirectory },
+                location: { directory: subscriber.directory ?? this.options.defaultDirectory },
                 data: {},
             }
             : { type: "server.connected", properties: {} };
-        write(res, `data: ${JSON.stringify(connected)}\n\n`);
+        const initial = subscriber.flavor === "v1" && subscriber.global
+            ? {
+                directory: subscriber.directory ?? this.options.defaultDirectory,
+                payload: { id: `evt_${randomUUID()}`, ...connected },
+            }
+            : connected;
+        write(res, `data: ${JSON.stringify(initial)}\n\n`);
+        const cursor = Number(lastEventID);
+        if (!Number.isSafeInteger(cursor) || cursor < 0)
+            return;
+        for (const record of this.replay) {
+            if (record.id > cursor && !this.writeRecord(res, subscriber, record))
+                break;
+        }
+    }
+    record(directory, frames) {
+        return { id: ++this.nextEventID, directory, ...frames };
+    }
+    retain(record) {
+        this.replay.push(record);
+        if (this.replay.length > MAX_SSE_REPLAY_RECORDS)
+            this.replay.shift();
+    }
+    writeRecord(res, subscriber, record) {
+        if (!subscriber.global && subscriber.directory !== record.directory)
+            return true;
+        const data = subscriber.flavor === "v2"
+            ? record.v2
+            : record.v1 === undefined
+                ? undefined
+                : subscriber.global
+                    ? {
+                        directory: record.directory,
+                        project: record.directory,
+                        payload: {
+                            id: `evt_${record.id}`,
+                            ...record.v1,
+                            properties: {
+                                ...record.v1.properties,
+                                ...(record.v1.type === "session.created" ||
+                                    record.v1.type === "session.updated" ||
+                                    record.v1.type === "session.deleted"
+                                    ? { sessionID: record.v1.properties.info.id }
+                                    : {}),
+                            },
+                        },
+                    }
+                    : record.v1;
+        if (data === undefined)
+            return true;
+        const frame = subscriber.flavor === "v1" && !subscriber.global
+            ? `data: ${JSON.stringify(data)}\n\n`
+            : `id: ${record.id}\ndata: ${JSON.stringify(data)}\n\n`;
+        return this.writeSSE(res, frame);
     }
 }

package/dist/subagents.d.ts

@@ -46,11 +46,16 @@ export declare class SubagentBridge {
     private discoverParts;
     private create;
     restore(id: string): ManagedSession | undefined;
+    private managedSession;
     restoreAll(): void;
     owns(id: string): boolean;
     messages(id: string): OCMessageWithParts[];
     private watch;
     private refresh;
+    private reconcileTaskRecord;
+    private hydrateTranscript;
+    private reconcileRuntime;
+    private publishRefresh;
     private saveArchive;
     private fallback;
     private persist;

package/dist/subagents.js

@@ -295,26 +295,15 @@ export class SubagentBridge {
         }
     }
     create(parent, task) {
-        const session = {
-            info: {
-                id: ocIdFor(task.id),
-                parentID: parent.info.id,
-                projectID: parent.info.projectID,
-                directory: parent.info.directory,
-                title: typeof task.input.description === "string" ? task.input.description : task.id,
-                version: parent.info.version,
-                time: { ...parent.info.time },
-            },
-            pi: undefined,
-            messages: undefined,
-            model: undefined,
-            streaming: undefined,
-            status: { type: "idle" },
-            toolByCallId: new Map(),
-            tree: { messageEntries: {} },
-            hasPendingInteraction: () => false,
-            hasRunningChildren: () => false,
-        };
+        const session = this.managedSession({
+            id: ocIdFor(task.id),
+            parentID: parent.info.id,
+            projectID: parent.info.projectID,
+            directory: parent.info.directory,
+            title: typeof task.input.description === "string" ? task.input.description : task.id,
+            version: parent.info.version,
+            time: { ...parent.info.time },
+        });
         const child = {
             session,
             task,
@@ -339,15 +328,21 @@ export class SubagentBridge {
         const entry = this.store.get(id);
         if (!entry?.task || !entry.parentID)
             return undefined;
-        const parent = {
-            info: {
-                id: entry.parentID,
-                projectID: entry.directory,
-                directory: entry.directory,
-                title: "",
-                version: ADAPTER_VERSION,
-                time: { created: entry.created, updated: entry.updated },
-            },
+        const parent = this.managedSession({
+            id: entry.parentID,
+            projectID: entry.directory,
+            directory: entry.directory,
+            title: "",
+            version: ADAPTER_VERSION,
+            time: { created: entry.created, updated: entry.updated },
+        });
+        const child = this.create(parent, entry.task);
+        child.session.info.title = entry.title ?? child.session.info.title;
+        return child.session;
+    }
+    managedSession(info) {
+        return {
+            info,
             pi: undefined,
             messages: undefined,
             model: undefined,
@@ -358,9 +353,6 @@ export class SubagentBridge {
             hasPendingInteraction: () => false,
             hasRunningChildren: () => false,
         };
-        const child = this.create(parent, entry.task);
-        child.session.info.title = entry.title ?? child.session.info.title;
-        return child.session;
     }
     restoreAll() {
         for (const id of this.store.childIds())
@@ -396,44 +388,63 @@ export class SubagentBridge {
     }
     refresh(child, publish, useRecord = true) {
         const archive = this.archive(child.task.id);
+        const found = this.reconcileTaskRecord(child, archive, useRecord);
+        const running = active(child.task.details.status) && (found !== undefined || child.live);
+        const state = {
+            previousMessages: child.session.messages ?? [],
+            previousStatus: child.session.status.type,
+            running,
+            costChanged: this.hydrateTranscript(child, archive, running, child.session.status.type),
+            updatedParts: this.reconcileRuntime(child, running),
+        };
+        if (state.costChanged)
+            this.emit(child.session.info.directory, { type: "session.updated", properties: { info: child.session.info } });
+        if (publish)
+            for (const part of state.updatedParts)
+                this.emitPart(child.session, part);
+        this.persist(child);
+        this.publishRefresh(child, state, publish);
+    }
+    reconcileTaskRecord(child, archive, useRecord) {
         const found = findTask(child.task.id, child.task.parentPiId);
-        if (found) {
-            child.recordPath = found.path;
-            const updated = typeof found.data.updated_at === "string" ? Date.parse(found.data.updated_at) : NaN;
-            const retainedTerminal = Math.max(child.task.terminalAt ?? 0, existsSync(archive) ? statSync(archive).mtimeMs : 0);
-            const staleRunning = active(found.data.status) && terminal(child.task.details.status) && updated <= retainedTerminal;
-            if (useRecord && !staleRunning)
-                child.task.details = { ...child.task.details, ...found.data };
-            const host = found.data.host_session;
-            if (record(host) && typeof host.session_path === "string")
-                child.livePath = host.session_path;
-            else if (typeof found.data.child_session_id === "string" && found.data.child_session_id !== "") {
-                // In-process agents persist under the task store but have no RPC host_session.
-                // Match the recorded session, not another retained run in the same directory.
-                const sessions = join(dirname(dirname(found.path)), "children", child.task.id, "sessions", child.task.id);
-                try {
-                    const file = readdirSync(sessions, { withFileTypes: true }).find((entry) => entry.isFile() && entry.name.endsWith(`_${found.data.child_session_id}.jsonl`));
-                    child.livePath = file ? join(sessions, file.name) : undefined;
-                }
-                catch (error) {
-                    if (!(error instanceof Error && "code" in error && ["ENOENT", "ENOTDIR", "EACCES"].includes(String(error.code))))
-                        throw error;
-                    child.livePath = undefined;
-                }
-            }
+        if (!found)
+            return undefined;
+        child.recordPath = found.path;
+        const updated = typeof found.data.updated_at === "string" ? Date.parse(found.data.updated_at) : NaN;
+        const retainedTerminal = Math.max(child.task.terminalAt ?? 0, existsSync(archive) ? statSync(archive).mtimeMs : 0);
+        const staleRunning = active(found.data.status) && terminal(child.task.details.status) && updated <= retainedTerminal;
+        if (useRecord && !staleRunning)
+            child.task.details = { ...child.task.details, ...found.data };
+        const host = found.data.host_session;
+        if (record(host) && typeof host.session_path === "string") {
+            child.livePath = host.session_path;
+            return found;
         }
-        const running = active(child.task.details.status) && (found !== undefined || child.live);
-        const previousMessages = child.session.messages ?? [];
-        const previousStatus = child.session.status.type;
+        if (typeof found.data.child_session_id !== "string" || found.data.child_session_id === "")
+            return found;
+        // In-process agents persist under the task store but have no RPC host_session.
+        // Match the recorded session, not another retained run in the same directory.
+        const sessions = join(dirname(dirname(found.path)), "children", child.task.id, "sessions", child.task.id);
+        try {
+            const file = readdirSync(sessions, { withFileTypes: true }).find((entry) => entry.isFile() && entry.name.endsWith(`_${found.data.child_session_id}.jsonl`));
+            child.livePath = file ? join(sessions, file.name) : undefined;
+        }
+        catch (error) {
+            if (!(error instanceof Error && "code" in error && ["ENOENT", "ENOTDIR", "EACCES"].includes(String(error.code))))
+                throw error;
+            child.livePath = undefined;
+        }
+        return found;
+    }
+    hydrateTranscript(child, archive, running, previousStatus) {
         // A resumed live task can be newer than its archive; completed history prefers the archive.
         const liveRun = running || previousStatus === "busy";
         let raw = liveRun ? undefined : optionalFile(archive);
         if (running && child.recordPath)
             this.watch(child, child.recordPath);
         if (raw === undefined && child.livePath !== undefined) {
-            if (running) {
+            if (running)
                 this.watch(child, child.livePath);
-            }
             child.tail.read(child.livePath);
             if (child.tail.text !== "")
                 raw = child.tail.text;
@@ -459,36 +470,38 @@ export class SubagentBridge {
         }
         child.loaded = true;
         // Each child reports only its own spend; OpenChamber sums the subtree by parentID.
-        if (syncSessionCost(child.session))
-            this.emit(child.session.info.directory, { type: "session.updated", properties: { info: child.session.info } });
+        return syncSessionCost(child.session);
+    }
+    reconcileRuntime(child, running) {
         child.session.status = { type: running ? "busy" : "idle" };
         if (!running)
             this.closeWatchers(child);
-        for (const part of child.parts.values()) {
+        const parts = [...child.parts.values()];
+        for (const part of parts) {
             updateTaskParts([part], {
                 details: child.task.details,
                 content: [{ type: "text", text: child.task.details.final_response ?? "" }],
             }, !running, Date.now());
-            if (publish)
-                this.emitPart(child.session, part);
         }
-        this.persist(child);
+        return parts;
+    }
+    publishRefresh(child, state, publish) {
         if (!publish)
             return;
-        const before = new Map(previousMessages.map((message) => [message.info.id, JSON.stringify(message)]));
-        for (const message of child.session.messages) {
+        const before = new Map(state.previousMessages.map((message) => [message.info.id, JSON.stringify(message)]));
+        for (const message of child.session.messages ?? []) {
             if (before.get(message.info.id) === JSON.stringify(message))
                 continue;
             this.emit(child.session.info.directory, { type: "message.updated", properties: { info: message.info } });
             for (const part of message.parts)
                 this.emitPart(child.session, part);
         }
-        if (previousStatus !== child.session.status.type) {
+        if (state.previousStatus !== child.session.status.type) {
             this.emit(child.session.info.directory, {
                 type: "session.status",
                 properties: { sessionID: child.session.info.id, status: child.session.status },
             });
-            if (!running)
+            if (!state.running)
                 this.emit(child.session.info.directory, {
                     type: "session.idle",
                     properties: { sessionID: child.session.info.id },

package/dist/tool-map.d.ts

@@ -1,6 +1,6 @@
 import type { OCToolPart } from "./types.js";
 /** OmO arguments translated to OpenChamber's renderer contracts. */
-export interface MappedTool {
+interface MappedTool {
     tool: string;
     input: Record<string, unknown>;
     title: string;
@@ -12,7 +12,7 @@ export interface ToolResult {
     details?: unknown;
     isError?: boolean;
 }
-export type ToolMapper = (args: Record<string, unknown>, result?: ToolResult) => MappedTool;
+type ToolMapper = (args: Record<string, unknown>, result?: ToolResult) => MappedTool;
 /** Mutable registry: todos 6/7 can assign handlers for `todo` and `task`. */
 export declare const toolMappers: Record<string, ToolMapper>;
 /** Text blocks only; images and structured details are not tool output text. */
@@ -30,3 +30,4 @@ export declare function providerToolParts(content: unknown, sessionID: string, m
 export declare function applyProviderToolResults(content: unknown, parts: Iterable<OCToolPart>, timestamp: number): OCToolPart[];
 /** Only an actual result (or a self-contained provider status) means success. */
 export declare function finishProviderToolParts(parts: Iterable<OCToolPart>, timestamp: number, error?: string): OCToolPart[];
+export {};

package/dist/types.d.ts

@@ -12,6 +12,31 @@ export interface OCSession {
     projectID: string;
     directory: string;
     parentID?: string;
+    parentMessageID?: string;
+    agent?: string;
+    model?: {
+        id: string;
+        providerID: string;
+        variant?: string;
+    };
+    metadata?: Record<string, unknown>;
+    outcome?: "succeeded" | "failed" | "interrupted";
+    slug?: string;
+    path?: string;
+    summary?: {
+        additions: number;
+        deletions: number;
+        files: number;
+    };
+    tokens?: {
+        input: number;
+        output: number;
+        reasoning: number;
+        cache: {
+            read: number;
+            write: number;
+        };
+    };
     title: string;
     version: string;
     revert?: {
@@ -22,6 +47,7 @@ export interface OCSession {
     time: {
         created: number;
         updated: number;
+        idle?: number;
         compacting?: number;
         /** Epoch ms — presence marks the session archived (SDK v2 session.update). */
         archived?: number;
@@ -36,6 +62,10 @@ export interface OCUserMessage {
     };
     agent: string;
     model: OCModelRef;
+    /** No-reply context admitted without a turn (v2 lists it as `type: "synthetic"`). */
+    synthetic?: boolean;
+    /** Client metadata sent with the prompt (OpenChamber 2.x). */
+    metadata?: Record<string, unknown>;
 }
 export interface OCAssistantMessage {
     id: string;
@@ -156,7 +186,34 @@ export interface OCCompactionPart {
     type: "compaction";
     auto: boolean;
 }
-export type OCPart = OCTextPart | OCReasoningPart | OCToolPart | OCCompactionPart;
+export type OCPromptPart = ({
+    type: "text";
+    text: string;
+    synthetic?: boolean;
+} | {
+    type: "file";
+    mime: string;
+    url: string;
+    filename?: string;
+} | {
+    type: "agent";
+    name: string;
+    source?: {
+        value: string;
+        start: number;
+        end: number;
+    };
+}) & {
+    id?: string;
+};
+export type OCInputPart = OCPromptPart & {
+    id: string;
+    sessionID: string;
+    messageID: string;
+};
+export type OCPart = OCTextPart | OCReasoningPart | OCToolPart | OCCompactionPart | Exclude<OCInputPart, {
+    type: "text";
+}>;
 export interface OCMessageWithParts {
     info: OCMessage;
     parts: OCPart[];
@@ -181,6 +238,15 @@ export type OCEvent = {
             delivery: "steer" | "queue";
             payload: {
                 text: string;
+                files?: Array<Record<string, unknown>>;
+                agents?: Array<Record<string, unknown>>;
+                metadata?: Record<string, unknown>;
+            };
+        } | {
+            type: "synthetic";
+            payload: {
+                text: string;
+                metadata?: Record<string, unknown>;
             };
         };
     };
@@ -209,6 +275,79 @@ export type OCEvent = {
     properties: {
         info: OCSession;
     };
+} | {
+    type: "session.revert.staged";
+    properties: {
+        sessionID: string;
+        revert: {
+            messageID: string;
+        };
+    };
+} | {
+    type: "session.revert.cleared";
+    properties: {
+        sessionID: string;
+    };
+} | {
+    type: "session.revert.committed";
+    properties: {
+        sessionID: string;
+        to: string;
+    };
+} | {
+    type: "session.compaction.started";
+    properties: {
+        sessionID: string;
+        reason: string;
+        inputID: string;
+    };
+} | {
+    type: "session.compaction.ended";
+    properties: {
+        sessionID: string;
+        reason: string;
+        inputID: string;
+        text: string;
+        recent: string;
+    };
+} | {
+    type: "session.compaction.failed";
+    properties: {
+        sessionID: string;
+        reason: string;
+        inputID: string;
+        error: {
+            name: string;
+            data: {
+                message: string;
+            };
+        };
+    };
+} | {
+    type: "session.shell.started" | "session.shell.ended";
+    properties: {
+        sessionID: string;
+        shell: {
+            id: string;
+            command: string;
+            cwd: string;
+            shell: string;
+            file: string;
+            status: "running" | "exited" | "timeout" | "killed";
+            exit?: number;
+            metadata: Record<string, unknown>;
+            time: {
+                started: number;
+                completed?: number;
+            };
+        };
+        output?: {
+            output: string;
+            cursor: number;
+            size: number;
+            truncated: boolean;
+        };
+    };
 } | {
     type: "session.deleted";
     properties: {
@@ -253,6 +392,15 @@ export type OCEvent = {
         part: OCPart;
         delta?: string;
     };
+} | {
+    type: "message.part.delta";
+    properties: {
+        sessionID: string;
+        messageID: string;
+        partID: string;
+        field: "text";
+        delta: string;
+    };
 } | {
     type: "permission.asked";
     properties: {
@@ -332,12 +480,15 @@ export interface OCProject {
     vcs?: "git";
     time: {
         created: number;
+        updated?: number;
         initialized?: number;
     };
+    sandboxes?: string[];
 }
 /** Incoming prompt body for POST /session/{id}/message and /prompt_async */
 export interface OCPromptBody {
     messageID?: string;
+    delivery?: "steer" | "queue";
     model?: OCModelRef;
     agent?: string;
     noReply?: boolean;