@xiaohhhh1/canvas-agent 0.4.44 → 0.4.46

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

@@ -1,5 +1,5 @@
 import { type JsonRecord } from "../utils/value.js";
-import type { CodexPlanUpdate, CodexRequestParams } from "./codex-protocol.js";
+import type { CodexPlanUpdate, CodexRequestParams, CodexTurn } from "./codex-protocol.js";
 import type { AgentEmit, AgentPermissionMode } from "./types.js";
 /** 封装 Codex app-server 的 JSON-RPC 通信与事件转换。 */
 export declare class CodexAppClient {
@@ -66,6 +66,13 @@ export declare class CodexAppClient {
     private emitDelta;
     /** 合并短时间内的文本增量，减少 SSE 传输和前端渲染次数。 */
     private flushDelta;
+    /**
+     * app-server 的流式通知偶尔会在本地重连时丢失。定期读取线程的最终
+     * 状态，保证被中断的 turn 不会只因少了一条通知而永久占着 Flow C 队列。
+     */
+    private scheduleTurnReconciliation;
+    /** 清除 turn 等待器与其轮询计时器。 */
+    private clearActiveTurn;
     /** 自动回复 app-server 发起的授权或交互请求。 */
     private answerServerRequest;
     /** 完成指定 JSON-RPC 请求。 */
@@ -75,3 +82,9 @@ export declare class CodexAppClient {
     /** 拒绝进程退出时仍未完成的请求与 turn。 */
     private failAll;
 }
+/** 只有正常 completed 才能被调用方视为可用脚本。 */
+export declare function isTerminalTurnStatus(status: unknown): boolean;
+/** interrupted 也必须作为失败传回，不能被误当成空的成功响应。 */
+export declare function turnFailure(turn: Pick<CodexTurn, "status" | "error">): Error | null;
+/** 补偿轮询发现终态时，尽量取回已完成的结构化文本。 */
+export declare function turnText(turn: CodexTurn): string;

package/dist/agent/codex-client.js

@@ -8,6 +8,7 @@ import { field } from "../utils/value.js";
 const canvasAgentMcp = canvasAgentMcpCommand();
 const require = createRequire(import.meta.url);
 const STREAM_UPDATE_INTERVAL_MS = 40;
+const TURN_RECONCILE_INTERVAL_MS = 5_000;
 /** 封装 Codex app-server 的 JSON-RPC 通信与事件转换。 */
 export class CodexAppClient {
     child;
@@ -110,7 +111,10 @@ export class CodexAppClient {
                 throw completed.error;
             return completed?.text || "";
         }
-        return await new Promise((resolve, reject) => this.activeTurns.set(turnId, { resolve, reject }));
+        return await new Promise((resolve, reject) => {
+            this.activeTurns.set(turnId, { resolve, reject });
+            this.scheduleTurnReconciliation(threadId, turnId);
+        });
     }
     /** 中断当前正在运行的 Codex turn。 */
     async interruptCurrentTurn() {
@@ -267,11 +271,11 @@ export class CodexAppClient {
             const turn = params.turn;
             const turnId = turn.id;
             const pending = this.activeTurns.get(turnId);
-            const error = turn.error;
+            const error = turnFailure(turn);
             const text = this.finalTextByTurn.get(turnId) || "";
             this.finalTextByTurn.delete(turnId);
             if (pending) {
-                this.activeTurns.delete(turnId);
+                this.clearActiveTurn(turnId);
                 error ? pending.reject(new Error(error.message || "Codex turn failed")) : pending.resolve(text);
             }
             else if (turnId) {
@@ -311,6 +315,53 @@ export class CodexAppClient {
         if (pending.delta)
             this.emit("agent_event", { agent: "codex", type: "item.updated", item: { id, type: pending.itemType, delta: pending.delta }, ...codexEventScope(pending.params) });
     }
+    /**
+     * app-server 的流式通知偶尔会在本地重连时丢失。定期读取线程的最终
+     * 状态，保证被中断的 turn 不会只因少了一条通知而永久占着 Flow C 队列。
+     */
+    scheduleTurnReconciliation(threadId, turnId) {
+        const check = async () => {
+            const pending = this.activeTurns.get(turnId);
+            if (!pending)
+                return;
+            try {
+                const result = await this.readThread(threadId, true);
+                const thread = field(result, "thread");
+                const turns = Array.isArray(field(thread, "turns")) ? field(thread, "turns") : [];
+                const turn = turns.find((item) => item?.id === turnId);
+                if (turn && isTerminalTurnStatus(turn.status)) {
+                    const error = turnFailure(turn);
+                    const text = turnText(turn);
+                    this.finalTextByTurn.delete(turnId);
+                    this.clearActiveTurn(turnId);
+                    error ? pending.reject(new Error(error.message)) : pending.resolve(text);
+                    if (turnId === this.currentTurnId) {
+                        this.currentThreadId = "";
+                        this.currentTurnId = "";
+                    }
+                    return;
+                }
+            }
+            catch (error) {
+                // The normal deadline in the workflow manager remains the hard
+                // fallback. A transient read error must not cancel live work.
+                logger.debug("Codex turn reconciliation read failed", { threadId, turnId, error });
+            }
+            const current = this.activeTurns.get(turnId);
+            if (current)
+                current.reconcileTimer = setTimeout(() => void check(), TURN_RECONCILE_INTERVAL_MS);
+        };
+        const pending = this.activeTurns.get(turnId);
+        if (pending)
+            pending.reconcileTimer = setTimeout(() => void check(), TURN_RECONCILE_INTERVAL_MS);
+    }
+    /** 清除 turn 等待器与其轮询计时器。 */
+    clearActiveTurn(turnId) {
+        const pending = this.activeTurns.get(turnId);
+        if (pending?.reconcileTimer)
+            clearTimeout(pending.reconcileTimer);
+        this.activeTurns.delete(turnId);
+    }
     /** 自动回复 app-server 发起的授权或交互请求。 */
     answerServerRequest(message) {
         const method = String(message.method);
@@ -339,7 +390,13 @@ export class CodexAppClient {
     }
     /** 拒绝进程退出时仍未完成的请求与 turn。 */
     failAll(message) {
-        [...this.pending.values(), ...this.activeTurns.values()].forEach((item) => item.reject(new Error(message)));
+        [...this.pending.values()].forEach((item) => item.reject(new Error(message)));
+        [...this.activeTurns.entries()].forEach(([turnId, item]) => {
+            if (item.reconcileTimer)
+                clearTimeout(item.reconcileTimer);
+            this.activeTurns.delete(turnId);
+            item.reject(new Error(message));
+        });
         this.pendingDeltas.forEach((item) => clearTimeout(item.timer));
         this.pending.clear();
         this.activeTurns.clear();
@@ -351,6 +408,35 @@ export class CodexAppClient {
         this.currentTurnId = "";
     }
 }
+/** 只有正常 completed 才能被调用方视为可用脚本。 */
+export function isTerminalTurnStatus(status) {
+    return ["completed", "failed", "interrupted", "cancelled", "canceled"].includes(String(status || "").toLowerCase());
+}
+/** interrupted 也必须作为失败传回，不能被误当成空的成功响应。 */
+export function turnFailure(turn) {
+    if (turn.error)
+        return new Error(turn.error.message || "Codex turn failed");
+    const status = String(turn.status || "completed").toLowerCase();
+    return status === "completed" ? null : new Error(`Codex turn ${status}`);
+}
+/** 补偿轮询发现终态时，尽量取回已完成的结构化文本。 */
+export function turnText(turn) {
+    const items = Array.isArray(field(turn, "items")) ? field(turn, "items") : [];
+    for (const item of [...items].reverse()) {
+        if (!["agent_message", "agentMessage"].includes(String(field(item, "type") || "")))
+            continue;
+        const text = field(item, "text");
+        if (typeof text === "string" && text)
+            return text;
+        const content = field(item, "content");
+        if (Array.isArray(content)) {
+            const joined = content.map((part) => String(field(part, "text") || "")).join("");
+            if (joined)
+                return joined;
+        }
+    }
+    return "";
+}
 /** 生成 Codex 调用 Canvas Agent MCP 的启动命令。 */
 function canvasAgentMcpCommand() {
     const current = process.argv.find((arg) => /index\.(t|j)s$/.test(arg)) || "";

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

@@ -6,6 +6,7 @@ export type CodexThread = JsonRecord & {
 };
 export type CodexTurn = JsonRecord & {
     id: string;
+    status?: string;
     error?: CodexTurnError | null;
     durationMs?: number | null;
 };

package/dist/canvas/schemas.d.ts

@@ -975,16 +975,16 @@ export declare const toolInputSchemas: {
     }, "strip", z.ZodTypeAny, {
         title: string;
         kind: "text" | "image";
-        source?: string | undefined;
         content?: string | undefined;
+        source?: string | undefined;
         tags?: string[] | undefined;
         imageUrl?: string | undefined;
         note?: string | undefined;
     }, {
         title: string;
         kind: "text" | "image";
-        source?: string | undefined;
         content?: string | undefined;
+        source?: string | undefined;
         tags?: string[] | undefined;
         imageUrl?: string | undefined;
         note?: string | undefined;

package/dist/canvas/tools.d.ts

@@ -173,8 +173,8 @@ export declare function parseToolInput(name: ToolName, input: unknown): {
 } | {
     title: string;
     kind: "text" | "image";
-    source?: string | undefined;
     content?: string | undefined;
+    source?: string | undefined;
     tags?: string[] | undefined;
     imageUrl?: string | undefined;
     note?: string | undefined;

package/dist/workflow/script-output.js

@@ -8,6 +8,10 @@ function continuitySchema(frameField) {
 }
 function segmentSchema() {
     return object({
+        // The central Flow C API receives each long-video segment as an
+        // independently executable script. Do not omit this just because the
+        // richer storyboard fields below are also present.
+        script: { type: "string", minLength: 40 },
         continuityMode: { type: "string", enum: ["reset", "continue"] },
         continuity: continuitySchema("previousEndingFrame"),
         endingState: continuitySchema("endingFrame"),

package/package.json

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