@xiaohhhh1/canvas-agent 0.4.42 → 0.4.44

package/dist/agent/codex-client.d.ts

@@ -1,3 +1,4 @@
+import { type JsonRecord } from "../utils/value.js";
 import type { CodexPlanUpdate, CodexRequestParams } from "./codex-protocol.js";
 import type { AgentEmit, AgentPermissionMode } from "./types.js";
 /** 封装 Codex app-server 的 JSON-RPC 通信与事件转换。 */
@@ -13,6 +14,7 @@ export declare class CodexAppClient {
     private pending;
     private activeTurns;
     private completedTurns;
+    private finalTextByTurn;
     private pendingDeltas;
     private plansByTurn;
     private approvalRequests;
@@ -41,9 +43,11 @@ export declare class CodexAppClient {
     /** 清理已归档线程的任务计划缓存。 */
     clearPlanUpdates(threadId: string): void;
     /** 启动一个 Codex turn 并等待完成通知。 */
-    startTurn(threadId: string, prompt: string, images: string[], permissionMode: AgentPermissionMode, onTurn?: (turnId: string) => void): Promise<void>;
+    startTurn(threadId: string, prompt: string, images: string[], permissionMode: AgentPermissionMode, onTurn?: (turnId: string) => void, outputSchema?: JsonRecord): Promise<string>;
     /** 中断当前正在运行的 Codex turn。 */
     interruptCurrentTurn(): Promise<boolean>;
+    /** 终止失去响应的 app-server，让后续队列可以在新进程继续。 */
+    terminate(message?: string): Promise<void>;
     /** 回复网页端已经确认的 Codex 权限请求。 */
     resolveApproval(requestId: string, decision: string): boolean;
     /** 发送 JSON-RPC 请求并保存待处理 Promise。 */

package/dist/agent/codex-client.js

@@ -21,6 +21,7 @@ export class CodexAppClient {
     pending = new Map();
     activeTurns = new Map();
     completedTurns = new Map();
+    finalTextByTurn = new Map();
     pendingDeltas = new Map();
     plansByTurn = new Map();
     approvalRequests = new Map();
@@ -92,9 +93,9 @@ export class CodexAppClient {
         });
     }
     /** 启动一个 Codex turn 并等待完成通知。 */
-    async startTurn(threadId, prompt, images, permissionMode, onTurn) {
+    async startTurn(threadId, prompt, images, permissionMode, onTurn, outputSchema) {
         this.currentThreadId = threadId;
-        const { turn } = await this.request("turn/start", { threadId, input: codexInput(prompt, images), ...turnSettings(permissionMode) });
+        const { turn } = await this.request("turn/start", { threadId, input: codexInput(prompt, images), ...turnSettings(permissionMode), ...(outputSchema ? { outputSchema } : {}) });
         const turnId = turn.id;
         if (!turnId)
             throw new Error("Codex app-server 没有返回 turn id");
@@ -105,11 +106,11 @@ export class CodexAppClient {
             this.completedTurns.delete(turnId);
             this.currentThreadId = "";
             this.currentTurnId = "";
-            if (completed)
-                throw completed;
-            return;
+            if (completed?.error)
+                throw completed.error;
+            return completed?.text || "";
         }
-        await new Promise((resolve, reject) => this.activeTurns.set(turnId, { resolve, reject }));
+        return await new Promise((resolve, reject) => this.activeTurns.set(turnId, { resolve, reject }));
     }
     /** 中断当前正在运行的 Codex turn。 */
     async interruptCurrentTurn() {
@@ -127,6 +128,17 @@ export class CodexAppClient {
             return false;
         }
     }
+    /** 终止失去响应的 app-server，让后续队列可以在新进程继续。 */
+    terminate(message = "Codex app-server was restarted") {
+        this.failAll(message);
+        if (this.child.exitCode !== null)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            const timer = setTimeout(resolve, 2000);
+            this.child.once("exit", () => { clearTimeout(timer); resolve(); });
+            this.child.kill();
+        });
+    }
     /** 回复网页端已经确认的 Codex 权限请求。 */
     resolveApproval(requestId, decision) {
         const request = this.approvalRequests.get(requestId);
@@ -235,6 +247,9 @@ export class CodexAppClient {
             const streamedText = this.textByItem.get(id);
             if (item?.type === "agent_message" && streamedText && !item.text)
                 item.text = streamedText;
+            const turnId = String(field(params, "turnId") || "");
+            if (turnId && item?.type === "agent_message" && item.text)
+                this.finalTextByTurn.set(turnId, String(item.text));
             if (id)
                 this.textByItem.delete(id);
         }
@@ -253,12 +268,14 @@ export class CodexAppClient {
             const turnId = turn.id;
             const pending = this.activeTurns.get(turnId);
             const error = turn.error;
+            const text = this.finalTextByTurn.get(turnId) || "";
+            this.finalTextByTurn.delete(turnId);
             if (pending) {
                 this.activeTurns.delete(turnId);
-                error ? pending.reject(new Error(error.message || "Codex turn failed")) : pending.resolve(event);
+                error ? pending.reject(new Error(error.message || "Codex turn failed")) : pending.resolve(text);
             }
             else if (turnId) {
-                this.completedTurns.set(turnId, error ? new Error(error.message || "Codex turn failed") : null);
+                this.completedTurns.set(turnId, { error: error ? new Error(error.message || "Codex turn failed") : null, text });
             }
             if (turnId === this.currentTurnId) {
                 this.currentThreadId = "";
@@ -328,6 +345,7 @@ export class CodexAppClient {
         this.activeTurns.clear();
         this.pendingDeltas.clear();
         this.textByItem.clear();
+        this.finalTextByTurn.clear();
         this.approvalRequests.clear();
         this.currentThreadId = "";
         this.currentTurnId = "";

package/dist/agent/codex-protocol.d.ts

@@ -114,6 +114,7 @@ type CodexRequestSpec = {
             } | {
                 type: "dangerFullAccess";
             };
+            outputSchema?: JsonRecord;
         };
         result: {
             turn: CodexTurn;

package/dist/agent/codex.d.ts

@@ -4,6 +4,7 @@ type CodexRunOptions = {
     cwd?: string;
     permissionMode?: AgentPermissionMode;
     appEmit?: AgentEmit;
+    outputSchema?: Record<string, unknown>;
     onStart?: () => void;
     onThread?: (threadId: string) => void;
     onTurn?: (turnId: string) => void;
@@ -11,6 +12,7 @@ type CodexRunOptions = {
 };
 export type CodexRunResult = {
     ok: true;
+    text: string;
 } | {
     ok: false;
     error: string;
@@ -20,6 +22,8 @@ export { summarizeCodexThread } from "./codex-history.js";
 export declare function runCodexTurn(prompt: string, emit: AgentEmit, attachments?: AgentAttachment[], options?: CodexRunOptions): Promise<CodexRunResult>;
 /** 中断当前线程正在执行的 Codex turn。 */
 export declare function interruptCodexTurn(threadId?: string): Promise<boolean>;
+/** 强制回收失去响应的 app-server；只用于有界超时恢复。 */
+export declare function restartCodexApp(message?: string): Promise<void>;
 /** 回复当前 app-server 的待处理权限请求。 */
 export declare function resolveCodexApproval(requestId: string, decision: string): Promise<boolean>;
 /** 创建新的 Codex 线程并记录当前线程 ID。 */

package/dist/agent/codex.js

@@ -24,6 +24,14 @@ export async function interruptCodexTurn(threadId) {
         return false;
     return await codexApp.interruptCurrentTurn();
 }
+/** 强制回收失去响应的 app-server；只用于有界超时恢复。 */
+export async function restartCodexApp(message = "Codex 执行超时，正在重启本机脚本引擎") {
+    const app = codexApp;
+    codexApp = null;
+    codexAppStart = null;
+    codexThreadId = "";
+    await app?.terminate(message);
+}
 /** 回复当前 app-server 的待处理权限请求。 */
 export async function resolveCodexApproval(requestId, decision) {
     return Boolean(codexApp?.resolveApproval(requestId, decision));
@@ -103,7 +111,8 @@ async function runCodexTurnNow(prompt, emit, attachments, options) {
         options.onThread?.(threadId);
         unmaterializedThreadIds.delete(threadId);
         try {
-            await app.startTurn(threadId, prompt, files, options.permissionMode || "request", options.onTurn);
+            const text = await app.startTurn(threadId, prompt, files, options.permissionMode || "request", options.onTurn, options.outputSchema);
+            return { ok: true, text };
         }
         catch (error) {
             if (!isRecoverableThreadError(error))
@@ -113,9 +122,9 @@ async function runCodexTurnNow(prompt, emit, attachments, options) {
             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);
+            const text = await app.startTurn(threadId, prompt, files, options.permissionMode || "request", options.onTurn, options.outputSchema);
+            return { ok: true, text };
         }
-        return { ok: true };
     }
     catch (error) {
         logger.error("Codex turn failed", error);

package/dist/index.js

@@ -7,6 +7,10 @@ if (process.argv[2] === "mcp") {
     await ensureHttpServer();
     await startMcpServer();
 }
+else if (process.argv[2] === "upgrade") {
+    await ensureHttpServer();
+    console.log("Canvas Agent upgraded and running in the background.");
+}
 else if (process.argv[2] === "watch")
     startHttpSupervisor();
 else

package/dist/server/http.js

@@ -59,7 +59,7 @@ export function startHttpServer() {
             return void res.json({});
         next();
     });
-    app.get("/health", (_req, res) => res.json({ ...session.health(), version: VERSION, relayReady: relayStatus.ready, relayLastReadyAt: relayStatus.lastReadyAt, relayLastDisconnectAt: relayStatus.lastDisconnectAt }));
+    app.get("/health", (_req, res) => res.json({ ...session.health(), version: VERSION, workflow: workflows.health(), relayReady: relayStatus.ready, relayLastReadyAt: relayStatus.lastReadyAt, relayLastDisconnectAt: relayStatus.lastDisconnectAt }));
     app.get("/config", (_req, res) => res.json({ ok: true, url: config.url, hasToken: true }));
     app.use((req, res, next) => {
         if (validToken(req, requestUrl(req, config), config.token))

package/dist/workflow/manager.d.ts

@@ -1,7 +1,22 @@
 import type { AgentEmit } from "../agent/types.js";
 import { type CanvasAgentConfig } from "../config.js";
+export declare const FLOW_C_CODEX_TURN_TIMEOUT_MS: number;
 type ScriptStatus = "queued" | "running" | "complete" | "error" | "expired";
 type DownloadStatus = "waiting" | "running" | "complete" | "error" | "expired";
+type ScriptRecord = {
+    id: string;
+    apiBase: string;
+    accessToken: string;
+    status: ScriptStatus;
+    requestedCount: number;
+    receivedOrdinals: number[];
+    threadId?: string;
+    message?: string;
+    expiresAt?: string;
+    attempts: number;
+    priorityAt?: string;
+    updatedAt: string;
+};
 type ScriptTask = {
     id: string;
     workflow: "flow-c";
@@ -86,6 +101,11 @@ export declare class WorkflowManager {
             updatedAt: string;
         }[];
     };
+    health(): {
+        activeScriptHandoffIds: string[];
+        queuedScripts: number;
+        blockedScripts: number;
+    };
     startDownloadDirectorySelection(): {
         id: string;
         status: "selecting" | "selected" | "cancelled" | "error";
@@ -174,4 +194,5 @@ export declare class WorkflowManager {
     private downloadRecord;
     private save;
 }
+export declare function compareScriptQueueRecords(left: Pick<ScriptRecord, "priorityAt" | "updatedAt">, right: Pick<ScriptRecord, "priorityAt" | "updatedAt">): number;
 export {};

package/dist/workflow/manager.js

@@ -5,12 +5,14 @@ import { mkdir, open, rename, stat, unlink } from "node:fs/promises";
 import path from "node:path";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { runCodexTurn, startCodexThread } from "../agent/codex.js";
+import { restartCodexApp, runCodexTurn, startCodexThread } from "../agent/codex.js";
 import { CONFIG_DIR, ensureSiteWorkspace } from "../config.js";
 import { logger } from "../utils/logger.js";
 import { windowsPowerShellExecutable } from "../utils/windows.js";
 import { FLOW_C_SCRIPT_CHUNK_MAX, FLOW_C_SCRIPT_CHUNK_SIZES } from "./constants.js";
+import { flowCScriptOutputSchema, parseFlowCScriptOutput } from "./script-output.js";
 const STATE_FILE = path.join(CONFIG_DIR, "workflow-state.json");
+export const FLOW_C_CODEX_TURN_TIMEOUT_MS = 8 * 60 * 1000;
 /** 本机持久化的 Flow C 控制器：脚本交给本机 Codex，视频直接落盘。 */
 export class WorkflowManager {
     config;
@@ -45,6 +47,7 @@ export class WorkflowManager {
             threadId: previous?.threadId,
             expiresAt: String(input.expiresAt || previous?.expiresAt || "") || undefined,
             attempts: previous?.attempts || 0,
+            priorityAt: now(),
             message: previous?.status === "complete" ? previous.message : "已进入本机 Codex 队列",
             updatedAt: now(),
         };
@@ -56,6 +59,7 @@ export class WorkflowManager {
         const id = workflowId(idValue, "脚本交接 ID");
         const record = this.scriptRecord(id);
         record.status = "queued";
+        record.priorityAt = now();
         record.message = "正在重新连接本机 Codex";
         record.updatedAt = now();
         this.save();
@@ -108,6 +112,14 @@ export class WorkflowManager {
             subscriptions: Object.values(this.state.downloads).map(publicDownload),
         };
     }
+    health() {
+        const records = Object.values(this.state.scripts);
+        return {
+            activeScriptHandoffIds: [...this.runningScripts],
+            queuedScripts: records.filter((record) => record.status === "queued" || record.status === "running").length,
+            blockedScripts: records.filter((record) => record.status === "error").length,
+        };
+    }
     startDownloadDirectorySelection() {
         if (this.directorySelection?.status === "selecting")
             return this.directorySelection;
@@ -176,7 +188,7 @@ export class WorkflowManager {
             while (true) {
                 const next = Object.values(this.state.scripts)
                     .filter((record) => (record.status === "queued" || record.status === "running") && !this.runningScripts.has(record.id))
-                    .sort((left, right) => left.updatedAt.localeCompare(right.updatedAt))[0];
+                    .sort(compareScriptQueueRecords)[0];
                 if (!next)
                     break;
                 await this.runScript(next.id);
@@ -206,6 +218,7 @@ export class WorkflowManager {
         this.runningScripts.add(id);
         const record = this.scriptRecord(id);
         try {
+            delete record.priorityAt;
             record.status = "running";
             record.message = "正在读取完整产品清单";
             record.updatedAt = now();
@@ -235,14 +248,24 @@ export class WorkflowManager {
                     record.message = `本机 Codex 正在写第 ${missing[0]}–${missing.at(-1)} 条（总计 ${task.requested_count} 条）`;
                     record.updatedAt = now();
                     this.save();
-                    const result = await runCodexTurn(scriptChunkPrompt(id, task, missing), this.emit, [], { threadId: record.threadId, cwd: workspace.workspacePath, permissionMode: "full", onThread: (threadId) => { record.threadId = threadId; this.save(); } });
+                    const result = await runCodexScriptWithTimeout(scriptChunkPrompt(id, task, missing), this.emit, { threadId: record.threadId, cwd: workspace.workspacePath, permissionMode: "full", outputSchema: flowCScriptOutputSchema(Number(task.duration_seconds || 10), missing.length), onThread: (threadId) => { record.threadId = threadId; this.save(); } });
                     await this.scriptTask(id);
                     progressed = record.receivedOrdinals.length > before;
+                    if (!progressed && result.ok && result.text) {
+                        try {
+                            await this.submitScriptChunk(id, parseFlowCScriptOutput(result.text, missing));
+                            await this.scriptTask(id);
+                            progressed = record.receivedOrdinals.length > before;
+                        }
+                        catch (error) {
+                            lastError = error instanceof Error ? `结构化脚本未通过本机校验：${error.message}` : "结构化脚本未通过本机校验";
+                        }
+                    }
                     if (progressed)
                         break;
                     // Keep provider/client details out of the browser-facing state. The
                     // underlying Codex runner already records the technical error locally.
-                    lastError = result.ok ? "Codex 未调用回传工具" : "Codex 本轮执行失败";
+                    lastError ||= result.ok ? "Codex 未返回可用的结构化脚本" : "Codex 本轮执行失败";
                     if (attemptIndex < FLOW_C_SCRIPT_CHUNK_SIZES.length - 1) {
                         const nextSize = FLOW_C_SCRIPT_CHUNK_SIZES[attemptIndex + 1];
                         record.message = `第 ${lastRange} 条未成功回传，正在换新会话并缩小为每段 ${nextSize} 条重试`;
@@ -406,6 +429,28 @@ export class WorkflowManager {
     }
     save() { saveState(this.state); }
 }
+export function compareScriptQueueRecords(left, right) {
+    if (left.priorityAt || right.priorityAt)
+        return String(right.priorityAt || "").localeCompare(String(left.priorityAt || ""));
+    return left.updatedAt.localeCompare(right.updatedAt);
+}
+async function runCodexScriptWithTimeout(prompt, emit, options) {
+    let timer;
+    const turn = runCodexTurn(prompt, emit, [], options);
+    const timeout = new Promise((resolve) => { timer = setTimeout(() => resolve("timeout"), FLOW_C_CODEX_TURN_TIMEOUT_MS); });
+    try {
+        const result = await Promise.race([turn, timeout]);
+        if (result !== "timeout")
+            return result;
+        await restartCodexApp("Flow C 脚本回合超过 8 分钟，已自动终止并换新会话");
+        await turn;
+        return { ok: false, error: "Flow C 脚本回合超过 8 分钟，已自动终止并换新会话" };
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 class ExpiredCapabilityError extends Error {
 }
 function scriptChunkPrompt(id, task, ordinals) {
@@ -415,13 +460,17 @@ function scriptChunkPrompt(id, task, ordinals) {
 每条回传同时填写 script=masterScript、masterScript 和 segments。segments[0].continuityMode 必须是 reset；同人物同场景延续时后续段用 continue，明确换人物或换场景才用 reset。continue 段必须复述并固定人物年龄、外貌、服装、场景陈设、光线、机位基调和商品当前状态。
 每份 masterScript 和每个 segment 都要写同一套详细音色身份：性别、年龄段、音高、音质、语速、口音、停连和说话习惯；情绪随剧情逐段变化，但音色身份不变。仍按短视频快节奏口播，不因时长增加而拖慢。`;
     return `你正在后台处理“抖音小辉跨境工具”Flow C 脚本交接 ${id}。
-必须使用 MCP 工具 flow_c_get_script_task 读取完整任务，再只创作 ordinal ${ordinals[0]} 到 ${ordinals.at(-1)}（精确列表：${ordinals.join(", ")}）。
+完整中心任务已经附在本提示词末尾。只创作 ordinal ${ordinals[0]} 到 ${ordinals.at(-1)}（精确列表：${ordinals.join(", ")}）。
 本段 productIndex 必须严格按此映射填写：${scriptProductAssignments(task.product_quantities, ordinals)}。不得凭产品名称猜测或把相邻产品编号混用。
 脚本质量绝不能因批量而降低：每条都必须独立构思、完整、真实合规，严格遵守任务 instructions、产品图片顺序和 productIndex；使用目标市场 ${task.market} 的自然本地语言与偏快但清晰的短视频节奏。${longVideoRules}
 每一个 ordinal 都必须从头到尾创作一份完整、独立的原生带货脚本，画面和口播必须在同一份脚本中一起独立构思。先让它成为一个当地真人在具体生活情境里自然发现、吐槽、试用或验证商品的短内容，再完成带货；禁止写成品牌广告片、棚拍宣传片、电视购物、逐条念卖点或全程完美对镜讲解。独立脚本天然包含独立口播：不得把任何一份口播当作整批公共模板，不得复用完整台词，也不得只换人物、场景或少数词后保留近似口播。音色身份可以为同一人物保持一致，但每条的 Hook、人物行动、证明表达和 CTA 都必须重新写。
 用户没有指定带货方向时，不得随意只用一种泛化形式；必须按任务 instructions 中“已批准的创意方向”逐条做产品适配轮换。轮换必须按每个产品自己的序号连续计算，不能因 30/15/10 条分段、换会话或跨产品边界而从第一个方向重新开始；让同一产品在重复某一方向前优先覆盖其他适配方向。
 工厂风格 A/B 是默认轮换中的演绎带货布景，不是商品来源声明；不得因用户未提供真实工厂资料而跳过，也绝不能写成我们的真实工厂、真实生产流程、真实产地、工厂直销、厂家出货或仓库现货。
-写完后必须调用 flow_c_submit_script_chunk 一次回传这 ${ordinals.length} 条，handoffId=${id}。不要创建付费批次，不要调用供应商模型，不要在聊天输出大段 JSON。工具返回成功后仅简短结束。`;
+只返回符合当前结构化输出契约的 jobs；每条必须包含 ordinal、productIndex、sellingFormId 和 script，长视频还必须包含 masterScript 与完整 segments。无需调用 MCP，Agent 会在本机校验后自动回传。不要创建付费批次，不要调用供应商模型。
+
+【中心任务完整 instructions】
+${task.instructions}
+【中心任务 instructions 结束】`;
 }
 function scriptProductAssignments(productQuantities, ordinals) {
     const assignments = [];

package/dist/workflow/script-output.d.ts

@@ -0,0 +1,5 @@
+type JsonSchema = Record<string, unknown>;
+/** Codex app-server 的结构化脚本返回契约；回传由 Agent 完成，不依赖模型调用 MCP。 */
+export declare function flowCScriptOutputSchema(durationSeconds: 10 | 20 | 30, count: number): JsonSchema;
+export declare function parseFlowCScriptOutput(value: string, expectedOrdinals: number[]): unknown[];
+export {};

package/dist/workflow/script-output.js

@@ -0,0 +1,52 @@
+const text = { type: "string", minLength: 1 };
+const continuityFields = ["character", "wardrobe", "location", "lighting", "productState", "unfinishedAction", "nextGoal"];
+function object(properties, required = Object.keys(properties)) {
+    return { type: "object", properties, required, additionalProperties: false };
+}
+function continuitySchema(frameField) {
+    return object(Object.fromEntries([...continuityFields, frameField].map((field) => [field, text])));
+}
+function segmentSchema() {
+    return object({
+        continuityMode: { type: "string", enum: ["reset", "continue"] },
+        continuity: continuitySchema("previousEndingFrame"),
+        endingState: continuitySchema("endingFrame"),
+        shots: {
+            type: "array",
+            minItems: 1,
+            maxItems: 8,
+            items: object({
+                startSeconds: { type: "number", minimum: 0, maximum: 10 },
+                endSeconds: { type: "number", minimum: 0, maximum: 10 },
+                visual: text,
+                voiceover: text,
+                onScreenText: text,
+                evidence: text,
+            }),
+        },
+    });
+}
+/** Codex app-server 的结构化脚本返回契约；回传由 Agent 完成，不依赖模型调用 MCP。 */
+export function flowCScriptOutputSchema(durationSeconds, count) {
+    const properties = {
+        ordinal: { type: "integer", minimum: 1 },
+        productIndex: { type: "integer", minimum: 0 },
+        sellingFormId: text,
+        script: { type: "string", minLength: 40 },
+    };
+    if (durationSeconds !== 10) {
+        properties.masterScript = { type: "string", minLength: 40 };
+        properties.segments = { type: "array", minItems: durationSeconds / 10, maxItems: durationSeconds / 10, items: segmentSchema() };
+    }
+    return object({ jobs: { type: "array", minItems: count, maxItems: count, items: object(properties) } });
+}
+export function parseFlowCScriptOutput(value, expectedOrdinals) {
+    const source = String(value || "").trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
+    const parsed = JSON.parse(source);
+    if (!Array.isArray(parsed.jobs) || parsed.jobs.length !== expectedOrdinals.length)
+        throw new Error("Codex 返回的脚本数量不正确");
+    const actual = parsed.jobs.map((job) => Number(job?.ordinal));
+    if (actual.some((ordinal, index) => ordinal !== expectedOrdinals[index]))
+        throw new Error("Codex 返回的 ordinal 与当前分段不一致");
+    return parsed.jobs;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiaohhhh1/canvas-agent",
-  "version": "0.4.42",
+  "version": "0.4.44",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",