antechamber 0.1.1 → 0.2.1

package/dist/routes-v2.js

@@ -1,34 +1,89 @@
 /** OpenCode v2 (/api/*) routes and their response adapters. */
+import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { tmpdir } from "node:os";
-import { errorBody, json } from "./http.js";
-import { debugLog } from "./misc-routes.js";
+import { promisify } from "node:util";
+import { errorBody, json, RequestBodyError } from "./http.js";
+import { nativePromptInput, parsePromptParts, v2PromptAttachments, v2PromptParts } from "./prompt-parts.js";
+import { debugLog, miscRoute } from "./misc-routes.js";
 import { OPENCODE_API_VERSION } from "./version.js";
 import { toV2Permission } from "./approvals.js";
 import { formQuestionAnswer, questionFormID, toQuestionForm } from "./question-forms.js";
-import { getAgentName, getExposedAgentNames } from "./agent-name.js";
-import { agentDefaults } from "./catalog.js";
-import { announceSessionError, compactSession, getCommands, parseShellCommand, parseSlashCommand, runShellCommand, runSlashCommand, unsupportedShare, } from "./session-commands.js";
+import { getAgentName } from "./agent-name.js";
+import { vcsRead, VcsError } from "./vcs.js";
+import { announceSessionError, compactSession, getCommands, unsupportedShare } from "./session-commands.js";
 import { defaultV2Model, flattenModels, toV2Message, toV2Session } from "./v2.js";
-import { modelRefFromBody, numberParam, OPENCODE_COMPAT_VERSION, promptAsync, } from "./route-services.js";
+import { agentDescriptors, modelRefFromBody, numberParam, OPENCODE_COMPAT_VERSION, promptAsync, runSessionShell, runSessionSlash, sessionDirectory, sessionMetadata, } from "./route-services.js";
 async function v2Agents(services) {
-    const piName = getAgentName();
-    const defaults = agentDefaults(await services.catalog());
-    return getExposedAgentNames().map((name) => ({
-        id: name,
-        name,
-        description: name === piName
-            ? `${piName} (pi coding agent via antechamber)`
-            : `${name} — ${piName} (pi coding agent via antechamber)`,
-        mode: "primary",
-        hidden: name === "build" && piName !== "build",
-        options: {},
-        ...defaults,
+    return (await agentDescriptors(services)).map((agent) => ({
+        id: agent.name,
+        ...agent,
+        request: { settings: {}, headers: {}, body: {} },
+        permissions: agent.permission.map((rule) => ({
+            action: rule.permission,
+            resource: rule.pattern,
+            effect: rule.action,
+        })),
+        system: agent.prompt,
     }));
 }
 function v2Session(services, info) {
     const managed = services.sessions.get(info.id);
-    return toV2Session(info, { model: managed?.model, agent: getAgentName() });
+    return toV2Session(info, { model: managed?.model, agent: info.agent ?? getAgentName() });
+}
+const execFileAsync = promisify(execFile);
+function encodeSessionCursor(session) {
+    return Buffer.from(JSON.stringify({ updated: session.time.updated, id: session.id })).toString("base64url");
+}
+function decodeSessionCursor(value) {
+    if (value === null || value === "")
+        return undefined;
+    try {
+        const parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+        if (typeof parsed === "object" &&
+            parsed !== null &&
+            "updated" in parsed &&
+            "id" in parsed &&
+            typeof parsed.updated === "number" &&
+            Number.isFinite(parsed.updated) &&
+            typeof parsed.id === "string") {
+            return { updated: parsed.updated, id: parsed.id };
+        }
+    }
+    catch {
+        // A malformed continuation cursor starts a fresh listing, as OpenCode's
+        // clients may retain a cursor across a restarted local server.
+    }
+    return undefined;
+}
+function compareSessions(left, right, order) {
+    const comparison = left.time.updated - right.time.updated || left.id.localeCompare(right.id);
+    return order === "asc" ? comparison : -comparison;
+}
+function followsCursor(session, cursor, order) {
+    const comparison = session.time.updated - cursor.updated || session.id.localeCompare(cursor.id);
+    return order === "asc" ? comparison > 0 : comparison < 0;
+}
+async function currentGitBranch(directory) {
+    try {
+        const { stdout } = await execFileAsync("git", ["symbolic-ref", "--short", "HEAD"], {
+            cwd: directory,
+            timeout: 3000,
+        });
+        return stdout.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function initializeGit(directory) {
+    try {
+        await execFileAsync("git", ["init", "-q"], { cwd: directory, timeout: 3000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 /** v2 `/api/project` list: the adapter has no project registry, so expose the
  * directories it knows about (the default plus every restorable session). */
@@ -40,14 +95,13 @@ function v2Projects(services) {
     return [...dirs].map((dir) => ({
         id: dir,
         canonical: dir,
-        time: { created: now, updated: now },
+        time: { created: now, updated: now, active: now },
         sandboxes: [],
+        vcs: "git",
     }));
 }
-export async function handleV2(services, req, res, url, path, method, directory) {
-    const location = { directory };
-    const withLocation = (data) => ({ location, data });
-    // --- bootstrap ---
+async function handleV2Bootstrap(services, res, path, method, directory) {
+    const withLocation = (data) => ({ location: { directory }, data });
     if (path === "/api/info" && method === "GET") {
         json(res, 200, {
             version: OPENCODE_COMPAT_VERSION ?? OPENCODE_API_VERSION,
@@ -55,73 +109,170 @@ export async function handleV2(services, req, res, url, path, method, directory)
             urls: [services.url],
             paths: { tmp: tmpdir() },
         });
-        return;
+        return true;
     }
     if (path === "/api/location" && method === "GET") {
         json(res, 200, { directory, project: { id: directory, directory, canonical: directory } });
-        return;
+        return true;
     }
     if (path === "/api/config" && method === "GET") {
-        json(res, 200, withLocation({ default_agent: getAgentName() }));
-        return;
+        // OpenCode 2.x returns a bare ConfigEntry[]; OpenChamber folds each document's `info` into one config.
+        json(res, 200, [{ type: "document", path: "antechamber", info: { default_agent: getAgentName() } }]);
+        return true;
     }
     if (path === "/api/provider" && method === "GET") {
         const cat = await services.catalog();
         json(res, 200, withLocation(cat.providers.map((p) => ({ ...p, activation: "enabled" }))));
-        return;
+        return true;
     }
     if (path === "/api/model" && method === "GET") {
         const cat = await services.catalog();
         json(res, 200, withLocation(flattenModels(cat)));
-        return;
+        return true;
     }
     if (path === "/api/model/default" && method === "GET") {
         const cat = await services.catalog();
         json(res, 200, withLocation(defaultV2Model(cat) ?? null));
-        return;
+        return true;
     }
     if (path === "/api/agent" && method === "GET") {
         json(res, 200, withLocation(await v2Agents(services)));
-        return;
+        return true;
     }
     const agentMatch = path.match(/^\/api\/agent\/([^/]+)$/);
     if (agentMatch && method === "GET") {
         const agentId = decodeURIComponent(agentMatch[1]);
         const agent = (await v2Agents(services)).find((a) => a.id === agentId);
-        if (!agent) {
+        if (!agent)
             json(res, 404, errorBody("NotFoundError", `agent not found: ${agentId}`));
-            return;
-        }
-        json(res, 200, withLocation(agent));
-        return;
+        else
+            json(res, 200, withLocation(agent));
+        return true;
     }
     if (path === "/api/command" && method === "GET") {
-        json(res, 200, withLocation(await getCommands(directory)));
-        return;
+        json(res, 200, withLocation((await getCommands(directory)).map((command) => ({
+            ...command,
+            source: "command",
+            hints: [],
+            subtask: false,
+        }))));
+        return true;
     }
     if (path === "/api/skill" && method === "GET") {
         json(res, 200, withLocation([]));
+        return true;
+    }
+    return false;
+}
+export async function handleV2(services, req, res, url, path, method, directory) {
+    const location = { directory };
+    const withLocation = (data) => ({ location, data });
+    // --- bootstrap ---
+    if (await handleV2Bootstrap(services, res, path, method, directory))
+        return;
+    if (path === "/api/debug/location" && method === "DELETE") {
+        // OpenChamber evicts a location after git worktree changes so OpenCode re-reads it. antechamber
+        // keeps no per-location instance (project and VCS reads are fresh per request): nothing to evict.
+        res.writeHead(204).end();
         return;
     }
     // --- project / vcs / permission / form (2.0.4 bootstrap) ---
+    if (path === "/api/credential" && method === "GET") {
+        json(res, 200, withLocation([]));
+        return;
+    }
+    const credentialMatch = path.match(/^\/api\/credential\/([^/]+)(\/activate)?$/);
+    if ((path === "/api/credential" && method === "POST") ||
+        (credentialMatch && method === (credentialMatch[2] ? "POST" : "PATCH"))) {
+        await services.body(req);
+        json(res, 400, errorBody("UnsupportedError", "Credential management is not available; configure providers in OmO"));
+        return;
+    }
+    if (credentialMatch && !credentialMatch[2] && method === "DELETE") {
+        res.writeHead(204).end();
+        return;
+    }
+    if (path === "/api/integration" && method === "GET") {
+        json(res, 200, withLocation([]));
+        return;
+    }
+    const integrationMatch = path.match(/^\/api\/integration\/([^/]+)$/);
+    if (integrationMatch && method === "GET") {
+        json(res, 404, errorBody("NotFoundError", `integration not found: ${decodeURIComponent(integrationMatch[1])}`));
+        return;
+    }
+    if ((method === "POST" && /^\/api\/integration\/[^/]+\/connect\/(key|external|oauth|command)$/.test(path)) ||
+        ((method === "GET" || method === "DELETE") &&
+            /^\/api\/integration\/[^/]+\/connect\/(oauth|command)\/[^/]+$/.test(path)) ||
+        (method === "POST" && /^\/api\/integration\/[^/]+\/connect\/oauth\/[^/]+\/complete$/.test(path))) {
+        json(res, 400, errorBody("UnsupportedError", "Integration connections are not available; configure providers in OmO"));
+        return;
+    }
+    if ((path === "/api/plugin" && method === "GET") || (path === "/api/plugin/check" && method === "POST")) {
+        if (method === "POST")
+            await services.body(req);
+        json(res, 200, withLocation([]));
+        return;
+    }
+    if (path === "/api/plugin/update" && method === "POST") {
+        json(res, 400, errorBody("UnsupportedError", "Plugin updates are not available with OmO"));
+        return;
+    }
+    if (path === "/api/experimental/generate" && method === "POST") {
+        json(res, 503, {
+            _tag: "ServiceUnavailableError",
+            message: "No generation model is available through antechamber/OmO",
+            service: "opencode",
+        });
+        return;
+    }
+    // Read-only inventories OpenChamber loads at bootstrap: OmO has no background shells,
+    // web-search providers or MCP servers, so each is an honest empty list (mutations stay 400).
+    if ((path === "/api/shell" || path === "/api/websearch/provider" || path === "/api/mcp") && method === "GET") {
+        json(res, 200, withLocation([]));
+        return;
+    }
+    if (path === "/api/experimental/session/stats" && method === "GET") {
+        json(res, 400, errorBody("UnsupportedError", "Session statistics are not available with OmO"));
+        return;
+    }
+    if (path === "/api/mcp" || path.startsWith("/api/mcp/") || path.startsWith("/api/experimental/mcp/")) {
+        json(res, 400, errorBody("UnsupportedError", "MCP is not available with OmO"));
+        return;
+    }
+    if (path === "/api/fs/find" && method === "GET") {
+        const result = await miscRoute("GET", "/find/file", url, directory);
+        if (result === undefined) {
+            json(res, 500, errorBody("UnknownError", "file search route is unavailable"));
+            return;
+        }
+        if (result.status !== 200) {
+            json(res, result.status, result.body);
+            return;
+        }
+        const files = Array.isArray(result.body)
+            ? result.body
+                .filter((entry) => typeof entry === "string")
+                .map((path) => ({ path, type: "file" }))
+            : [];
+        json(res, 200, withLocation(files));
+        return;
+    }
     if (path === "/api/project" && method === "GET") {
         json(res, 200, v2Projects(services));
         return;
     }
     const projectMatch = path.match(/^\/api\/project\/([^/]+)$/);
     if (projectMatch && method === "PATCH") {
-        const projectId = decodeURIComponent(projectMatch[1]);
-        const body = (await services.body(req));
-        json(res, 200, {
-            id: projectId,
-            canonical: body.canonical ?? projectId,
-            time: { created: 0, updated: Date.now() },
-            sandboxes: [],
-        });
+        await services.body(req);
+        json(res, 400, errorBody("UnsupportedError", "Project updates are not available with OmO"));
         return;
     }
     if (path === "/api/permission/request" && method === "GET") {
-        json(res, 200, withLocation(services.sessions.permissions().map(toV2Permission)));
+        json(res, 200, withLocation(services.sessions
+            .permissions()
+            .filter((permission) => services.sessions.get(permission.sessionID)?.info.directory === directory)
+            .map((permission) => ({ ...toV2Permission(permission), ...permission }))));
         return;
     }
     if (path === "/api/question/request" && method === "GET") {
@@ -140,46 +291,76 @@ export async function handleV2(services, req, res, url, path, method, directory)
         json(res, 200, withLocation(services.sessions.questions().map(toQuestionForm)));
         return;
     }
-    if (path === "/api/vcs" && method === "GET") {
-        json(res, 200, withLocation({ branch: {} }));
-        return;
-    }
-    if (path === "/api/vcs/base" && method === "GET") {
-        json(res, 200, withLocation(null));
-        return;
-    }
-    if (path === "/api/vcs/status" && method === "GET") {
-        json(res, 200, withLocation([]));
+    if (path === "/api/vcs/init" && method === "POST") {
+        if (!(await initializeGit(directory))) {
+            json(res, 400, errorBody("BadRequestError", "Git initialization failed"));
+            return;
+        }
+        res.writeHead(204).end();
         return;
     }
-    if (path === "/api/vcs/branch" && method === "GET") {
-        json(res, 200, withLocation([]));
+    if (path === "/api/vcs" && method === "GET") {
+        const current = await currentGitBranch(directory);
+        json(res, 200, withLocation({ provider: "git", branch: current === undefined ? {} : { current } }));
         return;
     }
-    if (path === "/api/vcs/diff" && method === "GET") {
-        json(res, 200, withLocation(""));
+    if (method === "GET" && ["/api/vcs/base", "/api/vcs/status", "/api/vcs/branch", "/api/vcs/diff"].includes(path)) {
+        try {
+            json(res, 200, withLocation(await vcsRead(directory, path.slice("/api/vcs/".length), url)));
+        }
+        catch (error) {
+            if (!(error instanceof VcsError))
+                throw error;
+            json(res, 400, errorBody(error.name, error.message));
+        }
         return;
     }
     // --- sessions ---
     if (path === "/api/session" && method === "GET") {
         const dir = url.searchParams.get("directory") ?? url.searchParams.get("location");
         const search = url.searchParams.get("search");
+        const parentID = url.searchParams.get("parentID");
+        const order = url.searchParams.get("order") === "asc" ? "asc" : "desc";
         const limit = numberParam(url.searchParams.get("limit"));
         let infos = dir !== null && dir !== "" ? services.sessions.list(dir) : services.sessions.listAll();
         if (search)
             infos = infos.filter((s) => s.title.toLowerCase().includes(search.toLowerCase()));
-        const sessions = infos.map((info) => v2Session(services, info));
-        sessions.sort((a, b) => b.time.updated - a.time.updated);
+        if (parentID !== null)
+            infos = infos.filter((session) => session.parentID === parentID);
+        let sessions = infos.map((info) => v2Session(services, info));
+        sessions.sort((left, right) => compareSessions(left, right, order));
+        const cursor = decodeSessionCursor(url.searchParams.get("cursor"));
+        if (cursor !== undefined)
+            sessions = sessions.filter((session) => followsCursor(session, cursor, order));
         const page = limit !== undefined ? sessions.slice(0, limit) : sessions;
         // The 2.0.4 UI reads `cursor.previous` unconditionally — a list body
         // without a cursor throws "Cannot read properties of undefined".
-        json(res, 200, { data: page, cursor: { previous: null, next: null } });
+        const next = limit !== undefined && page.length < sessions.length && page.at(-1) !== undefined
+            ? encodeSessionCursor(page.at(-1))
+            : null;
+        json(res, 200, { data: page, cursor: { previous: null, next } });
         return;
     }
     if (path === "/api/session" && method === "POST") {
         const body = (await services.body(req));
-        const dir = body.location?.directory ?? directory;
-        const info = await services.sessions.create(dir, body.title, body.parentID);
+        for (const field of ["id", "agent", "title", "parentID"]) {
+            if (body[field] !== undefined && typeof body[field] !== "string")
+                throw new RequestBodyError(400, `${field} must be a string`);
+        }
+        if (body.location !== undefined &&
+            (typeof body.location !== "object" || body.location === null || Array.isArray(body.location)))
+            throw new RequestBodyError(400, "location must be an object");
+        const dir = sessionDirectory(body.location?.directory ?? directory);
+        const metadata = sessionMetadata(body.metadata);
+        const model = modelRefFromBody(body.model);
+        if (body.model !== undefined && model === undefined)
+            throw new RequestBodyError(400, "model requires providerID and id or modelID");
+        const info = await services.sessions.create(dir, body.title, body.parentID, {
+            ...(body.id !== undefined ? { id: body.id } : {}),
+            ...(body.agent !== undefined ? { agent: body.agent } : {}),
+            ...(model !== undefined ? { model } : {}),
+            ...(metadata !== undefined ? { metadata } : {}),
+        });
         json(res, 200, { data: v2Session(services, info) });
         return;
     }
@@ -285,7 +466,8 @@ export async function handleV2(services, req, res, url, path, method, directory)
             const requestId = decodeURIComponent(permissionMatch[1]);
             if (permissionMatch[2] === "/reply" && method === "POST") {
                 const body = (await services.body(req));
-                if (!body.reply || !services.sessions.replyPermission(sessionId, requestId, body.reply, body.message)) {
+                const decision = body.decision ?? body.reply;
+                if (!decision || !services.sessions.replyPermission(sessionId, requestId, decision, body.message)) {
                     json(res, 404, errorBody("PermissionNotFoundError", `permission not found: ${requestId}`));
                     return;
                 }
@@ -302,6 +484,11 @@ export async function handleV2(services, req, res, url, path, method, directory)
             }
         }
         switch (`${method} ${sub}`) {
+            case "POST /generate":
+            case "POST /background":
+            case "POST /move":
+                json(res, 400, errorBody("UnsupportedError", `Session ${sub.slice(1)} is not available with OmO`));
+                return;
             case "GET /todo":
                 json(res, 200, { data: services.sessions.todos(sessionId) });
                 return;
@@ -311,7 +498,11 @@ export async function handleV2(services, req, res, url, path, method, directory)
             }
             case "PATCH ": {
                 const body = (await services.body(req));
-                services.sessions.update(sessionId, { title: body.title, archived: body.time?.archived });
+                await services.sessions.update(sessionId, {
+                    title: body.title,
+                    archived: body.time?.archived,
+                    metadata: sessionMetadata(body.metadata),
+                });
                 res.writeHead(204).end();
                 return;
             }
@@ -326,11 +517,21 @@ export async function handleV2(services, req, res, url, path, method, directory)
                 let messages = (services.sessions.messages(sessionId) ?? []).map((m) => toV2Message(m));
                 if (order !== "asc")
                     messages = messages.reverse(); // v2 default is newest-first
-                if (limit !== undefined)
-                    messages = messages.slice(0, limit);
-                json(res, 200, { data: messages, cursor: { previous: null, next: null } });
+                const cursor = url.searchParams.get("cursor");
+                if (cursor !== null) {
+                    const boundary = messages.findIndex((message) => message.id === cursor);
+                    if (boundary >= 0)
+                        messages = messages.slice(boundary + 1);
+                }
+                const page = limit === undefined ? messages : messages.slice(0, limit);
+                const last = page.at(-1);
+                json(res, 200, {
+                    data: page,
+                    cursor: { previous: null, next: last && page.length < messages.length ? last.id : null },
+                });
                 return;
             }
+            case "POST /compact":
             case "POST /summarize": {
                 await services.body(req);
                 const result = await compactSession(services.sessions, sessionId);
@@ -343,38 +544,34 @@ export async function handleV2(services, req, res, url, path, method, directory)
                 return;
             }
             case "POST /shell": {
-                const command = parseShellCommand(await services.body(req));
-                if (command === undefined) {
+                const result = await runSessionShell(services, managed, await services.body(req));
+                if (result.kind === "input") {
                     json(res, 400, errorBody("BadRequestError", "command is required"));
                     return;
                 }
-                if (managed.status.type !== "idle") {
+                if (result.kind === "busy") {
                     json(res, 409, errorBody("SessionBusyError", "session is busy"));
                     return;
                 }
-                const result = await runShellCommand({
-                    sessions: services.sessions,
-                    session: managed,
-                    command,
-                    emit: services.broadcast,
-                });
                 if (result.kind === "error") {
                     json(res, 400, errorBody("BadRequestError", result.message));
                     return;
                 }
-                json(res, 200, { data: toV2Message(result.message) });
+                res.writeHead(204).end();
                 return;
             }
             case "POST /command": {
-                const input = parseSlashCommand(await services.body(req));
-                if (input === undefined) {
+                const body = (await services.body(req));
+                const result = await runSessionSlash(services, sessionId, {
+                    command: body.name,
+                    arguments: body.text ?? "",
+                    messageID: body.id,
+                });
+                if (result.kind === "input") {
                     json(res, 400, errorBody("BadRequestError", "command is required"));
                     return;
                 }
-                const message = await runSlashCommand(services.sessions, sessionId, input);
-                json(res, 200, {
-                    data: message === undefined ? { info: null, parts: [] } : { info: toV2Message(message), parts: message.parts },
-                });
+                res.writeHead(204).end();
                 return;
             }
             case "POST /share":
@@ -384,7 +581,38 @@ export async function handleV2(services, req, res, url, path, method, directory)
                 return;
             case "POST /prompt": {
                 const body = (await services.body(req));
-                const text = typeof body.text === "string" ? body.text : "";
+                if (typeof body.text !== "string") {
+                    json(res, 400, { _tag: "InvalidRequestError", message: "text must be a string" });
+                    return;
+                }
+                const explicit = parsePromptParts(body.parts);
+                const text = body.text;
+                const parts = explicit.length > 0
+                    ? [...explicit, ...v2PromptParts("", body.files, body.agents)]
+                    : v2PromptParts(text, body.files, body.agents);
+                if (text.trim() === "" && !parts.some((part) => part.type === "file" || part.type === "agent")) {
+                    json(res, 400, {
+                        _tag: "InvalidRequestError",
+                        message: "prompt requires non-whitespace text, files, or agents",
+                    });
+                    return;
+                }
+                const metadata = sessionMetadata(body.metadata);
+                if (body.skills !== undefined) {
+                    if (!Array.isArray(body.skills))
+                        throw new RequestBodyError(400, "skills must be an array");
+                    const skill = body.skills[0];
+                    if (skill !== undefined) {
+                        if (typeof skill !== "object" || skill === null || !("id" in skill) || typeof skill.id !== "string")
+                            throw new RequestBodyError(400, "skills must contain {id} references");
+                        // GET /api/skill lists none, so any reference is unknown. OpenChamber retries without
+                        // the attachment on exactly this tagged OpenCode error.
+                        json(res, 400, { _tag: "InvalidRequestError", message: `Skill not found: ${skill.id}` });
+                        return;
+                    }
+                }
+                // Reject an attachment the native RPC cannot carry before acknowledging the prompt.
+                nativePromptInput(text, parts);
                 const messageID = typeof body.id === "string" && body.id !== "" ? body.id : `msg_${randomUUID().replaceAll("-", "")}`;
                 const model = modelRefFromBody(body.model ?? (body.variant !== undefined ? managed.model : undefined), body.variant);
                 if (body.delivery !== undefined && body.delivery !== "steer" && body.delivery !== "queue") {
@@ -392,7 +620,7 @@ export async function handleV2(services, req, res, url, path, method, directory)
                     return;
                 }
                 const delivery = body.delivery ?? "steer";
-                promptAsync(services, managed, text, model, false, messageID, delivery);
+                promptAsync(services, managed, text, model, false, messageID, delivery, parts.length > 0 ? parts : undefined, metadata);
                 json(res, 200, {
                     data: {
                         id: messageID,
@@ -400,19 +628,97 @@ export async function handleV2(services, req, res, url, path, method, directory)
                         time: { created: Date.now() },
                         type: "user",
                         text,
-                        payload: { text },
+                        payload: { text, ...v2PromptAttachments(parts) },
                         delivery,
+                        ...(metadata !== undefined ? { metadata } : {}),
+                    },
+                });
+                return;
+            }
+            case "POST /synthetic":
+            case "POST /context": {
+                const body = (await services.body(req));
+                if (typeof body.text !== "string" || body.text.trim() === "") {
+                    json(res, 400, { _tag: "InvalidRequestError", message: "text must be a non-whitespace string" });
+                    return;
+                }
+                if (body.delivery !== undefined && body.delivery !== "steer" && body.delivery !== "queue") {
+                    json(res, 400, errorBody("BadRequestError", 'delivery must be "steer" or "queue"'));
+                    return;
+                }
+                const metadata = sessionMetadata(body.metadata);
+                const messageID = typeof body.id === "string" && body.id !== "" ? body.id : `msg_${randomUUID().replaceAll("-", "")}`;
+                const text = body.text;
+                promptAsync(services, managed, text, undefined, true, messageID, body.delivery ?? "steer", undefined, metadata);
+                // OpenChamber 2.3.2 treats anything but 200 + the admitted record as a failed send (captured OpenCode shape).
+                json(res, 200, {
+                    data: {
+                        id: messageID,
+                        sessionID: sessionId,
+                        time: { created: Date.now() },
+                        type: "synthetic",
+                        payload: { text },
                     },
                 });
                 return;
             }
             case "POST /interrupt": {
-                await services.sessions.abort(sessionId);
-                json(res, 200, { data: true });
+                const interrupted = await services.sessions.abort(sessionId);
+                // Bare body, as captured from OpenCode 2.x: OpenChamber reads `result.interrupted` directly.
+                json(res, 200, { interrupted });
+                return;
+            }
+            case "POST /fork":
+            case "POST /revert":
+            case "POST /revert/stage":
+            case "POST /revert/commit":
+            case "DELETE /revert": {
+                const body = method === "DELETE" ? {} : await services.body(req);
+                const target = typeof body === "object" && body !== null
+                    ? "before" in body
+                        ? body.before
+                        : "messageID" in body
+                            ? body.messageID
+                            : undefined
+                    : undefined;
+                if ((sub === "/revert" || sub === "/revert/stage") &&
+                    method === "POST" &&
+                    (typeof target !== "string" || target === "")) {
+                    json(res, 400, errorBody("InvalidRequestError", "messageID is required"));
+                    return;
+                }
+                try {
+                    if (sub === "/fork") {
+                        if (target !== undefined && (typeof target !== "string" || target === ""))
+                            throw new Error("before must be a nonempty message id");
+                        const info = await services.sessions.fork(sessionId, typeof target === "string" ? target : undefined);
+                        json(res, 200, { data: v2Session(services, info) });
+                    }
+                    else if (method === "DELETE") {
+                        await services.sessions.unrevert(sessionId);
+                        res.writeHead(204).end();
+                    }
+                    else if (sub === "/revert/commit") {
+                        await services.sessions.commitRevert(sessionId);
+                        res.writeHead(204).end();
+                    }
+                    else {
+                        const info = await services.sessions.revert(sessionId, String(target));
+                        json(res, 200, { data: info.revert });
+                    }
+                }
+                catch (error) {
+                    json(res, 400, errorBody("SessionTreeError", error instanceof Error ? error.message : String(error)));
+                }
                 return;
             }
             case "POST /agent": {
-                await services.body(req); // agent is fixed per connector — acknowledge and ignore
+                const body = (await services.body(req));
+                if (typeof body.agent !== "string") {
+                    json(res, 400, errorBody("InvalidRequestError", "agent must be a string"));
+                    return;
+                }
+                await services.sessions.update(sessionId, { agent: body.agent });
                 res.writeHead(204).end();
                 return;
             }
@@ -462,7 +768,13 @@ export async function handleV2(services, req, res, url, path, method, directory)
                 return;
             }
             case "GET /diff":
-                json(res, 200, { data: await services.sessions.diff(sessionId) });
+                json(res, 200, {
+                    data: await services.sessions.diff(sessionId, {
+                        from: url.searchParams.get("from") ?? undefined,
+                        to: url.searchParams.get("to") ?? undefined,
+                        context: numberParam(url.searchParams.get("context")),
+                    }),
+                });
                 return;
             case "GET /context": {
                 json(res, 501, errorBody("NotImplemented", `${method} ${path} is not implemented by this connector`));