fix(agents): keep missing tool results on current model

mikasa0818 · mikasa0818 · commit 04469ace26ff · 2026-06-21T19:00:19.000+08:00
diff --git a/src/agents/failover-error.test.ts b/src/agents/failover-error.test.ts
@@ -1288,6 +1288,20 @@ describe("failover-error", () => {
       expect(isNonProviderRuntimeCoordinationError(wrappedTakeover)).toBe(true);
     });
 
+    it("returns true for Codex missing tool-result local execution failures", () => {
+      const missingToolResultMessage =
+        "OpenClaw recorded a native Codex tool.call without a matching tool.result before the turn completed.";
+      expect(isNonProviderRuntimeCoordinationError(new Error(missingToolResultMessage))).toBe(true);
+      expect(isNonProviderRuntimeCoordinationError("reason=missing_tool_result")).toBe(true);
+      expect(
+        isNonProviderRuntimeCoordinationError({
+          message: "codex app-server turn failed",
+          cause: { result: { reason: "missing_tool_result" } },
+        }),
+      ).toBe(true);
+      expect(resolveFailoverReasonFromError(new Error(missingToolResultMessage))).toBeNull();
+    });
+
     it("returns false for plain timeouts and provider errors", () => {
       const timeoutErr = Object.assign(new Error("operation timed out"), { name: "TimeoutError" });
       expect(isNonProviderRuntimeCoordinationError(timeoutErr)).toBe(false);
@@ -1302,6 +1316,13 @@ describe("failover-error", () => {
           cause: makeSessionLockError(),
         }),
       ).toBe(false);
+      expect(
+        isNonProviderRuntimeCoordinationError({
+          status: 503,
+          message: "upstream overloaded",
+          cause: { result: { reason: "missing_tool_result" } },
+        }),
+      ).toBe(false);
       expect(isNonProviderRuntimeCoordinationError(null)).toBe(false);
       expect(isNonProviderRuntimeCoordinationError(undefined)).toBe(false);
     });
diff --git a/src/agents/failover-error.ts b/src/agents/failover-error.ts
@@ -344,15 +344,66 @@ function hasEmbeddedAttemptSessionTakeover(err: unknown, seen: Set<object> = new
   );
 }
 
+function isMissingToolResultText(value: string): boolean {
+  return (
+    value.includes("missing_tool_result") ||
+    /native Codex tool\.call without a matching tool\.result/i.test(value)
+  );
+}
+
+function hasMissingToolResultFailure(err: unknown, seen: Set<object> = new Set()): boolean {
+  if (typeof err === "string") {
+    return isMissingToolResultText(err);
+  }
+  if (!err || typeof err !== "object") {
+    return false;
+  }
+  if (seen.has(err)) {
+    return false;
+  }
+  seen.add(err);
+  const candidate = err as {
+    cause?: unknown;
+    code?: unknown;
+    detail?: unknown;
+    error?: unknown;
+    message?: unknown;
+    output?: unknown;
+    reason?: unknown;
+    result?: unknown;
+    status?: unknown;
+  };
+  const directValues = [
+    candidate.code,
+    candidate.message,
+    candidate.output,
+    candidate.reason,
+    candidate.status,
+  ];
+  if (directValues.some((value) => typeof value === "string" && isMissingToolResultText(value))) {
+    return true;
+  }
+  return [
+    candidate.error,
+    candidate.cause,
+    candidate.reason,
+    candidate.result,
+    candidate.detail,
+  ].some((value) => value !== err && hasMissingToolResultFailure(value, seen));
+}
+
 /**
- * True when the error is a local runtime coordination error (session write-lock
- * timeout or embedded attempt session takeover) rather than a provider/model
- * failure. The model fallback chain must abort on these instead of consuming
- * candidate slots — retrying any model would hit the same local condition.
- * See #83510.
+ * True when the error is a local runtime coordination/tool-execution error
+ * rather than a provider/model failure. The model fallback chain must abort on
+ * these instead of consuming candidate slots — retrying any model would hit the
+ * same local condition. See #83510 and #95474.
  */
 export function isNonProviderRuntimeCoordinationError(err: unknown): boolean {
-  if (!hasSessionWriteLockContention(err) && !hasEmbeddedAttemptSessionTakeover(err)) {
+  if (
+    !hasSessionWriteLockContention(err) &&
+    !hasEmbeddedAttemptSessionTakeover(err) &&
+    !hasMissingToolResultFailure(err)
+  ) {
     return false;
   }
   if (isFailoverError(err)) {
diff --git a/src/agents/model-fallback.test.ts b/src/agents/model-fallback.test.ts
@@ -746,6 +746,33 @@ describe("runWithModelFallback", () => {
     expect(result.attempts[0].reason).toBe("unknown");
   });
 
+  it("does not treat Codex missing tool-result failures as model fallback candidates", async () => {
+    const cfg = makeCfg({
+      agents: {
+        defaults: {
+          model: {
+            primary: "openai/gpt-5.4",
+            fallbacks: ["anthropic/claude-sonnet-4-6"],
+          },
+        },
+      },
+    });
+    const missingToolResultError = new Error(
+      "OpenClaw recorded a native Codex tool.call without a matching tool.result before the turn completed.",
+    );
+    const run = vi.fn().mockRejectedValue(missingToolResultError);
+
+    await expect(
+      runWithModelFallback({
+        cfg,
+        provider: "openai",
+        model: "gpt-5.4",
+        run,
+      }),
+    ).rejects.toBe(missingToolResultError);
+    expect(run).toHaveBeenCalledTimes(1);
+  });
+
   it("falls back on a Zhipu GLM 1305 overload body and classifies it as overloaded", async () => {
     const cfg = makeCfg();
     const glmOverload = new Error("[1305][该模型当前访问量过大，请您稍后再试]");
