qcanvas-local-agent 0.1.0

package/dist/canvas-session.d.ts

@@ -0,0 +1,16 @@
+import type { ServerResponse } from "node:http";
+import type { PendingToolResult, QCanvasSnapshot } from "./types.js";
+export declare class CanvasSession {
+    private readonly clients;
+    private readonly pending;
+    private snapshot;
+    health(): Record<string, unknown>;
+    openEvents(clientIdInput: string | null, res: ServerResponse): void;
+    updateState(body: unknown, clientId: string): QCanvasSnapshot;
+    emitAll(type: string, payload: unknown): void;
+    resolveResult(body: PendingToolResult): void;
+    callTool(rawName: unknown, input: unknown, agent?: string): Promise<unknown>;
+    private readFlow;
+    private createGenerationFlow;
+    private requestBrowserPatch;
+}

package/dist/canvas-session.js

@@ -0,0 +1,154 @@
+import crypto from "node:crypto";
+import { isLocalAgentToolName, localAgentToolInputSchemas } from "./schemas.js";
+import { compileGenerationFlow, GenerationFlowCompileError, } from "./generation-flow-compiler.js";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function readStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return Array.from(new Set(value.map((item) => readString(item)).filter((item) => Boolean(item))));
+}
+function readViewport(value) {
+    if (!isRecord(value))
+        return null;
+    const x = Number(value.x);
+    const y = Number(value.y);
+    const zoom = Number(value.zoom);
+    if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(zoom))
+        return null;
+    return { x, y, zoom };
+}
+function parseCanvasSnapshot(value, clientId) {
+    if (!isRecord(value))
+        throw new Error("canvas state must be an object");
+    const nodes = Array.isArray(value.nodes) ? value.nodes : null;
+    const edges = Array.isArray(value.edges) ? value.edges : null;
+    if (!nodes)
+        throw new Error("canvas state missing nodes array");
+    if (!edges)
+        throw new Error("canvas state missing edges array");
+    return {
+        clientId,
+        url: readString(value.url),
+        projectId: readString(value.projectId),
+        projectName: readString(value.projectName),
+        flowId: readString(value.flowId),
+        flowName: readString(value.flowName),
+        nodes,
+        edges,
+        selectedNodeIds: readStringArray(value.selectedNodeIds),
+        viewport: readViewport(value.viewport),
+        updatedAt: readString(value.updatedAt) || new Date().toISOString(),
+    };
+}
+function writeSse(res, event, data) {
+    res.write(`event: ${event}\n`);
+    res.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+export class CanvasSession {
+    clients = new Map();
+    pending = new Map();
+    snapshot = null;
+    health() {
+        return {
+            ok: true,
+            clients: this.clients.size,
+            hasCanvas: Boolean(this.snapshot && this.clients.has(this.snapshot.clientId)),
+            updatedAt: this.snapshot?.updatedAt || null,
+        };
+    }
+    openEvents(clientIdInput, res) {
+        const clientId = clientIdInput || crypto.randomUUID();
+        res.writeHead(200, {
+            "content-type": "text/event-stream",
+            "cache-control": "no-cache",
+            connection: "keep-alive",
+        });
+        this.clients.set(clientId, res);
+        writeSse(res, "hello", { ok: true, clientId });
+        const timer = setInterval(() => writeSse(res, "ping", { at: new Date().toISOString() }), 15000);
+        res.on("close", () => {
+            clearInterval(timer);
+            this.clients.delete(clientId);
+        });
+    }
+    updateState(body, clientId) {
+        const snapshot = parseCanvasSnapshot(body, clientId);
+        this.snapshot = snapshot;
+        return snapshot;
+    }
+    emitAll(type, payload) {
+        this.clients.forEach((client) => writeSse(client, type, payload));
+    }
+    resolveResult(body) {
+        const requestId = readString(body.requestId);
+        if (!requestId)
+            return;
+        const pending = this.pending.get(requestId);
+        if (!pending)
+            return;
+        this.pending.delete(requestId);
+        clearTimeout(pending.timer);
+        if (body.error) {
+            pending.reject(new Error(body.error));
+            return;
+        }
+        pending.resolve(body.result);
+    }
+    async callTool(rawName, input, agent) {
+        if (!isLocalAgentToolName(rawName)) {
+            throw new Error(`unknown QCanvas local tool: ${String(rawName)}`);
+        }
+        if (rawName === "tapcanvas_flow_get")
+            return this.readFlow();
+        if (rawName === "tapcanvas_create_generation_flow")
+            return this.createGenerationFlow(input, agent);
+        return this.requestBrowserPatch(rawName, input, agent);
+    }
+    readFlow() {
+        if (!this.snapshot || !this.clients.has(this.snapshot.clientId)) {
+            throw new Error("no live QCanvas browser tab is connected");
+        }
+        return this.snapshot;
+    }
+    async createGenerationFlow(input, agent) {
+        const snapshot = this.readFlow();
+        const intent = localAgentToolInputSchemas.tapcanvas_create_generation_flow.parse(input);
+        let compiled;
+        try {
+            compiled = compileGenerationFlow(intent, { nodes: snapshot.nodes });
+        }
+        catch (error) {
+            throw error instanceof GenerationFlowCompileError ? new Error(error.message) : error;
+        }
+        // Reuse the browser's existing tapcanvas_flow_patch executor instead of
+        // teaching the browser a second node-creation code path.
+        const patchResult = await this.requestBrowserPatch("tapcanvas_flow_patch", compiled.patch, agent);
+        return {
+            ...(patchResult && typeof patchResult === "object" ? patchResult : {}),
+            nodeId: compiled.primaryNodeId,
+            warnings: compiled.warnings,
+        };
+    }
+    async requestBrowserPatch(name, input, agent) {
+        if (!this.snapshot || !this.clients.has(this.snapshot.clientId)) {
+            throw new Error("no live QCanvas browser tab is connected");
+        }
+        const client = this.clients.get(this.snapshot.clientId);
+        if (!client)
+            throw new Error("connected QCanvas browser tab is unavailable");
+        const requestId = crypto.randomUUID();
+        writeSse(client, "tool_call", { requestId, name, input, ...(agent ? { agent } : {}) });
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error("QCanvas browser confirmation timed out"));
+            }, 60000);
+            this.pending.set(requestId, { resolve, reject, timer });
+        });
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,29 @@
+export declare const VERSION = "0.1.0";
+export declare const CONFIG_DIR: string;
+export declare const CONFIG_FILE: string;
+export declare const AGENT_PROMPT = "\u4F60\u6B63\u5728\u5E2E\u52A9\u7528\u6237\u64CD\u4F5C QCanvas \u7F51\u9875\u753B\u5E03\u3002\u9700\u8981\u6539\u52A8\u753B\u5E03\u65F6\u4F18\u5148\u4F7F\u7528\u5DF2\u914D\u7F6E\u7684 qcanvas MCP \u5DE5\u5177\uFF1A\u5148\u7528 tapcanvas_flow_get \u8BFB\u53D6\u5F53\u524D\u753B\u5E03\u56FE\uFF08\u8282\u70B9 nodes / \u8FDE\u7EBF edges / \u9009\u533A selectedNodeIds\uFF09\uFF0C\u518D\u7528 tapcanvas_flow_patch \u63D0\u4EA4\u6539\u52A8\u3002tapcanvas_flow_patch \u652F\u6301 createNodes\u3001createEdges\u3001patchNodeData\u3001appendNodeArrays\u3001deleteNodeIds\u3001deleteEdgeIds\uFF1B\u8282\u70B9 type \u7528 \"taskNode\" \u6216 \"groupNode\"\uFF0Cdata \u91CC\u653E kind\uFF08image/text/video/audio \u7B49\uFF09\u4E0E\u4E1A\u52A1\u5B57\u6BB5\u3002\u6240\u6709\u5199\u64CD\u4F5C\u90FD\u4F1A\u7531\u6D4F\u89C8\u5668\u4E8C\u6B21\u786E\u8BA4\u540E\u624D\u771F\u6B63\u5E94\u7528\uFF0C\u4E0D\u8981\u6A21\u62DF\u9F20\u6807\u70B9\u51FB\uFF0C\u4E5F\u4E0D\u8981\u8981\u6C42\u7528\u6237\u624B\u52A8\u590D\u5236 JSON\u3002";
+export type CanvasWorkspaceConfig = {
+    workspacePath: string;
+    /** 每个本机智能体在该画布上的活跃会话/线程 id，按 agentId 索引。 */
+    activeThreadIds?: Record<string, string>;
+};
+export type LocalAgentConfig = {
+    host: string;
+    port: number;
+    url: string;
+    token: string;
+    /** Claude Code CLI 可执行命令；不在 PATH 时可配置完整路径。 */
+    claudeCommand: string;
+    origins: string[];
+    canvases: Record<string, CanvasWorkspaceConfig>;
+};
+export type CanvasWorkspace = {
+    canvasId: string;
+    workspacePath: string;
+    activeThreadIds: Record<string, string>;
+};
+export declare function ensureCanvasWorkspace(config: LocalAgentConfig, canvasId: string): CanvasWorkspace;
+export declare function setCanvasActiveThread(config: LocalAgentConfig, canvasId: string, agentId: string, threadId: string): CanvasWorkspace;
+export declare function saveConfig(config: LocalAgentConfig): void;
+export declare function loadConfig(writeIfMissing: boolean): LocalAgentConfig;
+export declare function rememberOrigin(config: LocalAgentConfig, origin: string | null): LocalAgentConfig;

package/dist/config.js

@@ -0,0 +1,150 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export const VERSION = "0.1.0";
+export const CONFIG_DIR = path.join(os.homedir(), ".qcanvas");
+export const CONFIG_FILE = path.join(CONFIG_DIR, "qcanvas-local-agent.json");
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_PORT = 17372;
+export const AGENT_PROMPT = "你正在帮助用户操作 QCanvas 网页画布。需要改动画布时优先使用已配置的 qcanvas MCP 工具：先用 tapcanvas_flow_get 读取当前画布图（节点 nodes / 连线 edges / 选区 selectedNodeIds），再用 tapcanvas_flow_patch 提交改动。tapcanvas_flow_patch 支持 createNodes、createEdges、patchNodeData、appendNodeArrays、deleteNodeIds、deleteEdgeIds；节点 type 用 \"taskNode\" 或 \"groupNode\"，data 里放 kind（image/text/video/audio 等）与业务字段。所有写操作都会由浏览器二次确认后才真正应用，不要模拟鼠标点击，也不要要求用户手动复制 JSON。";
+function readConfigRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    return value;
+}
+function readString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function readPort(value) {
+    const numeric = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+    if (!Number.isInteger(numeric) || numeric < 1 || numeric > 65535)
+        return null;
+    return numeric;
+}
+function readOrigins(value) {
+    if (!Array.isArray(value))
+        return [];
+    return Array.from(new Set(value.map((item) => readString(item)).filter((item) => Boolean(item))));
+}
+function readActiveThreadIds(record) {
+    const out = {};
+    const raw = readConfigRecord(record.activeThreadIds);
+    for (const [agentId, threadId] of Object.entries(raw)) {
+        const id = readString(threadId);
+        if (id)
+            out[agentId] = id;
+    }
+    // 旧版单 agent 字段：迁移为 codex 的活跃线程。
+    const legacy = readString(record.activeThreadId);
+    if (legacy && !out.codex)
+        out.codex = legacy;
+    return out;
+}
+function readCanvases(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+        const record = readConfigRecord(entry);
+        const workspacePath = readString(record.workspacePath);
+        if (!workspacePath)
+            continue;
+        const activeThreadIds = readActiveThreadIds(record);
+        out[key] = { workspacePath, ...(Object.keys(activeThreadIds).length ? { activeThreadIds } : {}) };
+    }
+    return out;
+}
+function createConfig(raw) {
+    const host = readString(process.env.QCANVAS_LOCAL_AGENT_HOST) || readString(raw.host) || DEFAULT_HOST;
+    const port = readPort(process.env.QCANVAS_LOCAL_AGENT_PORT) || readPort(raw.port) || DEFAULT_PORT;
+    const token = readString(process.env.QCANVAS_LOCAL_AGENT_TOKEN) ||
+        readString(raw.token) ||
+        crypto.randomBytes(24).toString("base64url");
+    const claudeCommand = readString(process.env.QCANVAS_CLAUDE_COMMAND) || readString(raw.claudeCommand) || "claude";
+    return {
+        host,
+        port,
+        url: `http://${host}:${port}`,
+        token,
+        claudeCommand,
+        origins: readOrigins(raw.origins),
+        canvases: readCanvases(raw.canvases),
+    };
+}
+function resolveWorkspacePath(value) {
+    if (value === "~")
+        return os.homedir();
+    if (value.startsWith("~/"))
+        return path.join(os.homedir(), value.slice(2));
+    return path.resolve(value);
+}
+function safeSegment(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 120) || "default";
+}
+export function ensureCanvasWorkspace(config, canvasId) {
+    const id = safeSegment(canvasId || "default");
+    const current = config.canvases[id];
+    if (current?.workspacePath) {
+        const workspacePath = resolveWorkspacePath(current.workspacePath);
+        fs.mkdirSync(workspacePath, { recursive: true });
+        return { canvasId: id, workspacePath, activeThreadIds: { ...(current.activeThreadIds || {}) } };
+    }
+    const workspacePath = path.join(CONFIG_DIR, "codex-workspaces", id);
+    config.canvases[id] = { workspacePath };
+    fs.mkdirSync(workspacePath, { recursive: true });
+    saveConfig(config);
+    return { canvasId: id, workspacePath, activeThreadIds: {} };
+}
+export function setCanvasActiveThread(config, canvasId, agentId, threadId) {
+    const current = ensureCanvasWorkspace(config, canvasId);
+    const activeThreadIds = { ...current.activeThreadIds };
+    if (threadId) {
+        activeThreadIds[agentId] = threadId;
+    }
+    else {
+        delete activeThreadIds[agentId];
+    }
+    config.canvases[current.canvasId] = {
+        ...(config.canvases[current.canvasId] || { workspacePath: current.workspacePath }),
+        workspacePath: config.canvases[current.canvasId]?.workspacePath || current.workspacePath,
+        ...(Object.keys(activeThreadIds).length ? { activeThreadIds } : { activeThreadIds: undefined }),
+    };
+    saveConfig(config);
+    return { ...current, activeThreadIds };
+}
+export function saveConfig(config) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify({
+        host: config.host,
+        port: config.port,
+        url: config.url,
+        token: config.token,
+        claudeCommand: config.claudeCommand,
+        origins: config.origins,
+        canvases: config.canvases,
+    }, null, 2));
+}
+export function loadConfig(writeIfMissing) {
+    if (!fs.existsSync(CONFIG_FILE)) {
+        const next = createConfig({});
+        if (writeIfMissing)
+            saveConfig(next);
+        return next;
+    }
+    const rawText = fs.readFileSync(CONFIG_FILE, "utf8");
+    const parsed = JSON.parse(rawText);
+    const config = createConfig(readConfigRecord(parsed));
+    if (writeIfMissing)
+        saveConfig(config);
+    return config;
+}
+export function rememberOrigin(config, origin) {
+    if (!origin)
+        return config;
+    if (config.origins.includes(origin))
+        return config;
+    const next = { ...config, origins: [...config.origins, origin] };
+    saveConfig(next);
+    return next;
+}

package/dist/generation-flow-compiler.d.ts

@@ -0,0 +1,67 @@
+/**
+ * High-level "generation flow" intent -> low-level tapcanvas_flow_patch compiler.
+ *
+ * This mirrors apps/hono-api/src/modules/task/generation-flow-compiler.ts (the
+ * server-side canonical copy used by the main agents bridge). It is duplicated
+ * here, rather than imported, because this package is a standalone distributable
+ * CLI with no build-time dependency on hono-api (same convention already used by
+ * schemas.ts in this package). Keep the handle matrix and supported kinds below
+ * in sync with apps/hono-api/src/modules/ai/tool-schemas.ts.
+ */
+export type GenerationFlowIntent = {
+    kind: string;
+    prompt: string;
+    label?: string;
+    position?: {
+        x: number;
+        y: number;
+    };
+    referenceNodeIds?: string[];
+    referenceImageUrls?: string[];
+    model?: string;
+    aspect?: string;
+    groupId?: string;
+    nodeId?: string;
+};
+type TaskNodeData = Record<string, unknown> & {
+    kind: string;
+    prompt: string;
+};
+export type CompiledTaskNode = {
+    id: string;
+    type: "taskNode";
+    position: {
+        x: number;
+        y: number;
+    };
+    data: TaskNodeData;
+    selected: true;
+    parentId?: string;
+};
+export type CompiledEdge = {
+    id: string;
+    source: string;
+    target: string;
+    sourceHandle?: string;
+    targetHandle?: string;
+};
+export type GenerationFlowCompileResult = {
+    patch: {
+        createNodes: CompiledTaskNode[];
+        createEdges: CompiledEdge[];
+    };
+    primaryNodeId: string;
+    warnings: string[];
+};
+export declare class GenerationFlowCompileError extends Error {
+    code: string;
+    constructor(message: string, code: string);
+}
+type GraphLike = {
+    nodes?: unknown;
+} | null | undefined;
+type CompileOptions = {
+    generateId?: () => string;
+};
+export declare function compileGenerationFlow(intent: GenerationFlowIntent, graph: GraphLike, options?: CompileOptions): GenerationFlowCompileResult;
+export {};

package/dist/generation-flow-compiler.js

@@ -0,0 +1,207 @@
+/**
+ * High-level "generation flow" intent -> low-level tapcanvas_flow_patch compiler.
+ *
+ * This mirrors apps/hono-api/src/modules/task/generation-flow-compiler.ts (the
+ * server-side canonical copy used by the main agents bridge). It is duplicated
+ * here, rather than imported, because this package is a standalone distributable
+ * CLI with no build-time dependency on hono-api (same convention already used by
+ * schemas.ts in this package). Keep the handle matrix and supported kinds below
+ * in sync with apps/hono-api/src/modules/ai/tool-schemas.ts.
+ */
+import crypto from "node:crypto";
+const HANDLE_MATRIX = {
+    textLikeSources: ["out-text", "out-text-wide"],
+    imageLikeSources: ["out-image", "out-image-wide"],
+    videoLikeSources: ["out-video", "out-video-wide"],
+    imageLikeTargets: ["in-image", "in-image-wide"],
+    genericTargets: ["in-any", "in-any-wide"],
+};
+const SUPPORTED_TASK_NODE_KINDS = new Set([
+    "text",
+    "image",
+    "panorama360",
+    "video",
+    "novelDoc",
+    "scriptDoc",
+    "storyboardScript",
+    "scriptGenerator",
+    "cameraRef",
+    "workflowInput",
+    "workflowOutput",
+    "storyboardImage",
+    "imageFission",
+    "mosaic",
+    "composeVideo",
+    "audio",
+    "subtitle",
+]);
+const DEFAULT_NODE_WIDTH = 360;
+const HORIZONTAL_GAP = 80;
+const IMAGE_LIKE_KINDS = new Set(["image", "panorama360", "storyboardImage", "imageFission", "mosaic"]);
+const VIDEO_LIKE_KINDS = new Set(["video", "composeVideo"]);
+export class GenerationFlowCompileError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = "GenerationFlowCompileError";
+        this.code = code;
+    }
+}
+function toRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function nodeCategory(kind) {
+    if (IMAGE_LIKE_KINDS.has(kind))
+        return "image";
+    if (VIDEO_LIKE_KINDS.has(kind))
+        return "video";
+    return "text";
+}
+function sourceHandleForCategory(category) {
+    if (category === "image")
+        return HANDLE_MATRIX.imageLikeSources[0];
+    if (category === "video")
+        return HANDLE_MATRIX.videoLikeSources[0];
+    return HANDLE_MATRIX.textLikeSources[0];
+}
+function targetHandleForCategory(category) {
+    if (category === "image")
+        return HANDLE_MATRIX.imageLikeTargets[0];
+    return HANDLE_MATRIX.genericTargets[0];
+}
+function modelFieldForCategory(category) {
+    if (category === "image")
+        return "imageModel";
+    if (category === "video")
+        return "videoModel";
+    return "modelSelect";
+}
+function graphNodes(graph) {
+    const raw = toRecord(graph)?.nodes;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.map(toRecord).filter((node) => Boolean(node));
+}
+function findNodeById(nodes, id) {
+    return nodes.find((node) => readString(node.id) === id) ?? null;
+}
+function computeNextPosition(nodes) {
+    let maxRight = Number.NEGATIVE_INFINITY;
+    for (const node of nodes) {
+        if (readString(node.parentId))
+            continue;
+        const position = toRecord(node.position);
+        const x = Number(position?.x);
+        if (!Number.isFinite(x))
+            continue;
+        const data = toRecord(node.data);
+        const width = Number(data?.nodeWidth);
+        const right = x + (Number.isFinite(width) && width > 0 ? width : DEFAULT_NODE_WIDTH);
+        if (right > maxRight)
+            maxRight = right;
+    }
+    return Number.isFinite(maxRight) ? { x: maxRight + HORIZONTAL_GAP, y: 0 } : { x: 0, y: 0 };
+}
+function extractReferenceImageUrl(node) {
+    const data = toRecord(node.data);
+    if (!data)
+        return "";
+    const direct = readString(data.imageUrl);
+    if (direct)
+        return direct;
+    const results = Array.isArray(data.imageResults) ? data.imageResults : [];
+    const primaryIndex = Number(data.imagePrimaryIndex);
+    const ordered = Number.isInteger(primaryIndex) && primaryIndex >= 0 && primaryIndex < results.length
+        ? [results[primaryIndex], ...results]
+        : results;
+    for (const item of ordered) {
+        const url = readString(toRecord(item)?.url);
+        if (url)
+            return url;
+    }
+    return "";
+}
+export function compileGenerationFlow(intent, graph, options = {}) {
+    const generateId = options.generateId ?? (() => crypto.randomUUID());
+    const warnings = [];
+    const kind = readString(intent.kind);
+    if (!kind)
+        throw new GenerationFlowCompileError("kind is required", "kind_required");
+    if (!SUPPORTED_TASK_NODE_KINDS.has(kind)) {
+        throw new GenerationFlowCompileError(`Unsupported taskNode kind: ${kind}`, "unsupported_kind");
+    }
+    const prompt = readString(intent.prompt);
+    if (!prompt)
+        throw new GenerationFlowCompileError("prompt is required", "prompt_required");
+    const category = nodeCategory(kind);
+    const nodes = graphNodes(graph);
+    const nodeId = readString(intent.nodeId) || generateId();
+    const position = intent.position && Number.isFinite(intent.position.x) && Number.isFinite(intent.position.y)
+        ? { x: intent.position.x, y: intent.position.y }
+        : computeNextPosition(nodes);
+    const assetInputs = [];
+    const referenceImages = [];
+    const seenUrls = new Set();
+    const addReferenceImage = (url, name) => {
+        const trimmed = readString(url);
+        if (!trimmed || seenUrls.has(trimmed))
+            return;
+        seenUrls.add(trimmed);
+        assetInputs.push({ url: trimmed, role: "reference", ...(name ? { name } : {}) });
+        referenceImages.push(trimmed);
+    };
+    const targetHandle = targetHandleForCategory(category);
+    const edges = [];
+    const seenSources = new Set();
+    for (const rawRefId of intent.referenceNodeIds ?? []) {
+        const refId = readString(rawRefId);
+        if (!refId || refId === nodeId || seenSources.has(refId))
+            continue;
+        seenSources.add(refId);
+        const refNode = findNodeById(nodes, refId);
+        if (!refNode) {
+            warnings.push(`referenceNodeId not found in flow: ${refId}`);
+            continue;
+        }
+        const refKind = readString(toRecord(refNode.data)?.kind);
+        const sourceHandle = sourceHandleForCategory(nodeCategory(refKind));
+        edges.push({
+            id: `${refId}__${nodeId}`,
+            source: refId,
+            target: nodeId,
+            ...(sourceHandle ? { sourceHandle } : {}),
+            ...(targetHandle ? { targetHandle } : {}),
+        });
+        addReferenceImage(extractReferenceImageUrl(refNode), readString(toRecord(refNode.data)?.label) || undefined);
+    }
+    for (const url of intent.referenceImageUrls ?? [])
+        addReferenceImage(url);
+    const model = readString(intent.model);
+    const aspect = readString(intent.aspect);
+    const label = readString(intent.label) || undefined;
+    const data = {
+        kind,
+        prompt,
+        ...(label ? { label } : {}),
+        ...(model ? { [modelFieldForCategory(category)]: model } : {}),
+        ...(category === "image" && aspect ? { aspect } : {}),
+        ...(assetInputs.length ? { assetInputs } : {}),
+        ...(referenceImages.length ? { referenceImages } : {}),
+    };
+    const node = {
+        id: nodeId,
+        type: "taskNode",
+        position,
+        data,
+        selected: true,
+        ...(readString(intent.groupId) ? { parentId: readString(intent.groupId) } : {}),
+    };
+    return {
+        patch: { createNodes: [node], createEdges: edges },
+        primaryNodeId: nodeId,
+        warnings,
+    };
+}

package/dist/http-server.d.ts

@@ -0,0 +1 @@
+export declare function startHttpServer(): Promise<void>;