chainlesschain 0.166.139 → 0.166.141

package/src/runtime/agent-core.js

@@ -7,6 +7,12 @@ import {
   requireUnscopedToolExecution,
 } from "../lib/formal-budget-provider-scope.js";
 import { isFormalBudgetError } from "../lib/formal-budget-errors.js";
+import {
+  FORMAL_QUALITY_ALLOWED_FILES_ENV,
+  FORMAL_QUALITY_FILE_TOOLS,
+  formalQualityAllowedFiles,
+  isFormalQualityHermeticRuntime,
+} from "../lib/formal-quality-eval-runtime.js";
 import { normalizeOllamaBaseUrl } from "../lib/ollama-base-url.js";
 import { ollamaProviderFetch } from "../lib/ollama-provider-fetch.js";
 import {
@@ -64,6 +70,11 @@ import {
 import { ReadFileLoopGuard } from "../lib/read-file-loop-guard.js";
 const READ_FILE_REQUEST_CONTEXT = Symbol("read-file-request-context");
 import { gitToolInputError } from "../lib/git-tool-input.js";
+import {
+  parseToolArguments,
+  projectRejectedToolArguments,
+  TOOL_ARGUMENTS_INVALID_CODE,
+} from "./tool-argument-recovery.js";
 import { shellOutputPage, shellOutputPreview } from "../lib/shell-output.js";
 import {
   boundedToolResultText,
@@ -12262,6 +12273,7 @@ function _openAIProviderRequestReceipt(response, data, clientRequestId) {
  * @returns {Promise<object>} response with .message
  */
 export async function chatWithTools(rawMessages, options) {
+  rawMessages = projectRejectedToolArguments(rawMessages);
   if (options.serviceTier != null) {
     resolveModelServiceTier(
       resolveModelCapabilityProfile(options),
@@ -14981,7 +14993,59 @@ function permissionDecision(callId, tool, result) {
   });
 }
 
+function bindFormalQualityLoopOptions(options) {
+  // The launcher owns this binding. Apply it at the shared loop so direct
+  // gateway/IDE callers receive the same schema and execution guard as CLI.
+  // Legacy hermetic callers without a file binding retain their own boundary.
+  if (
+    !isFormalQualityHermeticRuntime(process.env) ||
+    !Object.hasOwn(process.env, FORMAL_QUALITY_ALLOWED_FILES_ENV)
+  ) {
+    return options;
+  }
+  const allowedPaths = formalQualityAllowedFiles(process.env);
+  const cwd = options.cwd || process.cwd();
+  const launcherScope = normalizeExactFileMutationScope(
+    { exact: true, worktreeRoot: canonicalRealpath(cwd), allowedPaths },
+    { cwd },
+  );
+  const callerScope = normalizeExactFileMutationScope(
+    options.fileMutationScope,
+    {
+      cwd,
+    },
+  );
+  if (
+    callerScope &&
+    callerScope.allowedPaths.some((file) => !allowedPaths.includes(file))
+  ) {
+    throw new Error("mutation scope widens the formal quality file binding");
+  }
+  if (
+    options.enabledToolNames != null &&
+    !Array.isArray(options.enabledToolNames)
+  ) {
+    throw new Error("formal quality enabled tool names must be an array");
+  }
+  return {
+    ...options,
+    fileMutationScope: callerScope || launcherScope,
+    hermeticExecution: true,
+    exactToolNames: true,
+    // Hermetic execution ignores host executors. Match that on the provider
+    // side too: a same-named host executor must not suppress the path enum
+    // for the built-in mutation tool that will actually execute.
+    externalToolExecutors: null,
+    enabledToolNames: Object.freeze(
+      (options.enabledToolNames ?? FORMAL_QUALITY_FILE_TOOLS).filter((name) =>
+        FORMAL_QUALITY_FILE_TOOLS.includes(name),
+      ),
+    ),
+  };
+}
+
 export async function* agentLoop(messages, options) {
+  options = bindFormalQualityLoopOptions(options);
   // Bind the actual task before compaction, runtime nudges or provider projection.
   // A new host-admitted user turn starts a new loop and receives its own binding.
   const currentUserTask = messages.findLast(
@@ -17477,6 +17541,7 @@ export async function* agentLoop(messages, options) {
       toolCalls.every(
         (c) =>
           typeof c?.function?.name === "string" &&
+          parseToolArguments(c.function.arguments) !== null &&
           !pausedTools.has(c.function.name) &&
           _CHECKPOINT_READ_ONLY.has(c.function.name),
       );
@@ -17485,15 +17550,7 @@ export async function* agentLoop(messages, options) {
       const turnId = `${runId}:t${budget.consumed}`;
       const toolBatchRecords = [];
       const prepared = toolCalls.map((call) => {
-        let toolArgs;
-        try {
-          toolArgs =
-            typeof call.function.arguments === "string"
-              ? JSON.parse(call.function.arguments)
-              : call.function.arguments;
-        } catch {
-          toolArgs = {};
-        }
+        const toolArgs = parseToolArguments(call.function.arguments);
         const workflowBinding = _workflowToolEffectBinding(
           workflowEffectId,
           workflowEffectId ? (workflowChildEffectSequence += 1) : 0,
@@ -17698,15 +17755,39 @@ export async function* agentLoop(messages, options) {
         });
         continue;
       }
-      let toolArgs;
-
-      try {
-        toolArgs =
-          typeof fn.arguments === "string"
-            ? JSON.parse(fn.arguments)
-            : fn.arguments;
-      } catch {
-        toolArgs = {};
+      const toolArgs = parseToolArguments(fn.arguments);
+      if (toolArgs === null) {
+        const result = {
+          code: TOOL_ARGUMENTS_INVALID_CODE,
+          execution_started: false,
+          error:
+            "Tool arguments must be a valid JSON object. No tool was executed. " +
+            "Issue a new call with valid arguments if still appropriate.",
+        };
+        yield {
+          type: "tool-pre-execution-denied",
+          tool: toolName,
+          tool_use_id: call.id,
+          turn_id: turnId,
+          preExecutionDenied: true,
+          execution_started: false,
+        };
+        yield {
+          type: "tool-result",
+          tool: toolName,
+          result,
+          error: result.error,
+          tool_use_id: call.id,
+          turn_id: turnId,
+          preExecutionDenied: true,
+          execution_started: false,
+        };
+        appendMessages({
+          role: "tool",
+          content: JSON.stringify(result),
+          tool_call_id: call.id,
+        });
+        continue;
       }
 
       // Capability and exact-path authority must settle before any checkpoint,

package/src/runtime/tool-argument-recovery.js

@@ -0,0 +1,111 @@
+export const TOOL_ARGUMENTS_INVALID_CODE = "CC_TOOL_ARGUMENTS_INVALID";
+
+// Never infer executable arguments from a partial provider response. In
+// particular, a parse failure must not become an executable empty object.
+export function parseToolArguments(value) {
+  try {
+    const args = typeof value === "string" ? JSON.parse(value) : value;
+    if (!args || typeof args !== "object" || Array.isArray(args)) return null;
+    const prototype = Object.getPrototypeOf(args);
+    return prototype === Object.prototype || prototype === null ? args : null;
+  } catch {
+    return null;
+  }
+}
+
+function isUnexecutedArgumentRejection(result) {
+  return (
+    (result?.code === TOOL_ARGUMENTS_INVALID_CODE &&
+      result.execution_started === false) ||
+    (result?.policy?.code === "CC_RUN_CODE_EXECUTION_SNAPSHOT_INVALID" &&
+      result.policy.via === "run-code-execution-snapshot" &&
+      result.policy.decision === "blocked")
+  );
+}
+
+// Old sessions can contain a malformed provider call paired with a dispatch
+// rejection. Keep the durable transcript intact; derive a model-only copy so
+// that strict JSON projection and strict providers can admit the next turn.
+// This grants no execution authority and never repairs or forwards the bad text.
+export function projectRejectedToolArguments(messages) {
+  const callCounts = new Map();
+  const resultCounts = new Map();
+  for (const message of messages) {
+    if (message.role === "assistant" && Array.isArray(message.tool_calls)) {
+      for (const call of message.tool_calls) {
+        callCounts.set(call?.id, (callCounts.get(call?.id) || 0) + 1);
+      }
+    }
+    if (message.role === "tool") {
+      const id = message.tool_call_id;
+      resultCounts.set(id, (resultCounts.get(id) || 0) + 1);
+    }
+  }
+  let output = messages;
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (message.role !== "assistant" || !Array.isArray(message.tool_calls))
+      continue;
+    for (
+      let callIndex = 0;
+      callIndex < message.tool_calls.length;
+      callIndex++
+    ) {
+      const call = message.tool_calls[callIndex];
+      if (
+        typeof call?.id !== "string" ||
+        !call.id ||
+        callCounts.get(call.id) !== 1 ||
+        resultCounts.get(call.id) !== 1 ||
+        !call.function ||
+        (call.function.arguments !== null &&
+          typeof call.function.arguments === "object" &&
+          !Array.isArray(call.function.arguments)) ||
+        ["function", "symbol", "bigint"].includes(
+          typeof call.function.arguments,
+        ) ||
+        parseToolArguments(call.function.arguments) !== null
+      )
+        continue;
+      let resultIndex = index + 1;
+      while (
+        resultIndex < messages.length &&
+        messages[resultIndex].role === "tool" &&
+        messages[resultIndex].tool_call_id !== call.id
+      )
+        resultIndex++;
+      const result = messages[resultIndex];
+      if (result?.role !== "tool" || result.tool_call_id !== call.id) continue;
+      let content;
+      try {
+        content = JSON.parse(result.content);
+      } catch {
+        continue;
+      }
+      if (!isUnexecutedArgumentRejection(content)) continue;
+      // The legacy dispatch code belongs only to run_code.
+      if (
+        content.code !== TOOL_ARGUMENTS_INVALID_CODE &&
+        call.function.name !== "run_code"
+      )
+        continue;
+      if (output === messages) output = [...messages];
+      const calls = [...output[index].tool_calls];
+      calls[callIndex] = {
+        ...call,
+        function: { ...call.function, arguments: "{}" },
+      };
+      output[index] = { ...output[index], tool_calls: calls };
+      output[resultIndex] = {
+        ...result,
+        content: JSON.stringify({
+          ...content,
+          argumentRecovery:
+            "Malformed original arguments were omitted from this model request. " +
+            "The call was rejected before execution. Issue a new call with a valid JSON object if still appropriate.",
+        }),
+      };
+    }
+  }
+  return output;
+}

package/src/assets/web-panel/assets/index-DoVoNjtJ.js

@@ -1 +0,0 @@
-import{A as o}from"./Row-h7ovueJc.js";import{$ as t}from"./index-3RqDry-K.js";import"./responsiveObserve-CHw_f2d3.js";import"./vendor-BXcBOG8b.js";import"./useFlexGapSupport-_tbIIFMu.js";import"./styleChecker-DMybAFsA.js";import"./index-CjHA_Q7s.js";import"./icons-DlxlFL4g.js";const l=t(o);export{l as default};

package/src/assets/web-panel/assets/index-xlS8pDS2.js

@@ -1 +0,0 @@
-import{C as o}from"./Col-IO1NEUYL.js";import{$ as t}from"./index-3RqDry-K.js";import"./index-CjHA_Q7s.js";import"./vendor-BXcBOG8b.js";import"./icons-DlxlFL4g.js";const s=t(o);export{s as default};