@xiaohhhh1/canvas-agent 0.4.49 → 0.4.50

package/dist/agent/codex.d.ts

@@ -17,7 +17,18 @@ export type CodexRunResult = {
     ok: false;
     error: string;
 };
-export type CodexWorkflowRunResult = CodexRunResult & {
+export type CodexWorkflowRunResult = {
+    ok: true;
+    text: string;
+    timings: {
+        queueWaitMs: number;
+        threadStartMs: number;
+        modelMs: number;
+    };
+} | {
+    ok: false;
+    error: string;
+    retryable: boolean;
     timings: {
         queueWaitMs: number;
         threadStartMs: number;
@@ -45,6 +56,8 @@ export declare function runCodexWorkflowTurn(prompt: string, emit: AgentEmit, op
     onWorkerStart?: () => void;
     onWorkerFinish?: () => void;
 }): Promise<CodexWorkflowRunResult>;
+/** Contract/preflight 4xx errors are deterministic and must never burn every fallback chunk size. */
+export declare function isDeterministicWorkflowContractError(error: unknown): boolean;
 /** 强制回收失去响应的 app-server；只用于有界超时恢复。 */
 export declare function restartCodexApp(message?: string): Promise<void>;
 /** 回复当前 app-server 的待处理权限请求。 */

package/dist/agent/codex.js

@@ -37,7 +37,7 @@ export async function interruptCodexTurn(threadId) {
  */
 export async function runCodexWorkflowTurn(prompt, emit, options) {
     if (!prompt.trim())
-        return { ok: false, error: "Codex prompt is empty", timings: { queueWaitMs: 0, threadStartMs: 0, modelMs: 0 } };
+        return { ok: false, error: "Codex prompt is empty", retryable: false, timings: { queueWaitMs: 0, threadStartMs: 0, modelMs: 0 } };
     return await workflowCodexPool.run(async (workerIndex, queueWaitMs) => {
         options.onWorkerStart?.();
         const modelSettings = { model: FLOW_C_CODEX_MODEL, reasoningEffort: FLOW_C_CODEX_REASONING_EFFORT };
@@ -61,7 +61,7 @@ export async function runCodexWorkflowTurn(prompt, emit, options) {
                 workflowCodexApps.delete(workerIndex);
                 await app.terminate("Flow C 脚本回合超时，已仅回收当前 worker");
                 await turn.catch(() => undefined);
-                return { ok: false, error: "Flow C 脚本回合超过 8 分钟，已自动终止当前 worker", timings: { queueWaitMs, threadStartMs, modelMs: Date.now() - modelStartedAt } };
+                return { ok: false, error: "Flow C 脚本回合超过 8 分钟，已自动终止当前 worker", retryable: true, timings: { queueWaitMs, threadStartMs, modelMs: Date.now() - modelStartedAt } };
             }
             return { ok: true, text: result, timings: { queueWaitMs, threadStartMs, modelMs: Date.now() - modelStartedAt } };
         }
@@ -69,7 +69,7 @@ export async function runCodexWorkflowTurn(prompt, emit, options) {
             logger.error("Flow C Codex worker failed", { workerIndex, error });
             const message = errorMessage(error);
             emit("agent_error", { message });
-            return { ok: false, error: message, timings: { queueWaitMs, threadStartMs: threadStartMs || Date.now() - threadStartedAt, modelMs: modelStartedAt ? Date.now() - modelStartedAt : 0 } };
+            return { ok: false, error: message, retryable: !isDeterministicWorkflowContractError(message), timings: { queueWaitMs, threadStartMs: threadStartMs || Date.now() - threadStartedAt, modelMs: modelStartedAt ? Date.now() - modelStartedAt : 0 } };
         }
         finally {
             if (timer)
@@ -78,6 +78,11 @@ export async function runCodexWorkflowTurn(prompt, emit, options) {
         }
     });
 }
+/** Contract/preflight 4xx errors are deterministic and must never burn every fallback chunk size. */
+export function isDeterministicWorkflowContractError(error) {
+    const message = errorMessage(error);
+    return /invalid_json_schema|invalid schema for response_format|text\.format\.schema|response[_ ]format[^\n]*(?:invalid|schema)/i.test(message);
+}
 async function startWorkflowCodexApp(workerIndex, emit) {
     let started;
     started = await CodexAppClient.start(emit, () => {

package/dist/workflow/manager.d.ts

@@ -229,6 +229,11 @@ export declare class WorkflowManager {
     private save;
 }
 export declare function compareScriptQueueRecords(left: Pick<ScriptRecord, "priorityAt" | "updatedAt">, right: Pick<ScriptRecord, "priorityAt" | "updatedAt">): number;
+/** A deterministic response-format failure stops fallback isolation immediately. */
+export declare function terminalScriptChunkError(results: Array<{
+    error?: string;
+    terminal?: boolean;
+}>): string;
 export declare function scriptChunkPrompt(id: string, task: ScriptTask, ordinals: number[]): string;
 export declare function missingOrdinals(total: number, received: number[]): number[];
 export {};

package/dist/workflow/manager.js

@@ -239,6 +239,10 @@ export class WorkflowManager {
             const workspace = ensureSiteWorkspace(this.config);
             const durationSeconds = Number(task.duration_seconds || 10);
             const chunkSizes = flowCScriptChunkSizes(durationSeconds);
+            // Fail locally before starting any worker if a future schema edit
+            // violates strict response-format invariants.
+            for (const chunkSize of new Set(chunkSizes))
+                flowCScriptOutputSchema(durationSeconds, chunkSize);
             record.activeChunks = 0;
             let chunkSizeIndex = 0;
             while (record.receivedOrdinals.length < task.requested_count) {
@@ -253,6 +257,10 @@ export class WorkflowManager {
                 this.save();
                 const results = await Promise.all(chunks.map((ordinals) => this.runScriptChunk(id, task, ordinals, workspace.workspacePath)));
                 await this.scriptTask(id);
+                const terminalError = terminalScriptChunkError(results);
+                if (terminalError) {
+                    throw new Error(`本机脚本结构化契约被 Codex 拒绝，已停止自动重试且未提交缺失脚本。请先升级或修复 Canvas Agent，再手动重试（${terminalError}）`);
+                }
                 const progressed = record.receivedOrdinals.length > before;
                 if (progressed) {
                     chunkSizeIndex = 0;
@@ -304,7 +312,7 @@ export class WorkflowManager {
         this.emitScriptStage(id, ordinals, "thread_start", result.timings.threadStartMs);
         this.emitScriptStage(id, ordinals, "model", result.timings.modelMs);
         if (!result.ok || !result.text)
-            return { error: result.ok ? "Codex 未返回可用的结构化脚本" : result.error };
+            return { error: result.ok ? "Codex 未返回可用的结构化脚本" : result.error, terminal: !result.ok && !result.retryable };
         try {
             const parseStartedAt = Date.now();
             const jobs = parseFlowCScriptOutput(result.text, ordinals);
@@ -312,10 +320,10 @@ export class WorkflowManager {
             const persistStartedAt = Date.now();
             await this.submitGeneratedScriptJobs(id, jobs);
             this.emitScriptStage(id, ordinals, "persist", Date.now() - persistStartedAt);
-            return {};
+            return { terminal: false };
         }
         catch (error) {
-            return { error: error instanceof Error ? `结构化脚本未通过本机校验：${error.message}` : "结构化脚本未通过本机校验" };
+            return { error: error instanceof Error ? `结构化脚本未通过本机校验：${error.message}` : "结构化脚本未通过本机校验", terminal: false };
         }
     }
     /** 只记录阶段、ordinal 和毫秒数；禁止记录 prompt、令牌或中心能力。 */
@@ -487,6 +495,10 @@ export function compareScriptQueueRecords(left, right) {
         return String(right.priorityAt || "").localeCompare(String(left.priorityAt || ""));
     return left.updatedAt.localeCompare(right.updatedAt);
 }
+/** A deterministic response-format failure stops fallback isolation immediately. */
+export function terminalScriptChunkError(results) {
+    return results.find((result) => result.terminal)?.error || "";
+}
 class ExpiredCapabilityError extends Error {
 }
 export function scriptChunkPrompt(id, task, ordinals) {

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

@@ -1,5 +1,11 @@
 type JsonSchema = Record<string, unknown>;
 /** Codex app-server 的结构化脚本返回契约；回传由 Agent 完成，不依赖模型调用 MCP。 */
 export declare function flowCScriptOutputSchema(durationSeconds: 10 | 20 | 30, count: number): JsonSchema;
+/**
+ * OpenAI strict structured output requires every declared object property to
+ * appear in `required`. Optional semantics must therefore be represented by a
+ * required nullable field, never by omitting that key from `required`.
+ */
+export declare function assertStrictResponseSchema(schemaValue: unknown, path?: string): asserts schemaValue is JsonSchema;
 export declare function parseFlowCScriptOutput(value: string, expectedOrdinals: number[]): unknown[];
 export {};

package/dist/workflow/script-output.js

@@ -1,4 +1,5 @@
 const text = { type: "string", minLength: 1 };
+const nullableText = { anyOf: [text, { type: "null" }] };
 const continuityFields = ["character", "wardrobe", "location", "lighting", "productState", "unfinishedAction", "nextGoal"];
 function object(properties, required = Object.keys(properties)) {
     return { type: "object", properties, required, additionalProperties: false };
@@ -26,16 +27,16 @@ function creativePlanSchema() {
         format: text,
         visualHook: text,
         conflict: text,
-        escalation: text,
-        turn: text,
+        escalation: nullableText,
+        turn: nullableText,
         productIntervention: text,
         visibleProof: text,
         callbackMotivation: text,
         truthBoundary: text,
         differentiationKey: text,
-        styleCardSummary: text,
+        styleCardSummary: nullableText,
     };
-    return object(properties, Object.keys(properties).filter((field) => !["escalation", "turn"].includes(field)));
+    return object(properties);
 }
 function qualityGateSchema() {
     return object({
@@ -87,7 +88,40 @@ export function flowCScriptOutputSchema(durationSeconds, count) {
         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) } });
+    const schema = object({ jobs: { type: "array", minItems: count, maxItems: count, items: object(properties) } });
+    assertStrictResponseSchema(schema);
+    return schema;
+}
+/**
+ * OpenAI strict structured output requires every declared object property to
+ * appear in `required`. Optional semantics must therefore be represented by a
+ * required nullable field, never by omitting that key from `required`.
+ */
+export function assertStrictResponseSchema(schemaValue, path = "$") {
+    const schema = recordOf(schemaValue);
+    if (!schema)
+        throw new Error(`Strict response schema at ${path} must be an object`);
+    if (schema.type === "object") {
+        const properties = recordOf(schema.properties);
+        if (!properties)
+            throw new Error(`Strict response schema object at ${path} needs properties`);
+        const keys = Object.keys(properties).sort();
+        const required = Array.isArray(schema.required) ? schema.required.map(String).sort() : [];
+        if (keys.length !== required.length || keys.some((key, index) => key !== required[index])) {
+            throw new Error(`Strict response schema object at ${path} must require every property`);
+        }
+        if (schema.additionalProperties !== false)
+            throw new Error(`Strict response schema object at ${path} must disable additional properties`);
+        for (const [key, child] of Object.entries(properties))
+            assertStrictResponseSchema(child, `${path}.properties.${key}`);
+    }
+    if (schema.items)
+        assertStrictResponseSchema(schema.items, `${path}.items`);
+    for (const branchKey of ["anyOf", "oneOf", "allOf"]) {
+        const branches = schema[branchKey];
+        if (Array.isArray(branches))
+            branches.forEach((branch, index) => assertStrictResponseSchema(branch, `${path}.${branchKey}[${index}]`));
+    }
 }
 export function parseFlowCScriptOutput(value, expectedOrdinals) {
     const source = String(value || "").trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");

package/package.json

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