@xiaohhhh1/canvas-agent 0.2.2

package/dist/agents.js

@@ -0,0 +1,557 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { AGENT_PROMPT, VERSION } from "./config.js";
+let codexQueue = Promise.resolve();
+let codexApp = null;
+let codexAppStart = null;
+let codexThreadId = "";
+const canvasAgentMcp = canvasAgentMcpCommand();
+const require = createRequire(import.meta.url);
+export function withAgentPrompt(prompt) {
+    const commerceGuidelines = "画布内所有商品图片、视频参考图和中间资产默认使用用户自有 OSS；禁止把任何密钥写入画布、提示词、日志或前端。用户请求带货视频但未指定流程时，先确认流程 A 或 B；流程 A 使用结构化脚本和已审核的同 SKU 官方商品图，流程 B 使用最多 5 张同 SKU 官方图生成审核后的商品板。两个流程都只提交稳定 HTTPS 的 OSS 素材 URL。";
+    return prompt.trim() ? `${AGENT_PROMPT}\n\n${commerceGuidelines}\n\n用户请求：${prompt}` : "";
+}
+export async function runCodexTurn(prompt, emit, attachments = [], options = {}) {
+    if (!prompt.trim())
+        return;
+    codexQueue = codexQueue.catch(() => undefined).then(() => runCodexTurnNow(prompt, emit, attachments, options));
+    await codexQueue;
+}
+export function interruptCodexTurn(threadId) {
+    if (!codexApp || (threadId && threadId !== codexThreadId))
+        return false;
+    return codexApp.interruptCurrentTurn();
+}
+async function runCodexTurnNow(prompt, emit, attachments, options) {
+    let files = [];
+    try {
+        options.onStart?.();
+        files = await writeAttachmentFiles(attachments);
+        const app = await getCodexApp(options.appEmit || emit);
+        let threadId = await ensureCodexThread(app, options, emit);
+        options.onThread?.(threadId);
+        try {
+            await app.startTurn(threadId, prompt, files, options.onTurn);
+        }
+        catch (error) {
+            if (!isRecoverableThreadError(error))
+                throw error;
+            emit("agent_log", { text: `Codex thread unavailable, starting a new thread: ${errorMessage(error)}` });
+            codexThreadId = "";
+            threadId = await ensureCodexThread(app, { cwd: options.cwd }, emit);
+            options.onThread?.(threadId);
+            await app.startTurn(threadId, prompt, files, options.onTurn);
+        }
+    }
+    catch (error) {
+        emit("agent_error", { message: errorMessage(error) });
+    }
+    finally {
+        options.onFinish?.();
+        await Promise.all(files.map((file) => fs.unlink(file).catch(() => undefined)));
+    }
+}
+export async function startCodexThread(emit, cwd) {
+    const app = await getCodexApp(emit);
+    const thread = await app.startThread(cwd);
+    codexThreadId = String(field(thread, "id") || "");
+    return thread;
+}
+export async function resumeCodexThread(emit, threadId, cwd) {
+    const app = await getCodexApp(emit);
+    await loadCodexThread(emit, threadId, cwd, false);
+    const thread = await app.resumeThread(threadId, cwd);
+    assertThreadWorkspace(thread, cwd);
+    codexThreadId = String(field(thread, "id") || threadId);
+    return { thread, messages: threadMessages(thread) };
+}
+export async function listCodexThreads(emit, options) {
+    const app = await getCodexApp(emit);
+    const result = await app.listThreads({
+        limit: options.limit || 40,
+        sortKey: "updated_at",
+        sortDirection: "desc",
+        sourceKinds: ["cli", "vscode", "appServer", "exec"],
+        cwd: options.cwd,
+        ...(options.searchTerm ? { searchTerm: options.searchTerm } : {}),
+    });
+    const data = Array.isArray(field(result, "data")) ? field(result, "data").map(summarizeCodexThread).filter((thread) => threadInWorkspace(thread, options.cwd)) : [];
+    return { data, nextCursor: field(result, "nextCursor") || null, backwardsCursor: field(result, "backwardsCursor") || null };
+}
+export async function readCodexThread(emit, threadId, cwd) {
+    const thread = await loadCodexThread(emit, threadId, cwd, true);
+    return { thread: summarizeCodexThread(thread), messages: threadMessages(thread) };
+}
+export async function verifyCodexThreadWorkspace(emit, threadId, cwd) {
+    await loadCodexThread(emit, threadId, cwd, false);
+}
+export async function archiveCodexThread(emit, threadId, cwd) {
+    const app = await getCodexApp(emit);
+    await loadCodexThread(emit, threadId, cwd, false);
+    await app.archiveThread(threadId);
+}
+export function runClaudeTurn(prompt, emit) {
+    if (!prompt.trim())
+        return;
+    const child = spawnAgent("claude", ["-p", "--output-format", "stream-json", "--verbose", "--include-partial-messages", "--allowedTools", "mcp__infinite-canvas__*", prompt], ["ignore", "pipe", "pipe"], emit);
+    if (!child)
+        return;
+    pipeJsonLines(child, emit, "claude");
+}
+async function ensureCodexThread(app, options, emit) {
+    if (options.threadId) {
+        if (options.threadId === codexThreadId)
+            return codexThreadId;
+        try {
+            const result = await app.readThread(options.threadId, false);
+            assertThreadWorkspace(field(result, "thread") || {}, options.cwd);
+            const thread = await app.resumeThread(options.threadId, options.cwd);
+            assertThreadWorkspace(thread, options.cwd);
+            codexThreadId = String(field(thread, "id") || options.threadId);
+            return codexThreadId;
+        }
+        catch (error) {
+            if (!isRecoverableThreadError(error))
+                throw error;
+            emit("agent_log", { text: `Codex thread unavailable, starting a new thread: ${errorMessage(error)}` });
+        }
+    }
+    if (!codexThreadId) {
+        const thread = await app.startThread(options.cwd);
+        codexThreadId = String(field(thread, "id") || "");
+    }
+    return codexThreadId;
+}
+export function isRecoverableThreadError(error) {
+    return /thread not loaded|no rollout found/i.test(errorMessage(error));
+}
+class CodexAppClient {
+    child;
+    emit;
+    nextId = 1;
+    buffer = "";
+    textByItem = new Map();
+    deltaCount = 0;
+    lastUsage = null;
+    pending = new Map();
+    activeTurns = new Map();
+    completedTurns = new Map();
+    constructor(child, emit) {
+        this.child = child;
+        this.emit = emit;
+    }
+    static async start(emit) {
+        const child = spawn(process.execPath, [codexBin(), "app-server", "--stdio"], { stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+        const client = new CodexAppClient(child, emit);
+        child.stdout?.on("data", (chunk) => client.read(chunk.toString()));
+        child.stderr?.on("data", (chunk) => emit("agent_log", { text: chunk.toString() }));
+        child.on("error", (error) => emit("agent_error", { message: error.message }));
+        child.on("exit", (code) => {
+            client.failAll(`Codex app-server exited: ${code ?? 0}`);
+            codexApp = null;
+            codexThreadId = "";
+            emit("agent_log", { text: `Codex app-server exited: ${code ?? 0}` });
+        });
+        await client.request("initialize", { clientInfo: { name: "canvas-agent", title: "Infinite Canvas Agent", version: VERSION }, capabilities: { experimentalApi: true, requestAttestation: false } });
+        client.notify("initialized");
+        return client;
+    }
+    async startThread(cwd) {
+        const result = await this.request("thread/start", { approvalPolicy: "never", sandbox: "workspace-write", config: codexConfig(), ...(cwd ? { cwd } : {}), threadSource: "user" });
+        const thread = field(result, "thread");
+        const id = String(field(thread, "id") || "");
+        if (!id)
+            throw new Error("Codex app-server 没有返回 thread id");
+        return thread || {};
+    }
+    async resumeThread(threadId, cwd) {
+        const result = await this.request("thread/resume", { threadId, approvalPolicy: "never", sandbox: "workspace-write", config: codexConfig(), ...(cwd ? { cwd } : {}) });
+        const thread = field(result, "thread");
+        const id = String(field(thread, "id") || "");
+        if (!id)
+            throw new Error("Codex app-server 没有返回 thread id");
+        return thread || {};
+    }
+    listThreads(params) {
+        return this.request("thread/list", params);
+    }
+    readThread(threadId, includeTurns = true) {
+        return this.request("thread/read", { threadId, includeTurns });
+    }
+    archiveThread(threadId) {
+        return this.request("thread/archive", { threadId });
+    }
+    async startTurn(threadId, prompt, images, onTurn) {
+        const result = await this.request("turn/start", { threadId, input: codexInput(prompt, images), approvalPolicy: "never" });
+        const turnId = String(field(field(result, "turn"), "id") || "");
+        if (!turnId)
+            throw new Error("Codex app-server 没有返回 turn id");
+        onTurn?.(turnId);
+        const completed = this.completedTurns.get(turnId);
+        if (this.completedTurns.has(turnId)) {
+            this.completedTurns.delete(turnId);
+            if (completed)
+                throw completed;
+            return;
+        }
+        await new Promise((resolve, reject) => this.activeTurns.set(turnId, { resolve, reject }));
+    }
+    interruptCurrentTurn() {
+        if (this.activeTurns.size === 0)
+            return false;
+        try {
+            this.child.kill("SIGINT");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    request(method, params) {
+        const id = this.nextId++;
+        this.write({ id, method, params });
+        return new Promise((resolve, reject) => this.pending.set(id, { resolve, reject }));
+    }
+    notify(method, params) {
+        this.write(params === undefined ? { method } : { method, params });
+    }
+    write(value) {
+        this.child.stdin?.write(`${JSON.stringify(value)}\n`);
+    }
+    read(chunk) {
+        this.buffer += chunk;
+        const lines = this.buffer.split(/\r?\n/);
+        this.buffer = lines.pop() || "";
+        lines.filter(Boolean).forEach((line) => {
+            try {
+                this.handle(JSON.parse(line));
+            }
+            catch {
+                this.emit("agent_log", { text: line });
+            }
+        });
+    }
+    handle(message) {
+        const id = Number(message.id);
+        if (message.error && this.pending.has(id))
+            return this.reject(id, String(field(message.error, "message") || "Codex request failed"));
+        if (this.pending.has(id))
+            return this.resolve(id, message.result);
+        if (typeof message.method === "string" && "id" in message)
+            return this.answerServerRequest(message);
+        if (typeof message.method === "string")
+            this.handleNotification(message.method, (message.params || {}));
+    }
+    handleNotification(method, params) {
+        if (method === "item/agentMessage/delta")
+            return this.emitDelta(params);
+        if (method === "thread/tokenUsage/updated")
+            this.lastUsage = normalizeUsage(params);
+        const event = normalizeCodexNotification(method, params);
+        if (!event)
+            return;
+        if (event.type === "turn.completed")
+            event.usage = this.lastUsage;
+        this.emit("agent_event", { agent: "codex", ...event });
+        if (event.type === "turn.completed") {
+            const turnId = String(field(params, "turnId") || field(field(params, "turn"), "id") || "");
+            const pending = this.activeTurns.get(turnId);
+            const error = field(field(params, "turn"), "error");
+            if (pending) {
+                this.activeTurns.delete(turnId);
+                error ? pending.reject(new Error(String(field(error, "message") || "Codex turn failed"))) : pending.resolve(event);
+            }
+            else if (turnId) {
+                this.completedTurns.set(turnId, error ? new Error(String(field(error, "message") || "Codex turn failed")) : null);
+            }
+            this.emit("agent_event", { agent: "codex", type: "stream.summary", delta_count: this.deltaCount, ...codexEventScope(params) });
+            this.deltaCount = 0;
+            this.emit("agent_done", { agent: "codex", usage: event.usage, ...codexEventScope(params) });
+        }
+    }
+    emitDelta(params) {
+        const id = String(field(params, "itemId") || "");
+        const text = `${this.textByItem.get(id) || ""}${String(field(params, "delta") || "")}`;
+        this.deltaCount += 1;
+        this.textByItem.set(id, text);
+        this.emit("agent_event", { agent: "codex", type: "item.updated", item: { id, type: "agent_message", text }, ...codexEventScope(params) });
+    }
+    answerServerRequest(message) {
+        const method = String(message.method);
+        const result = method === "mcpServer/elicitation/request" ? { action: "accept", content: {}, _meta: null } : { decision: "decline" };
+        this.write({ id: message.id, result });
+        this.emit("agent_event", { agent: "codex", type: "server.request", method, params: message.params, result });
+    }
+    resolve(id, result) {
+        const pending = this.pending.get(id);
+        if (pending)
+            (this.pending.delete(id), pending.resolve(result));
+    }
+    reject(id, message) {
+        const pending = this.pending.get(id);
+        if (pending)
+            (this.pending.delete(id), pending.reject(new Error(message)));
+    }
+    failAll(message) {
+        [...this.pending.values(), ...this.activeTurns.values()].forEach((item) => item.reject(new Error(message)));
+        this.pending.clear();
+        this.activeTurns.clear();
+    }
+}
+function canvasAgentMcpCommand() {
+    const current = process.argv.find((arg) => /index\.(t|j)s$/.test(arg)) || "";
+    const entry = path.resolve(current || fileURLToPath(new URL("./index.js", import.meta.url)));
+    const tsx = path.join(path.dirname(entry), "..", "node_modules", "tsx", "dist", "cli.mjs");
+    return entry.endsWith(".ts") ? { command: process.execPath, args: [tsx, entry, "mcp"] } : { command: process.execPath, args: [entry, "mcp"] };
+}
+function codexConfig() {
+    return {
+        model: process.env.CANVAS_AGENT_CODEX_MODEL || "gpt-5.4",
+        mcp_servers: { "infinite-canvas": { command: canvasAgentMcp.command, args: canvasAgentMcp.args, default_tools_approval_mode: "approve", startup_timeout_sec: 20, tool_timeout_sec: 90 } },
+    };
+}
+function codexInput(prompt, images) {
+    return [{ type: "text", text: prompt, text_elements: [] }, ...images.map((file) => ({ type: "localImage", path: file }))];
+}
+function normalizeCodexNotification(method, params) {
+    const scope = codexEventScope(params);
+    if (method === "thread/started")
+        return { type: "thread.started", ...scope };
+    if (method === "turn/started")
+        return { type: "turn.started", ...scope };
+    if (method === "turn/completed")
+        return { type: "turn.completed", usage: null, ...scope };
+    if (method === "item/started")
+        return { type: "item.started", item: normalizeItem(field(params, "item")), ...scope };
+    if (method === "item/completed")
+        return { type: "item.completed", item: normalizeItem(field(params, "item")), ...scope };
+    if (method === "error")
+        return { type: "error", message: field(params, "message"), ...scope };
+    return null;
+}
+function codexEventScope(params) {
+    const threadId = String(field(params, "threadId") || field(field(params, "thread"), "id") || "");
+    const turnId = String(field(params, "turnId") || field(field(params, "turn"), "id") || "");
+    return { ...(threadId ? { thread_id: threadId } : {}), ...(turnId ? { turn_id: turnId } : {}) };
+}
+async function loadCodexThread(emit, threadId, cwd, includeTurns) {
+    const app = await getCodexApp(emit);
+    const result = await app.readThread(threadId, includeTurns);
+    const thread = field(result, "thread") || {};
+    assertThreadWorkspace(thread, cwd);
+    return thread;
+}
+async function getCodexApp(emit) {
+    if (codexApp)
+        return codexApp;
+    codexAppStart ||= CodexAppClient.start(emit);
+    try {
+        codexApp = await codexAppStart;
+        return codexApp;
+    }
+    finally {
+        codexAppStart = null;
+    }
+}
+function assertThreadWorkspace(thread, cwd) {
+    if (!cwd || threadInWorkspace(thread, cwd))
+        return;
+    throw new Error("该 Codex 会话不属于当前画布工作空间");
+}
+function threadInWorkspace(thread, cwd) {
+    const threadCwd = String(field(thread, "cwd") || "");
+    return Boolean(threadCwd && path.resolve(threadCwd) === path.resolve(cwd));
+}
+function normalizeItem(item) {
+    const value = item && typeof item === "object" ? { ...item } : {};
+    if (value.type === "agentMessage")
+        value.type = "agent_message";
+    if (value.type === "mcpToolCall")
+        value.type = "mcp_tool_call";
+    if (value.type === "agent_message" && typeof value.id === "string")
+        value.text = String(value.text || "");
+    if ("arguments" in value)
+        value.arguments = parseMaybeJson(value.arguments);
+    return value;
+}
+function normalizeUsage(params) {
+    const total = field(field(params, "tokenUsage"), "total");
+    return {
+        input_tokens: field(total, "inputTokens"),
+        cached_input_tokens: field(total, "cachedInputTokens"),
+        output_tokens: field(total, "outputTokens"),
+        reasoning_output_tokens: field(total, "reasoningOutputTokens"),
+    };
+}
+function parseMaybeJson(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function field(value, key) {
+    return value && typeof value === "object" ? value[key] : undefined;
+}
+export function summarizeCodexThread(thread) {
+    return {
+        id: String(field(thread, "id") || ""),
+        sessionId: String(field(thread, "sessionId") || ""),
+        preview: displayUserText(String(field(thread, "preview") || "")),
+        name: stringOrNull(field(thread, "name")),
+        cwd: String(field(thread, "cwd") || ""),
+        status: String(field(thread, "status") || ""),
+        source: field(thread, "source"),
+        threadSource: field(thread, "threadSource"),
+        createdAt: Number(field(thread, "createdAt") || 0),
+        updatedAt: Number(field(thread, "updatedAt") || 0),
+    };
+}
+function threadMessages(thread) {
+    const turns = arrayValue(field(thread, "turns"));
+    const messages = [];
+    turns.forEach((turn, turnIndex) => {
+        arrayValue(field(turn, "items")).forEach((item, itemIndex) => {
+            const type = String(field(item, "type") || "");
+            const id = String(field(item, "id") || `${turnIndex}-${itemIndex}`);
+            if (type === "userMessage") {
+                const text = displayUserText(userInputText(field(item, "content")));
+                if (text)
+                    messages.push({ id, role: "user", text });
+            }
+            if (type === "agentMessage") {
+                const text = String(field(item, "text") || "").trim();
+                if (text)
+                    messages.push({ id, role: "assistant", title: "Codex", text, streamId: id });
+            }
+            if (type === "mcpToolCall") {
+                const tool = String(field(item, "tool") || "工具调用");
+                const error = field(field(item, "error"), "message");
+                messages.push({ id, role: error ? "error" : "tool", title: toolName(tool), text: error ? String(error) : `${toolName(tool)} ${String(field(item, "status") || "完成")}`, detail: item });
+            }
+            if (type === "commandExecution") {
+                const command = String(field(item, "command") || "").trim();
+                if (command)
+                    messages.push({ id, role: "tool", title: "命令", text: command, detail: { cwd: field(item, "cwd"), status: field(item, "status"), exitCode: field(item, "exitCode") } });
+            }
+            if (type === "fileChange")
+                messages.push({ id, role: "tool", title: "文件变更", text: "Codex 修改了文件", detail: item });
+        });
+    });
+    return messages.filter((item) => item.text).slice(-120);
+}
+function userInputText(content) {
+    return arrayValue(content)
+        .map((item) => {
+        const type = String(field(item, "type") || "");
+        if (type === "text")
+            return String(field(item, "text") || "");
+        if (type === "image" || type === "localImage")
+            return "图片附件";
+        if (type === "mention")
+            return `@${String(field(item, "name") || "文件")}`;
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+function displayUserText(text) {
+    const value = text.trim();
+    const marker = "用户请求：";
+    const index = value.lastIndexOf(marker);
+    return (index >= 0 ? value.slice(index + marker.length) : value).trim();
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function stringOrNull(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function toolName(name) {
+    if (name === "canvas_apply_ops")
+        return "画布操作";
+    if (name === "canvas_get_state")
+        return "读取画布";
+    if (name === "canvas_get_selection")
+        return "读取选区";
+    if (name === "canvas_export_snapshot")
+        return "导出快照";
+    if (name === "canvas_create_attachment_nodes")
+        return "添加附件图片";
+    if (name === "canvas_create_text_node")
+        return "创建文本";
+    if (name === "canvas_create_image_prompt_flow")
+        return "创建生图流程";
+    if (name === "canvas_create_generation_flow")
+        return "创建生成流程";
+    if (name === "canvas_generate_text")
+        return "生成文本";
+    if (name === "canvas_generate_image")
+        return "生成图片";
+    if (name === "canvas_generate_video")
+        return "生成视频";
+    if (name === "canvas_generate_audio")
+        return "生成音频";
+    if (name === "canvas_run_generation")
+        return "触发生成";
+    return name;
+}
+async function writeAttachmentFiles(attachments) {
+    return await Promise.all(attachments.filter((item) => item.dataUrl?.startsWith("data:image/")).map(writeAttachmentFile));
+}
+async function writeAttachmentFile(item) {
+    const [, meta = "", data = ""] = item.dataUrl?.match(/^data:([^;]+);base64,(.+)$/) || [];
+    if (!data)
+        throw new Error(`图片附件无效：${item.name || "未命名图片"}`);
+    const file = path.join(os.tmpdir(), `infinite-canvas-${Date.now()}-${Math.random().toString(16).slice(2)}.${imageExt(meta || item.type)}`);
+    await fs.writeFile(file, Buffer.from(data, "base64"));
+    return file;
+}
+function imageExt(type = "") {
+    if (type.includes("png"))
+        return "png";
+    if (type.includes("webp"))
+        return "webp";
+    return "jpg";
+}
+function codexBin() {
+    return path.join(path.dirname(require.resolve("@openai/codex/package.json")), "bin", "codex.js");
+}
+function pipeJsonLines(child, emit, agent) {
+    let out = "";
+    child.stdout?.on("data", (chunk) => {
+        out += chunk.toString();
+        const lines = out.split(/\r?\n/);
+        out = lines.pop() || "";
+        lines.filter(Boolean).forEach((line) => {
+            try {
+                emit("agent_event", { agent, ...JSON.parse(line) });
+            }
+            catch {
+                emit("agent_event", { agent, type: "raw", text: line });
+            }
+        });
+    });
+    child.stderr?.on("data", (chunk) => emit("agent_log", { text: chunk.toString() }));
+    child.on("error", (error) => emit("agent_error", { message: error.message }));
+    child.on("close", (code) => emit("agent_done", { agent, code }));
+}
+function spawnAgent(name, args, stdio, emit) {
+    try {
+        return spawn(name, args, { stdio, shell: process.platform === "win32", windowsHide: true });
+    }
+    catch (error) {
+        emit("agent_error", { message: errorMessage(error) });
+        return null;
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/canvas-session.d.ts

@@ -0,0 +1,64 @@
+import type { ServerResponse } from "node:http";
+import type { AgentAttachment } from "./types.js";
+type TurnAttachment = {
+    clientId: string;
+    id: string;
+    name: string;
+    type: string;
+    size: number;
+    width: number;
+    height: number;
+    dataUrl: string;
+};
+export type CodexState = {
+    busy: boolean;
+    threadId: string;
+    turnId: string;
+};
+export declare class CanvasSession {
+    private clients;
+    private clientFocusOrder;
+    private pending;
+    private canvasStates;
+    private turnAttachments;
+    private activeClientId;
+    private boundClientId;
+    private focusSequence;
+    private codexState;
+    private get canvasState();
+    private get targetClientId();
+    health(): {
+        ok: boolean;
+        hasCanvas: boolean;
+        clients: number;
+        codexBusy: boolean;
+    };
+    get codexBusy(): boolean;
+    setCodexState(patch: Partial<CodexState>): void;
+    openEvents(url: URL, res: ServerResponse): void;
+    updateState(body: unknown, clientId?: string): void;
+    activateClient(clientId: string): void;
+    bindClient(clientId: string): void;
+    releaseClient(clientId: string): void;
+    setTurnAttachments(clientId: string, attachments: AgentAttachment[]): {
+        id: string;
+        name: string;
+        type: string;
+        size: number;
+        width: number;
+        height: number;
+    }[];
+    clearTurnAttachments(clientId?: string): void;
+    getTurnAttachment(clientId: string, attachmentId: string): TurnAttachment;
+    resolveResult(clientId: string, body: {
+        requestId?: string;
+        error?: string;
+        result?: unknown;
+    }): boolean;
+    emitAll(type: string, payload: unknown): void;
+    emitThread(type: string, threadId: string, payload?: Record<string, unknown>): void;
+    callTool(name: unknown, rawInput: unknown): Promise<unknown>;
+    private createAttachmentNodes;
+    private requestCanvasTool;
+}
+export {};