@xiaohhhh1/canvas-agent 0.4.2 → 0.4.4

package/dist/agent/codex.d.ts

@@ -9,9 +9,15 @@ type CodexRunOptions = {
     onTurn?: (turnId: string) => void;
     onFinish?: () => void;
 };
+export type CodexRunResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: 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 runCodexTurn(prompt: string, emit: AgentEmit, attachments?: AgentAttachment[], options?: CodexRunOptions): Promise<CodexRunResult>;
 /** 中断当前线程正在执行的 Codex turn。 */
 export declare function interruptCodexTurn(threadId?: string): Promise<boolean>;
 /** 回复当前 app-server 的待处理权限请求。 */

package/dist/agent/codex.js

@@ -14,9 +14,9 @@ export { summarizeCodexThread } from "./codex-history.js";
 /** 将 Codex turn 加入串行队列并等待执行完成。 */
 export async function runCodexTurn(prompt, emit, attachments = [], options = {}) {
     if (!prompt.trim())
-        return;
+        return { ok: false, error: "Codex prompt is empty" };
     codexQueue = codexQueue.catch(() => undefined).then(() => runCodexTurnNow(prompt, emit, attachments, options));
-    await codexQueue;
+    return await codexQueue;
 }
 /** 中断当前线程正在执行的 Codex turn。 */
 export async function interruptCodexTurn(threadId) {
@@ -115,10 +115,13 @@ async function runCodexTurnNow(prompt, emit, attachments, options) {
             unmaterializedThreadIds.delete(threadId);
             await app.startTurn(threadId, prompt, files, options.permissionMode || "request", options.onTurn);
         }
+        return { ok: true };
     }
     catch (error) {
         logger.error("Codex turn failed", error);
-        emit("agent_error", { message: errorMessage(error) });
+        const message = errorMessage(error);
+        emit("agent_error", { message });
+        return { ok: false, error: message };
     }
     finally {
         options.onFinish?.();

package/dist/server/mcp.js

@@ -3,6 +3,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 import { toolDescriptions, toolInputSchemas, toolNames } from "../canvas/schemas.js";
 import { AGENT_PROMPT, loadConfig, VERSION } from "../config.js";
+import { FLOW_C_SCRIPT_CHUNK_MAX } from "../workflow/constants.js";
 /** 启动通过标准输入输出通信的 MCP 服务。 */
 export async function startMcpServer() {
     const config = loadConfig(true);
@@ -22,7 +23,7 @@ function registerWorkflowTools(server, config) {
         inputSchema: { handoffId: z.string().uuid().describe("网站创建的脚本交接 ID") },
     }, async ({ handoffId }) => workflowTool(config, `/agent/workflow/script-handoffs/${encodeURIComponent(handoffId)}/task`, { method: "GET" }));
     server.registerTool("flow_c_submit_script_chunk", {
-        description: "把本段独立完成的 Flow C 高质量脚本持久化回传给网站。每次 1–30 条；成功后再创作下一段。",
+        description: `把本段独立完成的 Flow C 高质量脚本持久化回传给网站。每次 1–${FLOW_C_SCRIPT_CHUNK_MAX} 条；成功后再创作下一段。`,
         inputSchema: {
             handoffId: z.string().uuid().describe("脚本交接 ID"),
             jobs: z.array(z.object({
@@ -30,7 +31,7 @@ function registerWorkflowTools(server, config) {
                 productIndex: z.number().int().nonnegative(),
                 sellingFormId: z.string().min(1).max(100),
                 script: z.string().min(40).max(20_000),
-            })).min(1).max(25),
+            })).min(1).max(FLOW_C_SCRIPT_CHUNK_MAX),
         },
     }, async ({ handoffId, jobs }) => workflowTool(config, `/agent/workflow/script-handoffs/${encodeURIComponent(handoffId)}/draft-chunks`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ jobs }) }));
 }

package/dist/workflow/constants.d.ts

@@ -0,0 +1,3 @@
+/** Flow C 脚本分段的唯一上限和自动降级顺序，MCP 与调度器必须共用。 */
+export declare const FLOW_C_SCRIPT_CHUNK_SIZES: readonly [30, 15, 10];
+export declare const FLOW_C_SCRIPT_CHUNK_MAX: 30;

package/dist/workflow/constants.js

@@ -0,0 +1,3 @@
+/** Flow C 脚本分段的唯一上限和自动降级顺序，MCP 与调度器必须共用。 */
+export const FLOW_C_SCRIPT_CHUNK_SIZES = [30, 15, 10];
+export const FLOW_C_SCRIPT_CHUNK_MAX = FLOW_C_SCRIPT_CHUNK_SIZES[0];

package/dist/workflow/manager.d.ts

@@ -9,6 +9,8 @@ type ScriptTask = {
     requested_count: number;
     product_quantities: number[];
     instructions: string;
+    status: "pending" | "writing" | "ready";
+    received_ordinals: number[];
     expires_at: string;
 };
 /** 本机持久化的 Flow C 控制器：脚本交给本机 Codex，视频直接落盘。 */
@@ -64,6 +66,7 @@ export declare class WorkflowManager {
     submitScriptChunk(idValue: unknown, jobsValue: unknown): Promise<{
         accepted: number;
         received: number;
+        receivedOrdinals?: number[];
         requestedCount: number;
         status: string;
     } & {

package/dist/workflow/manager.js

@@ -9,8 +9,8 @@ import { 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";
 const STATE_FILE = path.join(CONFIG_DIR, "workflow-state.json");
-const SCRIPT_CHUNK_SIZE = 30;
 const DOWNLOAD_POLL_MS = 10_000;
 /** 本机持久化的 Flow C 控制器：脚本交给本机 Codex，视频直接落盘。 */
 export class WorkflowManager {
@@ -76,6 +76,7 @@ export class WorkflowManager {
         const data = await commerceJson(`${record.apiBase}/workflow-script-handoffs/${encodeURIComponent(record.id)}/task`, record.accessToken, "x-workflow-handoff-token");
         const task = data.handoff;
         record.requestedCount = Number(task.requested_count || 0);
+        record.receivedOrdinals = Array.isArray(task.received_ordinals) ? task.received_ordinals.map(Number).filter(Number.isInteger).sort((left, right) => left - right) : [];
         record.expiresAt = task.expires_at;
         record.updatedAt = now();
         this.save();
@@ -84,15 +85,19 @@ export class WorkflowManager {
     /** MCP 分段回传脚本，中心接口再次执行数量、产品索引和脚本完整性校验。 */
     async submitScriptChunk(idValue, jobsValue) {
         const record = this.scriptRecord(workflowId(idValue, "脚本交接 ID"));
-        if (!Array.isArray(jobsValue) || !jobsValue.length || jobsValue.length > SCRIPT_CHUNK_SIZE)
-            throw new Error(`每段必须包含 1–${SCRIPT_CHUNK_SIZE} 条脚本`);
+        if (!Array.isArray(jobsValue) || !jobsValue.length || jobsValue.length > FLOW_C_SCRIPT_CHUNK_MAX)
+            throw new Error(`每段必须包含 1–${FLOW_C_SCRIPT_CHUNK_MAX} 条脚本`);
         const jobs = jobsValue;
         const data = await commerceJson(`${record.apiBase}/workflow-script-handoffs/${encodeURIComponent(record.id)}/draft-chunks`, record.accessToken, "x-workflow-handoff-token", { method: "POST", body: JSON.stringify({ jobs }) });
-        const accepted = new Set(record.receivedOrdinals);
-        for (const job of jobs)
-            if (Number.isInteger(Number(job?.ordinal)))
-                accepted.add(Number(job.ordinal));
-        record.receivedOrdinals = [...accepted].sort((a, b) => a - b);
+        if (Array.isArray(data.receivedOrdinals))
+            record.receivedOrdinals = data.receivedOrdinals.map(Number).filter(Number.isInteger).sort((left, right) => left - right);
+        else {
+            const accepted = new Set(record.receivedOrdinals);
+            for (const job of jobs)
+                if (Number.isInteger(Number(job?.ordinal)))
+                    accepted.add(Number(job.ordinal));
+            record.receivedOrdinals = [...accepted].sort((a, b) => a - b);
+        }
         record.requestedCount = Number(data.requestedCount || record.requestedCount);
         record.status = data.status === "ready" ? "complete" : "running";
         record.message = data.status === "ready" ? `全部 ${record.requestedCount} 条高质量脚本已回传` : `已回传 ${data.received}/${data.requestedCount} 条脚本`;
@@ -212,28 +217,47 @@ export class WorkflowManager {
                 this.save();
             }
             while (record.receivedOrdinals.length < task.requested_count) {
-                const missing = missingOrdinals(task.requested_count, record.receivedOrdinals).slice(0, SCRIPT_CHUNK_SIZE);
-                if (!missing.length)
-                    break;
                 let progressed = false;
-                for (let attempt = 1; attempt <= 3 && !progressed; attempt += 1) {
+                let lastRange = "";
+                let lastError = "";
+                for (const [attemptIndex, chunkSize] of FLOW_C_SCRIPT_CHUNK_SIZES.entries()) {
+                    const missing = missingOrdinals(task.requested_count, record.receivedOrdinals).slice(0, chunkSize);
+                    if (!missing.length) {
+                        progressed = true;
+                        break;
+                    }
+                    lastRange = `${missing[0]}–${missing.at(-1)}`;
                     const before = record.receivedOrdinals.length;
                     record.attempts += 1;
                     record.message = `本机 Codex 正在写第 ${missing[0]}–${missing.at(-1)} 条（总计 ${task.requested_count} 条）`;
                     record.updatedAt = now();
                     this.save();
-                    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 runCodexTurn(scriptChunkPrompt(id, task, missing), this.emit, [], { threadId: record.threadId, cwd: workspace.workspacePath, permissionMode: "full", onThread: (threadId) => { record.threadId = threadId; this.save(); } });
+                    await this.scriptTask(id);
                     progressed = record.receivedOrdinals.length > before;
-                    if (!progressed && attempt < 3)
-                        record.message = `第 ${missing[0]}–${missing.at(-1)} 条未成功回传，正在自动重试 ${attempt + 1}/3`;
+                    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 本轮执行失败";
+                    if (attemptIndex < FLOW_C_SCRIPT_CHUNK_SIZES.length - 1) {
+                        const nextSize = FLOW_C_SCRIPT_CHUNK_SIZES[attemptIndex + 1];
+                        record.message = `第 ${lastRange} 条未成功回传，正在换新会话并缩小为每段 ${nextSize} 条重试`;
+                        const thread = await startCodexThread(this.emit, workspace.workspacePath, "full");
+                        record.threadId = String(thread.id || "");
+                        this.save();
+                    }
                 }
                 if (!progressed)
-                    throw new Error(`本机 Codex 连续 3 次未回传第 ${missing[0]}–${missing.at(-1)} 条，请点击重试`);
+                    throw new Error(`本机 Codex 已自动换会话并降级到每段 10 条，仍未回传第 ${lastRange} 条${lastError ? `（${lastError}）` : ""}，请点击重试`);
             }
-            if (record.receivedOrdinals.length >= task.requested_count) {
+            const finalTask = await this.scriptTask(id);
+            if (finalTask.status === "ready" && record.receivedOrdinals.length === task.requested_count) {
                 record.status = "complete";
                 record.message = `全部 ${task.requested_count} 条高质量脚本已回传`;
             }
+            else
+                throw new Error(`中心校验尚未通过（${record.receivedOrdinals.length}/${task.requested_count} 条），请点击重试`);
         }
         catch (error) {
             record.status = error instanceof ExpiredCapabilityError ? "expired" : "error";
@@ -364,9 +388,37 @@ class ExpiredCapabilityError extends Error {
 function scriptChunkPrompt(id, task, ordinals) {
     return `你正在后台处理“抖音小辉跨境工具”Flow C 脚本交接 ${id}。
 必须使用 MCP 工具 flow_c_get_script_task 读取完整任务，再只创作 ordinal ${ordinals[0]} 到 ${ordinals.at(-1)}（精确列表：${ordinals.join(", ")}）。
+本段 productIndex 必须严格按此映射填写：${scriptProductAssignments(task.product_quantities, ordinals)}。不得凭产品名称猜测或把相邻产品编号混用。
 脚本质量绝不能因批量而降低：每条都必须独立构思、完整、真实合规，严格遵守任务 instructions、产品图片顺序和 productIndex；使用目标市场 ${task.market} 的自然本地语言与偏快但清晰的 10 秒节奏。
+用户没有指定带货方向时，不得随意只用一种泛化形式；必须按任务 instructions 中“已批准的创意方向”逐条做产品适配轮换。轮换必须按每个产品自己的序号连续计算，不能因 30/15/10 条分段、换会话或跨产品边界而从第一个方向重新开始；让同一产品在重复某一方向前优先覆盖其他适配方向。
 写完后必须调用 flow_c_submit_script_chunk 一次回传这 ${ordinals.length} 条，handoffId=${id}。不要创建付费批次，不要调用供应商模型，不要在聊天输出大段 JSON。工具返回成功后仅简短结束。`;
 }
+function scriptProductAssignments(productQuantities, ordinals) {
+    const assignments = [];
+    let first = ordinals[0];
+    let previous = first;
+    let productIndex = productIndexForOrdinal(productQuantities, first);
+    for (const ordinal of ordinals.slice(1)) {
+        const nextProductIndex = productIndexForOrdinal(productQuantities, ordinal);
+        if (nextProductIndex !== productIndex || ordinal !== previous + 1) {
+            assignments.push(`${first}${first === previous ? "" : `–${previous}`} → productIndex ${productIndex}`);
+            first = ordinal;
+            productIndex = nextProductIndex;
+        }
+        previous = ordinal;
+    }
+    assignments.push(`${first}${first === previous ? "" : `–${previous}`} → productIndex ${productIndex}`);
+    return assignments.join("；");
+}
+function productIndexForOrdinal(productQuantities, ordinal) {
+    let lastOrdinal = 0;
+    for (const [productIndex, quantity] of productQuantities.entries()) {
+        lastOrdinal += Number(quantity);
+        if (ordinal <= lastOrdinal)
+            return productIndex;
+    }
+    return -1;
+}
 function publicScript(record) {
     return { id: record.id, status: record.status, requestedCount: record.requestedCount, received: record.receivedOrdinals.length, threadId: record.threadId, message: record.message, expiresAt: record.expiresAt, updatedAt: record.updatedAt };
 }

package/package.json

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