@kobinflow/canvas-agent 0.6.0

package/dist/agent/message-metadata.js

@@ -0,0 +1,378 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { CONFIG_DIR } from "../config.js";
+const STORAGE_VERSION = 1;
+const MAX_PREVIEW_LENGTH = 500_000;
+const MAX_TEXT_LENGTH = 20_000;
+const MANIFEST_FILE = "manifest.json";
+const MESSAGE_ASSET_PREFIX = "agent-asset:";
+const MESSAGE_METADATA_DIRECTORY = path.join(CONFIG_DIR, "message-metadata");
+export class MessageMetadataStore {
+    directory;
+    queue = Promise.resolve();
+    ready;
+    constructor(directory = MESSAGE_METADATA_DIRECTORY) {
+        this.directory = directory;
+    }
+    recordPending(clientMessageId, value) {
+        return this.run(async () => {
+            const metadata = normalizeMetadata(value, false);
+            if (!clientMessageId || !metadata)
+                return undefined;
+            await this.ensureReady();
+            const storedMetadata = await persistMetadataPreviews(this.directory, clientMessageId, metadata);
+            const record = { version: STORAGE_VERSION, clientMessageId, createdAt: Date.now(), metadata: storedMetadata };
+            await writeJson(this.pendingFile(clientMessageId), record);
+            return structuredClone(storedMetadata);
+        });
+    }
+    bindThread(clientMessageId, threadId) {
+        return this.run(async () => {
+            if (!clientMessageId || !threadId)
+                return;
+            await this.ensureReady();
+            const pendingFile = this.pendingFile(clientMessageId);
+            const targetFile = this.threadFile(threadId, clientMessageId);
+            const record = await readRecord(targetFile) || await readRecord(pendingFile);
+            if (!record)
+                return;
+            await writeJson(targetFile, { ...record, threadId, turnId: record.threadId === threadId ? record.turnId : undefined });
+            await removeFile(pendingFile);
+        });
+    }
+    bindTurn(clientMessageId, threadId, turnId) {
+        return this.run(async () => {
+            if (!clientMessageId || !threadId || !turnId)
+                return;
+            await this.ensureReady();
+            const pendingFile = this.pendingFile(clientMessageId);
+            const targetFile = this.threadFile(threadId, clientMessageId);
+            const record = await readRecord(targetFile) || await readRecord(pendingFile);
+            if (!record)
+                return;
+            await writeJson(targetFile, { ...record, threadId, turnId });
+            await removeFile(pendingFile);
+        });
+    }
+    mergeThread(threadId, messages) {
+        return this.run(async () => {
+            await this.ensureReady();
+            const records = (await readRecords(this.threadDirectory(threadId))).filter((item) => item.threadId === threadId && item.turnId);
+            const byTurnId = new Map(records.map((item) => [item.turnId, item]));
+            return messages.map((message) => {
+                if (message.role !== "user" || message.threadId !== threadId)
+                    return message;
+                const record = byTurnId.get(message.turnId);
+                return record ? { ...message, clientMessageId: record.clientMessageId, ...structuredClone(record.metadata) } : message;
+            });
+        });
+    }
+    remove(clientMessageId, threadId = "") {
+        return this.run(async () => {
+            if (!clientMessageId)
+                return;
+            await this.ensureReady();
+            await Promise.all([
+                removeFile(this.pendingFile(clientMessageId)),
+                ...(threadId ? [removeFile(this.threadFile(threadId, clientMessageId))] : []),
+                fs.rm(this.assetDirectory(clientMessageId), { recursive: true, force: true }),
+            ]);
+        });
+    }
+    removeThread(threadId) {
+        return this.run(async () => {
+            if (!threadId)
+                return;
+            await this.ensureReady();
+            const records = await readRecords(this.threadDirectory(threadId));
+            await Promise.all([
+                fs.rm(this.threadDirectory(threadId), { recursive: true, force: true }),
+                ...records.map((record) => fs.rm(this.assetDirectory(record.clientMessageId), { recursive: true, force: true })),
+            ]);
+        });
+    }
+    readAsset(messageKey, assetFile) {
+        return this.run(async () => {
+            await this.ensureReady();
+            if (!/^[a-f0-9]{64}$/.test(messageKey) || !/^[a-f0-9]{64}\.(?:gif|jpe?g|png|webp)$/.test(assetFile))
+                return undefined;
+            try {
+                return { data: await fs.readFile(path.join(this.directory, "assets", messageKey, assetFile)), contentType: assetContentType(assetFile) };
+            }
+            catch (error) {
+                if (isMissing(error))
+                    return undefined;
+                throw error;
+            }
+        });
+    }
+    run(task) {
+        const result = this.queue.then(task, task);
+        this.queue = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    ensureReady() {
+        this.ready ||= this.initialize();
+        return this.ready;
+    }
+    async initialize() {
+        const manifestFile = path.join(this.directory, MANIFEST_FILE);
+        try {
+            const manifest = await readJson(manifestFile);
+            if (manifest.version !== STORAGE_VERSION)
+                throw unsupportedVersion(manifest.version);
+            return;
+        }
+        catch (error) {
+            if (!isMissing(error))
+                throw error;
+        }
+        if (await exists(this.directory))
+            throw new Error(`Message metadata store is missing ${MANIFEST_FILE}; refusing to overwrite it.`);
+        await createStorage(this.directory);
+    }
+    pendingFile(clientMessageId) {
+        return path.join(this.directory, "pending", `${storageKey(clientMessageId)}.json`);
+    }
+    threadDirectory(threadId) {
+        return path.join(this.directory, "threads", storageKey(threadId));
+    }
+    threadFile(threadId, clientMessageId) {
+        return path.join(this.threadDirectory(threadId), `${storageKey(clientMessageId)}.json`);
+    }
+    assetDirectory(clientMessageId) {
+        return path.join(this.directory, "assets", storageKey(clientMessageId));
+    }
+}
+export const messageMetadataStore = new MessageMetadataStore();
+async function createStorage(directory) {
+    const temporaryDirectory = `${directory}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        await fs.mkdir(path.join(temporaryDirectory, "pending"), { recursive: true });
+        await fs.mkdir(path.join(temporaryDirectory, "threads"), { recursive: true });
+        await fs.mkdir(path.join(temporaryDirectory, "assets"), { recursive: true });
+        await writeJson(path.join(temporaryDirectory, MANIFEST_FILE), { version: STORAGE_VERSION });
+        await fs.rename(temporaryDirectory, directory);
+    }
+    finally {
+        await fs.rm(temporaryDirectory, { recursive: true, force: true });
+    }
+}
+async function readRecords(directory) {
+    let files;
+    try {
+        files = (await fs.readdir(directory, { withFileTypes: true })).filter((item) => item.isFile() && item.name.endsWith(".json")).map((item) => path.join(directory, item.name));
+    }
+    catch (error) {
+        if (isMissing(error))
+            return [];
+        throw error;
+    }
+    return (await Promise.all(files.map(readRecord))).filter((item) => Boolean(item));
+}
+async function readRecord(file) {
+    try {
+        const value = await readJson(file);
+        if (value.version !== STORAGE_VERSION)
+            throw unsupportedVersion(value.version);
+        const clientMessageId = text(value.clientMessageId, 200);
+        const metadata = normalizeMetadata(value.metadata, true);
+        if (!clientMessageId || !metadata)
+            throw new Error(`Message metadata record is invalid: ${file}`);
+        const threadId = text(value.threadId, 200);
+        const turnId = text(value.turnId, 200);
+        return { version: STORAGE_VERSION, clientMessageId, createdAt: Number(value.createdAt) || 0, metadata, ...(threadId ? { threadId } : {}), ...(turnId ? { turnId } : {}) };
+    }
+    catch (error) {
+        if (isMissing(error))
+            return undefined;
+        throw error;
+    }
+}
+function normalizeMetadata(value, allowAsset) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Message metadata must be an object.");
+    const source = value;
+    const attachments = normalizeList(source.attachments, 6, (item) => normalizeAttachment(item, allowAsset), "attachments");
+    const canvasReferences = normalizeList(source.canvasReferences, 50, (item) => normalizeCanvasReference(item, allowAsset), "canvas references");
+    const skill = normalizeSkill(source.skill);
+    if (source.skill !== undefined && !skill)
+        throw new Error("Message skill metadata is invalid.");
+    if (!attachments.length && !canvasReferences.length && !skill)
+        return undefined;
+    return { ...(attachments.length ? { attachments } : {}), ...(canvasReferences.length ? { canvasReferences } : {}), ...(skill ? { skill } : {}) };
+}
+function normalizeList(value, limit, normalize, label) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw new Error(`Message ${label} metadata must be an array.`);
+    if (value.length > limit)
+        throw new Error(`Message ${label} metadata exceeds the limit of ${limit}.`);
+    const normalized = value.map(normalize).filter((item) => Boolean(item));
+    if (normalized.length !== value.length)
+        throw new Error(`Message ${label} metadata is invalid.`);
+    return normalized;
+}
+function normalizeAttachment(value, allowAsset) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const item = value;
+    const id = text(item.id, 200);
+    const name = text(item.name, 500);
+    const url = imagePreview(item.url, allowAsset);
+    if (!id || !name || !url)
+        return undefined;
+    return { id, name, url, ...numberFields(item) };
+}
+function normalizeCanvasReference(value, allowAsset) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const item = value;
+    const nodeId = text(item.nodeId, 200);
+    const label = text(item.label, 200);
+    const title = text(item.title, 500);
+    const kind = String(item.kind || "");
+    if (!nodeId || !label || !title || !["image", "video", "audio", "text"].includes(kind))
+        return undefined;
+    const previewUrl = kind === "image" ? imagePreview(item.previewUrl, allowAsset) : remotePreview(item.previewUrl);
+    const referenceText = text(item.text, MAX_TEXT_LENGTH);
+    return { nodeId, label, title, kind: kind, ...(previewUrl ? { previewUrl } : {}), ...(referenceText ? { text: referenceText } : {}) };
+}
+function normalizeSkill(value) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const item = value;
+    const name = text(item.name, 200);
+    const skillPath = text(item.path, 2000);
+    const displayName = text(item.displayName, 200);
+    return name && skillPath ? { name, path: skillPath, ...(displayName ? { displayName } : {}) } : undefined;
+}
+function numberFields(item) {
+    const fields = {};
+    const type = text(item.type, 200);
+    if (type)
+        fields.type = type;
+    for (const key of ["size", "width", "height"]) {
+        const value = Number(item[key]);
+        if (Number.isFinite(value) && value >= 0)
+            fields[key] = value;
+    }
+    return fields;
+}
+function imagePreview(value, allowAsset = false) {
+    if (typeof value !== "string")
+        return "";
+    const url = value.trim();
+    if (allowAsset && new RegExp(`^${MESSAGE_ASSET_PREFIX}[a-f0-9]{64}/[a-f0-9]{64}\\.(?:gif|jpe?g|png|webp)$`).test(url))
+        return url;
+    if (/^https?:\/\//i.test(url))
+        return url.length <= 5000 ? url : "";
+    return url.length <= MAX_PREVIEW_LENGTH && /^data:image\/[a-z0-9.+-]+;base64,/i.test(url) ? url : "";
+}
+function remotePreview(value) {
+    if (typeof value !== "string")
+        return "";
+    const url = value.trim();
+    return url.length <= 5000 && /^https?:\/\//i.test(url) ? url : "";
+}
+function text(value, limit) {
+    return typeof value === "string" ? value.trim().slice(0, limit) : "";
+}
+function storageKey(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}
+async function persistMetadataPreviews(directory, clientMessageId, metadata) {
+    const attachments = await Promise.all((metadata.attachments || []).map(async (item) => ({ ...item, url: await persistImagePreview(directory, clientMessageId, `attachment:${item.id}`, item.url) })));
+    const canvasReferences = await Promise.all((metadata.canvasReferences || []).map(async (item) => ({
+        ...item,
+        ...(item.kind === "image" && item.previewUrl ? { previewUrl: await persistImagePreview(directory, clientMessageId, `reference:${item.nodeId}`, item.previewUrl) } : {}),
+    })));
+    return {
+        ...(attachments.length ? { attachments } : {}),
+        ...(canvasReferences.length ? { canvasReferences } : {}),
+        ...(metadata.skill ? { skill: metadata.skill } : {}),
+    };
+}
+async function persistImagePreview(directory, clientMessageId, key, value) {
+    const match = value.match(/^data:(image\/[a-z0-9.+-]+);base64,(.+)$/i);
+    if (!match)
+        return value;
+    const extension = imageExtension(match[1]);
+    if (!extension)
+        throw new Error(`Unsupported message preview type: ${match[1]}`);
+    const messageKey = storageKey(clientMessageId);
+    const assetFile = `${storageKey(key)}.${extension}`;
+    await writeFile(path.join(directory, "assets", messageKey, assetFile), Buffer.from(match[2], "base64"));
+    return `${MESSAGE_ASSET_PREFIX}${messageKey}/${assetFile}`;
+}
+function imageExtension(contentType) {
+    const type = contentType.toLowerCase();
+    if (type === "image/jpeg" || type === "image/jpg")
+        return "jpg";
+    if (type === "image/png")
+        return "png";
+    if (type === "image/webp")
+        return "webp";
+    if (type === "image/gif")
+        return "gif";
+    return "";
+}
+function assetContentType(file) {
+    const extension = path.extname(file).slice(1).toLowerCase();
+    if (extension === "jpg" || extension === "jpeg")
+        return "image/jpeg";
+    return `image/${extension}`;
+}
+async function readJson(file) {
+    try {
+        return JSON.parse(await fs.readFile(file, "utf8"));
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            throw new Error(`Message metadata JSON is invalid: ${file}`);
+        throw error;
+    }
+}
+async function writeJson(file, value) {
+    await writeFile(file, JSON.stringify(value));
+}
+async function writeFile(file, value) {
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const temporaryFile = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    try {
+        await fs.writeFile(temporaryFile, value);
+        await fs.rename(temporaryFile, file);
+    }
+    finally {
+        await removeFile(temporaryFile);
+    }
+}
+async function removeFile(file) {
+    await fs.unlink(file).catch((error) => {
+        if (error.code !== "ENOENT")
+            throw error;
+    });
+}
+async function exists(file) {
+    try {
+        await fs.access(file);
+        return true;
+    }
+    catch (error) {
+        if (isMissing(error))
+            return false;
+        throw error;
+    }
+}
+function unsupportedVersion(version) {
+    return new Error(`Unsupported message metadata version: ${String(version ?? "missing")}. Refusing to overwrite existing data.`);
+}
+function isMissing(error) {
+    return error?.code === "ENOENT";
+}

package/dist/agent/types.d.ts

@@ -0,0 +1,45 @@
+/** Agent 向网页广播事件的函数类型。 */
+export type AgentEmit = (type: string, payload: unknown) => void;
+/** 用户随当前 Agent 消息上传的附件。 */
+export type AgentAttachment = {
+    id?: string;
+    name?: string;
+    type?: string;
+    size?: number;
+    width?: number;
+    height?: number;
+    dataUrl?: string;
+};
+/** 用户消息在历史记录中展示所需的附件信息。 */
+export type AgentAttachmentDisplay = {
+    id: string;
+    name: string;
+    type?: string;
+    size?: number;
+    width?: number;
+    height?: number;
+    url: string;
+};
+/** 用户消息引用的画布素材。 */
+export type AgentCanvasReference = {
+    nodeId: string;
+    label: string;
+    title: string;
+    kind: "image" | "video" | "audio" | "text";
+    previewUrl?: string;
+    text?: string;
+};
+/** 用户消息调用的 Codex Skill。 */
+export type AgentSkillReference = {
+    name: string;
+    path: string;
+    displayName?: string;
+};
+/** 独立于 Codex 原生线程历史保存的用户消息展示元数据。 */
+export type AgentMessageMetadata = {
+    attachments?: AgentAttachmentDisplay[];
+    canvasReferences?: AgentCanvasReference[];
+    skill?: AgentSkillReference;
+};
+/** Codex 文件、命令和网络权限模式。 */
+export type AgentPermissionMode = "request" | "automatic" | "full";

package/dist/agent/types.js

@@ -0,0 +1 @@
+export {};

package/dist/canvas/operations.d.ts

@@ -0,0 +1,13 @@
+import type { ToolName } from "./schemas.js";
+import type { CanvasSnapshot } from "./types.js";
+export type CanvasToolRequest = {
+    name: "canvas_apply_ops";
+    input: Record<string, unknown>;
+};
+/** 将上层画布工具调用转换为前端可执行的批量操作。 */
+export declare function buildCanvasToolRequest(name: ToolName, input: Record<string, unknown>, state: CanvasSnapshot | null): CanvasToolRequest;
+/** 按最大边限制计算附件图片节点尺寸，并保持原始比例。 */
+export declare function fitAttachmentNodeSize(width: number, height: number): {
+    width: number;
+    height: number;
+};

package/dist/canvas/operations.js

@@ -0,0 +1,167 @@
+import crypto from "node:crypto";
+import { nextCanvasX } from "./tools.js";
+/** 将上层画布工具调用转换为前端可执行的批量操作。 */
+export function buildCanvasToolRequest(name, input, state) {
+    if (name === "canvas_apply_ops")
+        return { name, input };
+    if (name === "canvas_create_node") {
+        const data = input;
+        return applyOps([{ type: "add_node", nodeType: data.nodeType, title: data.title, position: { x: data.x ?? nextCanvasX(state), y: data.y ?? 0 }, width: data.width, height: data.height, metadata: data.metadata }]);
+    }
+    if (name === "canvas_create_text_node") {
+        const data = input;
+        return applyOps([textNodeOp(data, data.x ?? nextCanvasX(state), data.y ?? 0)]);
+    }
+    if (name === "canvas_create_text_nodes") {
+        const data = input;
+        const x = Number(data.x ?? nextCanvasX(state));
+        const y = Number(data.y ?? 0);
+        const gap = Number(data.gap ?? 40);
+        return applyOps(data.items.map((item, index) => textNodeOp(item, item.x ?? (data.direction === "row" ? x + index * (340 + gap) : x), item.y ?? (data.direction === "row" ? y : y + index * (240 + gap)))));
+    }
+    if (name === "canvas_create_image_prompt_flow")
+        return applyOps(generationFlowOps({ ...input, mode: "image" }, state));
+    if (name === "canvas_create_config_node") {
+        const x = Number(input.x ?? nextCanvasX(state));
+        const y = Number(input.y ?? 0);
+        const configId = `config-${crypto.randomUUID()}`;
+        const mode = generationMode(input.mode);
+        const prompt = String(input.prompt || "");
+        return applyOps([configNodeOp(configId, input, x, y), ...(input.autoRun ? [runGenerationOp(configId, mode, prompt)] : [])]);
+    }
+    if (name === "canvas_create_generation_flow")
+        return applyOps(generationFlowOps(input, state));
+    if (name === "canvas_generate_text" || name === "canvas_generate_image" || name === "canvas_generate_video" || name === "canvas_generate_audio") {
+        return applyOps(generationFlowOps({ ...input, mode: name.replace("canvas_generate_", ""), autoRun: true }, state));
+    }
+    if (name === "canvas_update_node") {
+        const data = input;
+        return applyOps([{ type: "update_node", id: data.id, patch: data.patch, metadata: data.metadata }]);
+    }
+    if (name === "canvas_update_node_text") {
+        const data = input;
+        return applyOps([{ type: "update_node", id: data.id, patch: { ...(data.title ? { title: data.title } : {}) }, metadata: { content: data.text, status: "success" } }]);
+    }
+    if (name === "canvas_move_nodes") {
+        const data = input;
+        return applyOps(data.items.map((item) => {
+            const current = findNode(state, item.id);
+            return { type: "update_node", id: item.id, patch: { position: { x: item.x ?? ((current?.position.x || 0) + (item.dx || 0)), y: item.y ?? ((current?.position.y || 0) + (item.dy || 0)) } } };
+        }));
+    }
+    if (name === "canvas_resize_node") {
+        const data = input;
+        return applyOps([{ type: "update_node", id: data.id, patch: { width: data.width, height: data.height }, metadata: data.freeResize === undefined ? undefined : { freeResize: data.freeResize } }]);
+    }
+    if (name === "canvas_delete_nodes")
+        return applyOps([{ type: "delete_node", ids: input.ids }]);
+    if (name === "canvas_connect_nodes") {
+        const data = input;
+        return applyOps(data.connections.map((connection) => ({ type: "connect_nodes", ...connection })));
+    }
+    if (name === "canvas_select_nodes")
+        return applyOps([{ type: "select_nodes", ids: input.ids }]);
+    if (name === "canvas_set_viewport")
+        return applyOps([{ type: "set_viewport", viewport: input.viewport }]);
+    if (name === "canvas_run_generation") {
+        const data = input;
+        return applyOps([runGenerationOp(data.nodeId, generationMode(data.mode), data.prompt)]);
+    }
+    throw new Error(`未知工具：${name}`);
+}
+/** 按最大边限制计算附件图片节点尺寸，并保持原始比例。 */
+export function fitAttachmentNodeSize(width, height) {
+    const scale = Math.min(1, 640 / width, 640 / height);
+    return { width: width * scale, height: height * scale };
+}
+/** 创建统一的批量画布操作请求。 */
+function applyOps(ops) {
+    return { name: "canvas_apply_ops", input: { ops } };
+}
+/** 创建文本节点操作。 */
+function textNodeOp(input, x, y) {
+    return { type: "add_node", id: input.id, nodeType: "text", title: input.title, position: { x, y }, width: input.width, height: input.height, metadata: { content: input.text || "", status: "success", fontSize: 14 } };
+}
+/** 创建生成配置节点操作。 */
+function configNodeOp(id, input, x, y) {
+    const mode = generationMode(input.mode);
+    const prompt = String(input.prompt || "");
+    return {
+        type: "add_node",
+        id,
+        nodeType: "config",
+        title: String(input.title || generationTitle(mode)),
+        position: { x, y },
+        width: typeof input.width === "number" ? input.width : undefined,
+        height: typeof input.height === "number" ? input.height : undefined,
+        metadata: cleanRecord({
+            generationMode: mode,
+            composerContent: prompt,
+            prompt,
+            status: "idle",
+            model: input.model,
+            size: input.size,
+            quality: input.quality,
+            count: input.count,
+            seconds: input.seconds,
+            vquality: input.vquality,
+            generateAudio: input.generateAudio,
+            watermark: input.watermark,
+            videoMode: input.videoMode,
+            audioVoice: input.audioVoice,
+            audioFormat: input.audioFormat,
+            audioSpeed: input.audioSpeed,
+            audioInstructions: input.audioInstructions,
+        }),
+    };
+}
+/** 创建包含提示词、配置节点和引用连线的生成流程。 */
+function generationFlowOps(input, state) {
+    const mode = generationMode(input.mode);
+    const prompt = String(input.prompt || "");
+    const x = Number(input.x ?? nextCanvasX(state));
+    const y = Number(input.y ?? 0);
+    const textId = `text-${crypto.randomUUID()}`;
+    const configId = `config-${crypto.randomUUID()}`;
+    const referenceNodeIds = Array.isArray(input.referenceNodeIds) ? input.referenceNodeIds.filter((id) => typeof id === "string") : [];
+    // When the prompt only @-mentions nodes already passed as references, reuse them instead of minting a duplicate text node.
+    const mentionedIds = [...prompt.matchAll(/@\[node:([\w-]+)\]/g)].map((match) => match[1]);
+    const reuseReferences = referenceNodeIds.length > 0 && mentionedIds.length > 0
+        && mentionedIds.every((id) => referenceNodeIds.includes(id))
+        && prompt.replace(/@\[node:[\w-]+\]/g, "").trim() === "";
+    const tokens = reuseReferences ? referenceNodeIds.map((id) => `@[node:${id}]`) : [`@[node:${textId}]`, ...referenceNodeIds.map((id) => `@[node:${id}]`)];
+    return [
+        ...(reuseReferences ? [] : [textNodeOp({ id: textId, text: prompt, title: String(input.title || "提示词") }, x, y)]),
+        configNodeOp(configId, { ...input, prompt: tokens.join("\n") }, x + 420, y),
+        ...(reuseReferences ? [] : [{ type: "connect_nodes", fromNodeId: textId, toNodeId: configId }]),
+        ...referenceNodeIds.map((fromNodeId) => ({ type: "connect_nodes", fromNodeId, toNodeId: configId })),
+        { type: "select_nodes", ids: [configId] },
+        ...(input.autoRun ? [runGenerationOp(configId, mode, tokens.join("\n"))] : []),
+    ];
+}
+/** 创建触发节点生成的画布操作。 */
+function runGenerationOp(nodeId, mode, prompt) {
+    return { type: "run_generation", nodeId, mode, prompt };
+}
+/** 将未知生成模式归一为画布支持的模式。 */
+function generationMode(value) {
+    return value === "text" || value === "video" || value === "audio" ? value : "image";
+}
+/** 获取生成模式对应的默认节点标题。 */
+function generationTitle(mode) {
+    if (mode === "text")
+        return "文本生成";
+    if (mode === "video")
+        return "视频生成";
+    if (mode === "audio")
+        return "音频生成";
+    return "图片生成";
+}
+/** 按节点 ID 查找当前画布节点。 */
+function findNode(state, id) {
+    return (state?.nodes || []).find((node) => node.id === id);
+}
+/** 移除对象中未设置的生成参数。 */
+function cleanRecord(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined && item !== ""));
+}