@xiaohhhh1/canvas-agent 0.2.2 → 0.3.0

package/dist/{agents.d.ts → agent/codex.d.ts}

@@ -1,30 +1,36 @@
-import type { AgentAttachment, AgentEmit } from "./types.js";
-type Json = Record<string, unknown>;
+import type { AgentAttachment, AgentEmit, AgentPermissionMode } from "./types.js";
 type CodexRunOptions = {
     threadId?: string;
     cwd?: string;
+    permissionMode?: AgentPermissionMode;
     appEmit?: AgentEmit;
     onStart?: () => void;
     onThread?: (threadId: string) => void;
     onTurn?: (turnId: string) => void;
     onFinish?: () => void;
 };
-type AgentHistoryMessage = {
-    id: string;
-    role: "user" | "assistant" | "tool" | "error";
-    title?: string;
-    text: string;
-    detail?: unknown;
-    streamId?: string;
-};
-export declare function withAgentPrompt(prompt: string): string;
+export { summarizeCodexThread } from "./codex-history.js";
+/** 将 Codex turn 加入串行队列并等待执行完成。 */
 export declare function runCodexTurn(prompt: string, emit: AgentEmit, attachments?: AgentAttachment[], options?: CodexRunOptions): Promise<void>;
-export declare function interruptCodexTurn(threadId?: string): boolean;
-export declare function startCodexThread(emit: AgentEmit, cwd?: string): Promise<Json>;
-export declare function resumeCodexThread(emit: AgentEmit, threadId: string, cwd?: string): Promise<{
-    thread: Json;
-    messages: AgentHistoryMessage[];
+/** 中断当前线程正在执行的 Codex turn。 */
+export declare function interruptCodexTurn(threadId?: string): Promise<boolean>;
+/** 回复当前 app-server 的待处理权限请求。 */
+export declare function resolveCodexApproval(requestId: string, decision: string): Promise<boolean>;
+/** 创建新的 Codex 线程并记录当前线程 ID。 */
+export declare function startCodexThread(emit: AgentEmit, cwd?: string, permissionMode?: AgentPermissionMode): Promise<import("./codex-protocol.js").CodexThread>;
+/** 恢复指定 Codex 线程并返回聊天历史。 */
+export declare function resumeCodexThread(emit: AgentEmit, threadId: string, cwd?: string, permissionMode?: AgentPermissionMode): Promise<{
+    thread: import("./codex-protocol.js").CodexThread;
+    messages: {
+        id: string;
+        role: "user" | "assistant" | "tool" | "error";
+        title?: string;
+        text: string;
+        detail?: unknown;
+        streamId?: string;
+    }[];
 }>;
+/** 查询当前工作空间中的 Codex 线程。 */
 export declare function listCodexThreads(emit: AgentEmit, options: {
     cwd: string;
     searchTerm?: string;
@@ -45,6 +51,7 @@ export declare function listCodexThreads(emit: AgentEmit, options: {
     nextCursor: {} | null;
     backwardsCursor: {} | null;
 }>;
+/** 读取指定 Codex 线程及其聊天历史。 */
 export declare function readCodexThread(emit: AgentEmit, threadId: string, cwd?: string): Promise<{
     thread: {
         id: string;
@@ -58,22 +65,18 @@ export declare function readCodexThread(emit: AgentEmit, threadId: string, cwd?:
         createdAt: number;
         updatedAt: number;
     };
-    messages: AgentHistoryMessage[];
+    messages: {
+        id: string;
+        role: "user" | "assistant" | "tool" | "error";
+        title?: string;
+        text: string;
+        detail?: unknown;
+        streamId?: string;
+    }[];
 }>;
+/** 确认指定 Codex 线程属于当前工作空间。 */
 export declare function verifyCodexThreadWorkspace(emit: AgentEmit, threadId: string, cwd: string): Promise<void>;
+/** 归档指定 Codex 线程。 */
 export declare function archiveCodexThread(emit: AgentEmit, threadId: string, cwd?: string): Promise<void>;
-export declare function runClaudeTurn(prompt: string, emit: AgentEmit): void;
+/** 判断线程异常是否允许自动新建线程后重试。 */
 export declare function isRecoverableThreadError(error: unknown): boolean;
-export declare function summarizeCodexThread(thread: unknown): {
-    id: string;
-    sessionId: string;
-    preview: string;
-    name: string | null;
-    cwd: string;
-    status: string;
-    source: unknown;
-    threadSource: unknown;
-    createdAt: number;
-    updatedAt: number;
-};
-export {};

package/dist/agent/codex.js

@@ -0,0 +1,210 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { logger } from "../utils/logger.js";
+import { errorMessage, field } from "../utils/value.js";
+import { CodexAppClient } from "./codex-client.js";
+import { summarizeCodexThread, threadMessages } from "./codex-history.js";
+let codexQueue = Promise.resolve();
+let codexApp = null;
+let codexAppStart = null;
+let codexThreadId = "";
+const unmaterializedThreadIds = new Set();
+export { summarizeCodexThread } from "./codex-history.js";
+/** 将 Codex turn 加入串行队列并等待执行完成。 */
+export async function runCodexTurn(prompt, emit, attachments = [], options = {}) {
+    if (!prompt.trim())
+        return;
+    codexQueue = codexQueue.catch(() => undefined).then(() => runCodexTurnNow(prompt, emit, attachments, options));
+    await codexQueue;
+}
+/** 中断当前线程正在执行的 Codex turn。 */
+export async function interruptCodexTurn(threadId) {
+    if (!codexApp || (threadId && threadId !== codexThreadId))
+        return false;
+    return await codexApp.interruptCurrentTurn();
+}
+/** 回复当前 app-server 的待处理权限请求。 */
+export async function resolveCodexApproval(requestId, decision) {
+    return Boolean(codexApp?.resolveApproval(requestId, decision));
+}
+/** 创建新的 Codex 线程并记录当前线程 ID。 */
+export async function startCodexThread(emit, cwd, permissionMode = "request") {
+    const app = await getCodexApp(emit);
+    const thread = await app.startThread(cwd, permissionMode);
+    codexThreadId = String(field(thread, "id") || "");
+    if (codexThreadId)
+        unmaterializedThreadIds.add(codexThreadId);
+    return thread;
+}
+/** 恢复指定 Codex 线程并返回聊天历史。 */
+export async function resumeCodexThread(emit, threadId, cwd, permissionMode = "request") {
+    const app = await getCodexApp(emit);
+    await loadCodexThread(emit, threadId, cwd, false);
+    const thread = await app.resumeThread(threadId, cwd, permissionMode);
+    assertThreadWorkspace(thread, cwd);
+    codexThreadId = String(field(thread, "id") || threadId);
+    const historyThread = await loadCodexThread(emit, codexThreadId, cwd, true);
+    return { thread, messages: threadMessages(historyThread, app.planUpdates(threadId)) };
+}
+/** 查询当前工作空间中的 Codex 线程。 */
+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 };
+}
+/** 读取指定 Codex 线程及其聊天历史。 */
+export async function readCodexThread(emit, threadId, cwd) {
+    const app = await getCodexApp(emit);
+    let thread;
+    try {
+        thread = await loadCodexThread(emit, threadId, cwd, !unmaterializedThreadIds.has(threadId));
+    }
+    catch (error) {
+        if (!/not materialized yet.*includeTurns/i.test(errorMessage(error)))
+            throw error;
+        unmaterializedThreadIds.add(threadId);
+        thread = await loadCodexThread(emit, threadId, cwd, false);
+    }
+    return { thread: summarizeCodexThread(thread), messages: threadMessages(thread, app.planUpdates(threadId)) };
+}
+/** 确认指定 Codex 线程属于当前工作空间。 */
+export async function verifyCodexThreadWorkspace(emit, threadId, cwd) {
+    await loadCodexThread(emit, threadId, cwd, false);
+}
+/** 归档指定 Codex 线程。 */
+export async function archiveCodexThread(emit, threadId, cwd) {
+    const app = await getCodexApp(emit);
+    await loadCodexThread(emit, threadId, cwd, false);
+    await app.archiveThread(threadId);
+    app.clearPlanUpdates(threadId);
+    unmaterializedThreadIds.delete(threadId);
+}
+/** 判断线程异常是否允许自动新建线程后重试。 */
+export function isRecoverableThreadError(error) {
+    return /thread not loaded|no rollout found/i.test(errorMessage(error));
+}
+/** 执行一次 Codex turn，并负责附件临时文件和线程恢复。 */
+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);
+        unmaterializedThreadIds.delete(threadId);
+        try {
+            await app.startTurn(threadId, prompt, files, options.permissionMode || "request", 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);
+            unmaterializedThreadIds.delete(threadId);
+            await app.startTurn(threadId, prompt, files, options.permissionMode || "request", options.onTurn);
+        }
+    }
+    catch (error) {
+        logger.error("Codex turn failed", error);
+        emit("agent_error", { message: errorMessage(error) });
+    }
+    finally {
+        options.onFinish?.();
+        await Promise.all(files.map((file) => fs.unlink(file).catch(() => undefined)));
+    }
+}
+/** 恢复请求线程或创建新的 Codex 线程。 */
+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, options.permissionMode || "request");
+            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, options.permissionMode || "request");
+        codexThreadId = String(field(thread, "id") || "");
+        if (codexThreadId)
+            unmaterializedThreadIds.add(codexThreadId);
+    }
+    return codexThreadId;
+}
+/** 从 app-server 读取线程并校验工作空间。 */
+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;
+}
+/** 获取已启动的 Codex app-server 客户端。 */
+async function getCodexApp(emit) {
+    if (codexApp)
+        return codexApp;
+    codexAppStart ||= CodexAppClient.start(emit, () => {
+        codexApp = null;
+        codexThreadId = "";
+    });
+    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));
+}
+/** 将图片附件写入临时文件供 Codex 读取。 */
+async function writeAttachmentFiles(attachments) {
+    return await Promise.all(attachments.filter((item) => item.dataUrl?.startsWith("data:image/")).map(writeAttachmentFile));
+}
+/** 将单个 Data URL 图片附件写入临时文件。 */
+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;
+}
+/** 根据图片 MIME 类型返回临时文件扩展名。 */
+function imageExt(type = "") {
+    if (type.includes("png"))
+        return "png";
+    if (type.includes("webp"))
+        return "webp";
+    return "jpg";
+}

package/dist/agent/types.d.ts

@@ -0,0 +1,14 @@
+/** 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;
+};
+/** 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,161 @@
+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,
+            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") : [];
+    const tokens = [`@[node:${textId}]`, ...referenceNodeIds.map((id) => `@[node:${id}]`)];
+    return [
+        textNodeOp({ id: textId, text: prompt, title: String(input.title || "提示词") }, x, y),
+        configNodeOp(configId, { ...input, prompt: tokens.join("\n") }, x + 420, y),
+        { 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 !== ""));
+}

package/dist/{schemas.d.ts → canvas/schemas.d.ts}

@@ -1,4 +1,5 @@
 import { z } from "zod";
+/** Canvas Agent 对外提供的工具名称。 */
 export declare const toolNames: readonly ["site_navigate", "canvas_list_projects", "canvas_get_state", "canvas_get_selection", "canvas_export_snapshot", "canvas_export_media", "canvas_apply_ops", "canvas_create_node", "canvas_create_attachment_nodes", "canvas_create_text_node", "canvas_create_text_nodes", "canvas_create_config_node", "canvas_create_image_prompt_flow", "canvas_create_generation_flow", "canvas_generate_text", "canvas_generate_image", "canvas_generate_video", "canvas_generate_audio", "canvas_update_node", "canvas_update_node_text", "canvas_move_nodes", "canvas_resize_node", "canvas_delete_nodes", "canvas_connect_nodes", "canvas_select_nodes", "canvas_set_viewport", "canvas_run_generation", "generation_get_status", "workbench_image_get_config", "workbench_image_generate", "workbench_video_get_config", "workbench_video_generate", "prompts_search", "assets_list", "assets_add"];
 export type ToolName = (typeof toolNames)[number];
 export declare const canvasOpSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
@@ -545,18 +546,18 @@ export declare const toolInputSchemas: {
         height: z.ZodOptional<z.ZodNumber>;
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, "strip", z.ZodTypeAny, {
-        nodeType: "image" | "text" | "config" | "video" | "audio";
+        nodeType: "text" | "image" | "config" | "video" | "audio";
+        title?: string | undefined;
         x?: number | undefined;
         y?: number | undefined;
-        title?: string | undefined;
         width?: number | undefined;
         height?: number | undefined;
         metadata?: Record<string, unknown> | undefined;
     }, {
-        nodeType: "image" | "text" | "config" | "video" | "audio";
+        nodeType: "text" | "image" | "config" | "video" | "audio";
+        title?: string | undefined;
         x?: number | undefined;
         y?: number | undefined;
-        title?: string | undefined;
         width?: number | undefined;
         height?: number | undefined;
         metadata?: Record<string, unknown> | undefined;
@@ -589,16 +590,16 @@ export declare const toolInputSchemas: {
         height: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         text?: string | undefined;
+        title?: string | undefined;
         x?: number | undefined;
         y?: number | undefined;
-        title?: string | undefined;
         width?: number | undefined;
         height?: number | undefined;
     }, {
         text?: string | undefined;
+        title?: string | undefined;
         x?: number | undefined;
         y?: number | undefined;
-        title?: string | undefined;
         width?: number | undefined;
         height?: number | undefined;
     }>;
@@ -612,16 +613,16 @@ export declare const toolInputSchemas: {
             height: z.ZodOptional<z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             text: string;
+            title?: string | undefined;
             x?: number | undefined;
             y?: number | undefined;
-            title?: string | undefined;
             width?: number | undefined;
             height?: number | undefined;
         }, {
             text: string;
+            title?: string | undefined;
             x?: number | undefined;
             y?: number | undefined;
-            title?: string | undefined;
             width?: number | undefined;
             height?: number | undefined;
         }>, "many">;
@@ -632,9 +633,9 @@ export declare const toolInputSchemas: {
     }, "strip", z.ZodTypeAny, {
         items: {
             text: string;
+            title?: string | undefined;
             x?: number | undefined;
             y?: number | undefined;
-            title?: string | undefined;
             width?: number | undefined;
             height?: number | undefined;
         }[];
@@ -645,9 +646,9 @@ export declare const toolInputSchemas: {
     }, {
         items: {
             text: string;
+            title?: string | undefined;
             x?: number | undefined;
             y?: number | undefined;
-            title?: string | undefined;
             width?: number | undefined;
             height?: number | undefined;
         }[];
@@ -853,11 +854,11 @@ export declare const toolInputSchemas: {
         prompt: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         nodeId: string;
-        mode?: "image" | "text" | "video" | "audio" | undefined;
+        mode?: "text" | "image" | "video" | "audio" | undefined;
         prompt?: string | undefined;
     }, {
         nodeId: string;
-        mode?: "image" | "text" | "video" | "audio" | undefined;
+        mode?: "text" | "image" | "video" | "audio" | undefined;
         prompt?: string | undefined;
     }>;
     generation_get_status: z.ZodObject<{
@@ -866,15 +867,15 @@ export declare const toolInputSchemas: {
         nodeIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         limit: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
-        limit?: number | undefined;
         nodeIds?: string[] | undefined;
         scope?: "image" | "video" | "all" | "canvas" | undefined;
         taskId?: string | undefined;
-    }, {
         limit?: number | undefined;
+    }, {
         nodeIds?: string[] | undefined;
         scope?: "image" | "video" | "all" | "canvas" | undefined;
         taskId?: string | undefined;
+        limit?: number | undefined;
     }>;
     workbench_image_get_config: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
     workbench_image_generate: z.ZodObject<{
@@ -886,17 +887,17 @@ export declare const toolInputSchemas: {
         run: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         prompt: string;
+        count?: number | undefined;
         model?: string | undefined;
         size?: string | undefined;
         quality?: string | undefined;
-        count?: number | undefined;
         run?: boolean | undefined;
     }, {
         prompt: string;
+        count?: number | undefined;
         model?: string | undefined;
         size?: string | undefined;
         quality?: string | undefined;
-        count?: number | undefined;
         run?: boolean | undefined;
     }>;
     workbench_video_get_config: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
@@ -953,15 +954,15 @@ export declare const toolInputSchemas: {
         page: z.ZodOptional<z.ZodNumber>;
         pageSize: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
+        kind?: "text" | "image" | "video" | "all" | undefined;
         keyword?: string | undefined;
         page?: number | undefined;
         pageSize?: number | undefined;
-        kind?: "image" | "text" | "video" | "all" | undefined;
     }, {
+        kind?: "text" | "image" | "video" | "all" | undefined;
         keyword?: string | undefined;
         page?: number | undefined;
         pageSize?: number | undefined;
-        kind?: "image" | "text" | "video" | "all" | undefined;
     }>;
     assets_add: z.ZodObject<{
         kind: z.ZodEnum<["text", "image"]>;
@@ -973,7 +974,7 @@ export declare const toolInputSchemas: {
         note: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         title: string;
-        kind: "image" | "text";
+        kind: "text" | "image";
         source?: string | undefined;
         content?: string | undefined;
         tags?: string[] | undefined;
@@ -981,7 +982,7 @@ export declare const toolInputSchemas: {
         note?: string | undefined;
     }, {
         title: string;
-        kind: "image" | "text";
+        kind: "text" | "image";
         source?: string | undefined;
         content?: string | undefined;
         tags?: string[] | undefined;