@spotpatch/agent 1.2.0 → 1.2.1

package/dist/index.cjs

@@ -69,9 +69,27 @@ function parseJsonRecord(value) {
 }
 function parseToolArguments(value) {
   if (typeof value !== "string") {
-    throw new import_shared.SpotPatchError(import_shared.ERROR_CODES.PROVIDER_PROTOCOL_UNSUPPORTED);
+    throw new import_shared.SpotPatchError(import_shared.ERROR_CODES.TOOL_ARGUMENTS_INVALID);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new import_shared.SpotPatchError(import_shared.ERROR_CODES.TOOL_ARGUMENTS_INVALID);
+  }
+  if (!isRecord(parsed)) {
+    throw new import_shared.SpotPatchError(import_shared.ERROR_CODES.TOOL_ARGUMENTS_INVALID);
+  }
+  return parsed;
+}
+function assertUniqueToolCallIds(calls) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const call of calls) {
+    if (ids.has(call.id)) {
+      throw new import_shared.SpotPatchError(import_shared.ERROR_CODES.TOOL_CALL_ID_CONFLICT);
+    }
+    ids.add(call.id);
   }
-  return parseJsonRecord(value);
 }
 function requireString(record, field) {
   const value = record[field];
@@ -81,6 +99,7 @@ function requireString(record, field) {
   return value;
 }
 function validateToolResults(pendingCalls, results) {
+  assertUniqueToolCallIds(pendingCalls);
   if (pendingCalls.length === 0) {
     if (results !== void 0 && results.length > 0) {
       throw new import_shared.SpotPatchError(import_shared.ERROR_CODES.INTERNAL_ERROR);
@@ -478,6 +497,7 @@ function parseChatEvents(events) {
   }
   const finalText = content.join("");
   const toolCalls = finalizeToolCalls(calls);
+  assertUniqueToolCallIds(toolCalls);
   if (toolCalls.length === 0 && finalText.trim().length === 0) {
     throw new import_shared5.SpotPatchError(import_shared5.ERROR_CODES.PROVIDER_PROTOCOL_UNSUPPORTED);
   }
@@ -574,7 +594,7 @@ function collectFunctionCall(item, calls) {
   });
   const existing = calls.get(id);
   if (existing !== void 0 && (existing.name !== call.name || JSON.stringify(existing.arguments) !== JSON.stringify(call.arguments))) {
-    throw new import_shared6.SpotPatchError(import_shared6.ERROR_CODES.PROVIDER_PROTOCOL_UNSUPPORTED);
+    throw new import_shared6.SpotPatchError(import_shared6.ERROR_CODES.TOOL_CALL_ID_CONFLICT);
   }
   calls.set(id, call);
 }
@@ -874,7 +894,7 @@ function encodeUtf8Text(content, includeByteOrderMark) {
 }
 async function writeAgentTextFileIfContentMatches(root, relativePath, expectedContent, nextContent, maximumBytes) {
   if (nextContent.includes("\0")) {
-    throw new import_shared9.SpotPatchError(import_shared9.ERROR_CODES.TOOL_INPUT_INVALID);
+    throw new import_shared9.SpotPatchError(import_shared9.ERROR_CODES.TOOL_ARGUMENTS_INVALID);
   }
   const absolutePath = await resolveExistingAgentPath(root, relativePath);
   const [metadata, currentBytes] = await Promise.all([
@@ -1143,7 +1163,7 @@ async function runConfiguredCheck(options) {
 function requireConfiguredCheck(checkId, checks) {
   const check = checks[checkId];
   if (check === void 0) {
-    throw new import_shared10.SpotPatchError(import_shared10.ERROR_CODES.TOOL_INPUT_INVALID);
+    throw new import_shared10.SpotPatchError(import_shared10.ERROR_CODES.TOOL_ARGUMENTS_INVALID);
   }
   return check;
 }
@@ -1455,7 +1475,7 @@ var MAX_DISCOVERED_FILES = 2e4;
 var TEXT_SAMPLE_BYTES = 8192;
 function compileGlob(glob) {
   if (glob.length === 0 || glob.length > 256 || glob.includes("\0") || glob.includes("\\") || glob.startsWith("/") || ["[", "]", "{", "}", "(", ")", "!"].some((character) => glob.includes(character)) || glob.split("/").some((segment) => segment === "..")) {
-    throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.TOOL_INPUT_INVALID);
+    throw new import_shared14.SpotPatchError(import_shared14.ERROR_CODES.TOOL_ARGUMENTS_INVALID);
   }
   let expression = "^";
   for (let index = 0; index < glob.length; index += 1) {
@@ -1694,7 +1714,7 @@ var runCheckSchema = import_zod.z.strictObject({
   checkId: import_zod.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u)
 });
 function invalidTool() {
-  throw new import_shared15.SpotPatchError(import_shared15.ERROR_CODES.TOOL_INPUT_INVALID);
+  throw new import_shared15.SpotPatchError(import_shared15.ERROR_CODES.TOOL_ARGUMENTS_INVALID);
 }
 function parseArguments(schema, value) {
   const parsed = schema.safeParse(value);
@@ -1751,8 +1771,16 @@ function retryableWriteRejection(reason, guidance) {
     guidance
   });
 }
+function retryableArgumentsRejection() {
+  return Object.freeze({
+    errorCode: import_shared15.ERROR_CODES.TOOL_ARGUMENTS_INVALID,
+    retryable: true,
+    reason: "ARGUMENTS_DO_NOT_MATCH_CONTRACT",
+    guidance: "No files changed. Retry once with a new tool call ID and only the declared fields and value types."
+  });
+}
 function createAgentToolExecutor(options) {
-  const cache = /* @__PURE__ */ new Map();
+  const cacheByTurn = /* @__PURE__ */ new Map();
   const touchedPaths = /* @__PURE__ */ new Set();
   const executeUncached = async (call, signal) => {
     switch (call.name) {
@@ -1968,20 +1996,32 @@ function createAgentToolExecutor(options) {
     }
   };
   return Object.freeze({
-    async execute(call, signal) {
+    async execute(call, scope, signal) {
+      if (!Number.isSafeInteger(scope.turn) || scope.turn < 1) {
+        throw new import_shared15.SpotPatchError(import_shared15.ERROR_CODES.INTERNAL_ERROR);
+      }
+      const turnCache = cacheByTurn.get(scope.turn) ?? /* @__PURE__ */ new Map();
+      cacheByTurn.set(scope.turn, turnCache);
       const signature = `${call.name}\0${JSON.stringify(call.arguments)}`;
-      const cached = cache.get(call.id);
+      const cached = turnCache.get(call.id);
       if (cached !== void 0) {
         if (cached.signature !== signature) {
-          return invalidTool();
+          throw new import_shared15.SpotPatchError(import_shared15.ERROR_CODES.TOOL_CALL_ID_CONFLICT);
         }
         return cached.result;
       }
-      const result = Object.freeze({
-        toolCallId: call.id,
-        output: await executeUncached(call, signal)
-      });
-      cache.set(call.id, Object.freeze({ signature, result }));
+      let output;
+      try {
+        output = await executeUncached(call, signal);
+      } catch (error) {
+        if (error instanceof import_shared15.SpotPatchError && error.code === import_shared15.ERROR_CODES.TOOL_ARGUMENTS_INVALID) {
+          output = retryableArgumentsRejection();
+        } else {
+          throw error;
+        }
+      }
+      const result = Object.freeze({ toolCallId: call.id, output });
+      turnCache.set(call.id, Object.freeze({ signature, result }));
       return result;
     },
     touchedPaths() {
@@ -2552,6 +2592,7 @@ Follow these rules exactly:
 - Use apply_patch only when creating or deleting a file, or when the change cannot be expressed as one exact replacement. apply_patch accepts only a raw canonical unified Git diff.
 - Every patch must begin with 'diff --git a/<path> b/<path>', include matching '--- a/<path>' and '+++ b/<path>' headers and valid '@@' hunks. Send only the raw diff: no Markdown fences, prose, shell commands, or '*** Begin Patch' markers.
 - If a write tool returns a retryable PATCH_REJECTED result, no file changed. Follow its guidance, re-read the current file, and retry once with a new tool call ID.
+- If any tool returns a retryable TOOL_ARGUMENTS_INVALID result, no file changed. Retry once with a new tool call ID using only the declared fields and value types.
 - Never modify credentials, environment files, lockfiles, generated output, Git metadata, or dependencies.
 - Do not claim a check passed unless run_check returned a passed status.
 - Finish with a concise factual summary after all needed tool calls. Do not include secrets or absolute paths.`;
@@ -2711,7 +2752,7 @@ function isRetryableToolFailure(result) {
     return false;
   }
   const candidate = output;
-  return candidate.errorCode === import_shared20.ERROR_CODES.PATCH_REJECTED && candidate.retryable === true;
+  return candidate.retryable === true && (candidate.errorCode === import_shared20.ERROR_CODES.PATCH_REJECTED || candidate.errorCode === import_shared20.ERROR_CODES.TOOL_ARGUMENTS_INVALID);
 }
 function throwIfCancelled(signal) {
   if (signal.aborted) {
@@ -2787,8 +2828,10 @@ async function executeAgentChange(options) {
     let summary;
     let toolCallCount = 0;
     for (let turn = 0; turn < options.execution.limits.maxTurns; turn += 1) {
+      const turnNumber = turn + 1;
       throwIfCancelled(controller.signal);
       const response = await session.next(pendingResults, controller.signal);
+      assertUniqueToolCallIds(response.toolCalls);
       if (response.toolCalls.length === 0) {
         summary = response.finalText.trim().slice(0, options.execution.limits.maxToolOutputCharacters);
         break;
@@ -2801,16 +2844,22 @@ async function executeAgentChange(options) {
       for (const call of response.toolCalls) {
         options.callbacks?.onTool?.(
           Object.freeze({
+            turn: turnNumber,
             toolCallId: call.id,
             toolName: call.name,
             state: "started"
           })
         );
         try {
-          const result2 = await executor.execute(call, controller.signal);
+          const result2 = await executor.execute(
+            call,
+            Object.freeze({ turn: turnNumber }),
+            controller.signal
+          );
           results.push(result2);
           options.callbacks?.onTool?.(
             Object.freeze({
+              turn: turnNumber,
               toolCallId: call.id,
               toolName: call.name,
               state: isRetryableToolFailure(result2) ? "failed" : "succeeded"
@@ -2819,6 +2868,7 @@ async function executeAgentChange(options) {
         } catch (error) {
           options.callbacks?.onTool?.(
             Object.freeze({
+              turn: turnNumber,
               toolCallId: call.id,
               toolName: call.name,
               state: "failed"