@replayci/replay 0.1.6 → 0.1.7

package/dist/index.cjs

@@ -1916,7 +1916,12 @@ function safelyCaptureResponse(input) {
       });
       input.persistHealthEvent();
     }
-  } catch {
+  } catch (err) {
+    emitDiagnostic(input.diagnostics, {
+      type: "capture_error",
+      session_id: input.sessionId,
+      details: err instanceof Error ? err.message : "response capture failed"
+    });
   }
 }
 function safelyPushStreamCapture(input) {
@@ -1945,7 +1950,12 @@ function safelyPushStreamCapture(input) {
       });
       input.persistHealthEvent();
     }
-  } catch {
+  } catch (err) {
+    emitDiagnostic(input.diagnostics, {
+      type: "capture_error",
+      session_id: input.sessionId,
+      details: err instanceof Error ? err.message : "stream capture failed"
+    });
   }
 }
 function buildCapturedCall(input) {
@@ -2514,6 +2524,173 @@ function formatErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
+// src/preconditions.ts
+function evaluatePreconditions(preconditions, sessionState, currentArguments) {
+  return preconditions.map(
+    (p) => evaluatePrecondition(p, sessionState, currentArguments)
+  );
+}
+function evaluatePrecondition(precondition, sessionState, currentArguments) {
+  if (precondition.requires_step_count) {
+    const required = precondition.requires_step_count.gte;
+    if (sessionState.totalStepCount < required) {
+      return {
+        satisfied: false,
+        detail: `Need ${required} prior steps, have ${sessionState.totalStepCount}`
+      };
+    }
+  }
+  if (precondition.requires_prior_tool) {
+    const toolName = precondition.requires_prior_tool;
+    const resourcePath = precondition.resource ? typeof precondition.resource === "string" ? precondition.resource : precondition.resource.path : void 0;
+    const resourceValue = resourcePath ? extractPath(currentArguments ?? {}, resourcePath) : void 0;
+    const cacheKey = resourceValue !== void 0 ? `${toolName}:${JSON.stringify(resourceValue)}` : toolName;
+    let priorStep;
+    for (let i = sessionState.steps.length - 1; i >= 0; i--) {
+      const s = sessionState.steps[i];
+      if (s.toolCalls.some((tc) => {
+        if (tc.toolName !== toolName) return false;
+        if (tc.proposal_decision !== "allowed") return false;
+        if (resourceValue !== void 0 && tc.resourceValues?.[resourcePath] !== resourceValue) {
+          return false;
+        }
+        return true;
+      })) {
+        priorStep = s;
+        break;
+      }
+    }
+    const cachedExtract = sessionState.satisfiedPreconditions.get(cacheKey);
+    if (!priorStep && cachedExtract === void 0) {
+      const detail = resourceValue !== void 0 ? `Required prior tool ${toolName} not found for resource ${JSON.stringify(resourceValue)}` : `Required prior tool ${toolName} not found in session`;
+      return { satisfied: false, detail };
+    }
+    if (precondition.with_output) {
+      const extract = priorStep?.outputExtract ?? cachedExtract ?? {};
+      for (const assertion of precondition.with_output) {
+        const value = extractPath(extract, assertion.path);
+        if (assertion.equals !== void 0 && value !== assertion.equals) {
+          return {
+            satisfied: false,
+            detail: `Prior tool output assertion failed: ${assertion.path} \u2014 expected ${JSON.stringify(assertion.equals)}, got ${JSON.stringify(value)}`
+          };
+        }
+      }
+    }
+  }
+  return { satisfied: true, detail: "" };
+}
+function extractPath(obj, path) {
+  const cleanPath = path.startsWith("$.") ? path.slice(2) : path;
+  if (cleanPath === "" || cleanPath === "$") return obj;
+  const segments = cleanPath.split(".");
+  let current = obj;
+  for (const segment of segments) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current !== "object") return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+
+// src/argumentValues.ts
+function evaluateArgumentValueInvariants(parsedArguments, invariants) {
+  const failures = [];
+  for (const inv of invariants) {
+    const value = extractPath(parsedArguments, inv.path);
+    if (inv.exact_match !== void 0) {
+      const strValue = typeof value === "string" ? value : JSON.stringify(value);
+      if (strValue !== inv.exact_match) {
+        failures.push({
+          path: inv.path,
+          operator: "exact_match",
+          expected: inv.exact_match,
+          actual: value,
+          detail: `Expected exact match "${inv.exact_match}", got "${strValue}"`
+        });
+      }
+    }
+    if (inv.regex !== void 0) {
+      const strValue = typeof value === "string" ? value : String(value);
+      try {
+        const re = safeRegex(inv.regex);
+        if (!re.test(strValue)) {
+          failures.push({
+            path: inv.path,
+            operator: "regex",
+            expected: inv.regex,
+            actual: value,
+            detail: `Value "${strValue}" does not match regex "${inv.regex}"`
+          });
+        }
+      } catch {
+        failures.push({
+          path: inv.path,
+          operator: "regex",
+          expected: inv.regex,
+          actual: value,
+          detail: `Invalid regex pattern: "${inv.regex}"`
+        });
+      }
+    }
+    if (inv.one_of !== void 0) {
+      const match = inv.one_of.some((candidate) => {
+        if (typeof candidate === typeof value) {
+          return JSON.stringify(candidate) === JSON.stringify(value);
+        }
+        return false;
+      });
+      if (!match) {
+        failures.push({
+          path: inv.path,
+          operator: "one_of",
+          expected: inv.one_of,
+          actual: value,
+          detail: `Value ${JSON.stringify(value)} not in ${JSON.stringify(inv.one_of)}`
+        });
+      }
+    }
+    if (inv.type !== void 0) {
+      const actualType = Array.isArray(value) ? "array" : typeof value;
+      if (actualType !== inv.type) {
+        failures.push({
+          path: inv.path,
+          operator: "type",
+          expected: inv.type,
+          actual: actualType,
+          detail: `Expected type "${inv.type}", got "${actualType}"`
+        });
+      }
+    }
+    if (typeof inv.gte === "number") {
+      if (typeof value !== "number" || value < inv.gte) {
+        failures.push({
+          path: inv.path,
+          operator: "gte",
+          expected: inv.gte,
+          actual: value,
+          detail: `Expected >= ${inv.gte}, got ${JSON.stringify(value)}`
+        });
+      }
+    }
+    if (typeof inv.lte === "number") {
+      if (typeof value !== "number" || value > inv.lte) {
+        failures.push({
+          path: inv.path,
+          operator: "lte",
+          expected: inv.lte,
+          actual: value,
+          detail: `Expected <= ${inv.lte}, got ${JSON.stringify(value)}`
+        });
+      }
+    }
+  }
+  return {
+    passed: failures.length === 0,
+    failures
+  };
+}
+
 // src/validate.ts
 function prepareContracts(input) {
   assertSupportedNodeRuntime();
@@ -2578,6 +2755,7 @@ function evaluateAllContracts(matchedContracts, extraction) {
     failures.push(...evaluateExpectTools(contract, extraction.toolCalls));
     failures.push(...evaluateOutputInvariants(contract, extraction.normalizedResponse));
     failures.push(...evaluateExpectedToolCallMatchers(contract, extraction.toolCalls));
+    failures.push(...evaluateArgumentInvariants(contract, extraction.toolCalls));
   }
   return {
     pass: failures.length === 0,
@@ -2745,6 +2923,28 @@ function evaluateExpectedToolCallMatchers(contract, toolCalls) {
     contract_file: contract.contract_file
   }));
 }
+function evaluateArgumentInvariants(contract, toolCalls) {
+  if (!contract.argument_value_invariants || contract.argument_value_invariants.length === 0) {
+    return [];
+  }
+  const failures = [];
+  for (const toolCall of toolCalls) {
+    if (toolCall.name !== contract.tool) continue;
+    const parsedArgs = toolCall.parsedArguments != null && typeof toolCall.parsedArguments === "object" ? toolCall.parsedArguments : {};
+    const result = evaluateArgumentValueInvariants(parsedArgs, contract.argument_value_invariants);
+    for (const f of result.failures) {
+      failures.push({
+        path: f.path,
+        operator: f.operator,
+        expected: f.expected,
+        found: f.actual,
+        message: f.detail,
+        contract_file: contract.contract_file
+      });
+    }
+  }
+  return failures;
+}
 function mapInvariantFailure(contract, failure, normalizedResponse) {
   const invariant = findMatchingInvariant(contract.assertions.output_invariants, failure);
   const lookup = (0, import_contracts_core3.getPathValue)(normalizedResponse, failure.path);
@@ -3607,75 +3807,6 @@ function checkCircuitBreaker(state, config) {
   return { triggered: false, reason: null };
 }
 
-// src/preconditions.ts
-function evaluatePreconditions(preconditions, sessionState, currentArguments) {
-  return preconditions.map(
-    (p) => evaluatePrecondition(p, sessionState, currentArguments)
-  );
-}
-function evaluatePrecondition(precondition, sessionState, currentArguments) {
-  if (precondition.requires_step_count) {
-    const required = precondition.requires_step_count.gte;
-    if (sessionState.totalStepCount < required) {
-      return {
-        satisfied: false,
-        detail: `Need ${required} prior steps, have ${sessionState.totalStepCount}`
-      };
-    }
-  }
-  if (precondition.requires_prior_tool) {
-    const toolName = precondition.requires_prior_tool;
-    const resourcePath = precondition.resource ? typeof precondition.resource === "string" ? precondition.resource : precondition.resource.path : void 0;
-    const resourceValue = resourcePath ? extractPath(currentArguments ?? {}, resourcePath) : void 0;
-    const cacheKey = resourceValue !== void 0 ? `${toolName}:${JSON.stringify(resourceValue)}` : toolName;
-    let priorStep;
-    for (let i = sessionState.steps.length - 1; i >= 0; i--) {
-      const s = sessionState.steps[i];
-      if (s.toolCalls.some((tc) => {
-        if (tc.toolName !== toolName) return false;
-        if (tc.proposal_decision !== "allowed") return false;
-        if (resourceValue !== void 0 && tc.resourceValues?.[resourcePath] !== resourceValue) {
-          return false;
-        }
-        return true;
-      })) {
-        priorStep = s;
-        break;
-      }
-    }
-    const cachedExtract = sessionState.satisfiedPreconditions.get(cacheKey);
-    if (!priorStep && cachedExtract === void 0) {
-      const detail = resourceValue !== void 0 ? `Required prior tool ${toolName} not found for resource ${JSON.stringify(resourceValue)}` : `Required prior tool ${toolName} not found in session`;
-      return { satisfied: false, detail };
-    }
-    if (precondition.with_output) {
-      const extract = priorStep?.outputExtract ?? cachedExtract ?? {};
-      for (const assertion of precondition.with_output) {
-        const value = extractPath(extract, assertion.path);
-        if (assertion.equals !== void 0 && value !== assertion.equals) {
-          return {
-            satisfied: false,
-            detail: `Prior tool output assertion failed: ${assertion.path} \u2014 expected ${JSON.stringify(assertion.equals)}, got ${JSON.stringify(value)}`
-          };
-        }
-      }
-    }
-  }
-  return { satisfied: true, detail: "" };
-}
-function extractPath(obj, path) {
-  const cleanPath = path.startsWith("$.") ? path.slice(2) : path;
-  if (cleanPath === "" || cleanPath === "$") return obj;
-  const segments = cleanPath.split(".");
-  let current = obj;
-  for (const segment of segments) {
-    if (current === null || current === void 0) return void 0;
-    if (typeof current !== "object") return void 0;
-    current = current[segment];
-  }
-  return current;
-}
-
 // src/crossStep.ts
 function validateCrossStep(toolCalls, sessionState, contracts) {
   const failures = [];
@@ -3749,104 +3880,6 @@ function validateCrossStep(toolCalls, sessionState, contracts) {
   };
 }
 
-// src/argumentValues.ts
-function evaluateArgumentValueInvariants(parsedArguments, invariants) {
-  const failures = [];
-  for (const inv of invariants) {
-    const value = extractPath(parsedArguments, inv.path);
-    if (inv.exact_match !== void 0) {
-      const strValue = typeof value === "string" ? value : JSON.stringify(value);
-      if (strValue !== inv.exact_match) {
-        failures.push({
-          path: inv.path,
-          operator: "exact_match",
-          expected: inv.exact_match,
-          actual: value,
-          detail: `Expected exact match "${inv.exact_match}", got "${strValue}"`
-        });
-      }
-    }
-    if (inv.regex !== void 0) {
-      const strValue = typeof value === "string" ? value : String(value);
-      try {
-        const re = safeRegex(inv.regex);
-        if (!re.test(strValue)) {
-          failures.push({
-            path: inv.path,
-            operator: "regex",
-            expected: inv.regex,
-            actual: value,
-            detail: `Value "${strValue}" does not match regex "${inv.regex}"`
-          });
-        }
-      } catch {
-        failures.push({
-          path: inv.path,
-          operator: "regex",
-          expected: inv.regex,
-          actual: value,
-          detail: `Invalid regex pattern: "${inv.regex}"`
-        });
-      }
-    }
-    if (inv.one_of !== void 0) {
-      const match = inv.one_of.some((candidate) => {
-        if (typeof candidate === typeof value) {
-          return JSON.stringify(candidate) === JSON.stringify(value);
-        }
-        return false;
-      });
-      if (!match) {
-        failures.push({
-          path: inv.path,
-          operator: "one_of",
-          expected: inv.one_of,
-          actual: value,
-          detail: `Value ${JSON.stringify(value)} not in ${JSON.stringify(inv.one_of)}`
-        });
-      }
-    }
-    if (inv.type !== void 0) {
-      const actualType = Array.isArray(value) ? "array" : typeof value;
-      if (actualType !== inv.type) {
-        failures.push({
-          path: inv.path,
-          operator: "type",
-          expected: inv.type,
-          actual: actualType,
-          detail: `Expected type "${inv.type}", got "${actualType}"`
-        });
-      }
-    }
-    if (typeof inv.gte === "number") {
-      if (typeof value !== "number" || value < inv.gte) {
-        failures.push({
-          path: inv.path,
-          operator: "gte",
-          expected: inv.gte,
-          actual: value,
-          detail: `Expected >= ${inv.gte}, got ${JSON.stringify(value)}`
-        });
-      }
-    }
-    if (typeof inv.lte === "number") {
-      if (typeof value !== "number" || value > inv.lte) {
-        failures.push({
-          path: inv.path,
-          operator: "lte",
-          expected: inv.lte,
-          actual: value,
-          detail: `Expected <= ${inv.lte}, got ${JSON.stringify(value)}`
-        });
-      }
-    }
-  }
-  return {
-    passed: failures.length === 0,
-    failures
-  };
-}
-
 // src/messageValidation.ts
 var import_contracts_core4 = require("@replayci/contracts-core");
 function validateToolResultMessages(messages, contracts, provider) {
@@ -4620,12 +4653,12 @@ function replay(client, opts = {}) {
     contracts = resolveContracts(opts);
   } catch (err) {
     const detail = err instanceof Error ? err.message : "Failed to load contracts";
-    emitDiagnostic2(diagnostics, { type: "replay_contract_error", details: detail });
+    emitDiagnostic2(diagnostics, { type: "replay_compile_error", details: detail });
     return createBlockingInactiveSession(client, sessionId, detail);
   }
   const configError = validateConfig(contracts, opts);
   if (configError) {
-    emitDiagnostic2(diagnostics, { type: "replay_contract_error", details: configError.message });
+    emitDiagnostic2(diagnostics, { type: "replay_compile_error", details: configError.message });
     return createBlockingInactiveSession(client, sessionId, configError.message, configError);
   }
   let discoveredSessionYaml = null;
@@ -4633,7 +4666,7 @@ function replay(client, opts = {}) {
     discoveredSessionYaml = discoverSessionYaml(opts);
   } catch (err) {
     const detail = `session.yaml: ${err instanceof Error ? err.message : String(err)}`;
-    emitDiagnostic2(diagnostics, { type: "replay_contract_error", details: detail });
+    emitDiagnostic2(diagnostics, { type: "replay_compile_error", details: detail });
     return createBlockingInactiveSession(client, sessionId, detail);
   }
   let sessionYaml = discoveredSessionYaml;
@@ -4649,15 +4682,19 @@ function replay(client, opts = {}) {
       tools: opts.tools ? new Map(Object.entries(opts.tools)) : void 0
     });
   } catch (err) {
+    const detail = `Session compilation failed: ${err instanceof Error ? err.message : String(err)}`;
     emitDiagnostic2(diagnostics, {
-      type: "replay_contract_error",
-      details: `Session compilation: ${err instanceof Error ? err.message : String(err)}`
+      type: "replay_compile_error",
+      details: detail
     });
+    if (discoveredSessionYaml) {
+      return createBlockingInactiveSession(client, sessionId, detail);
+    }
   }
   if (compiledSession?.warnings && compiledSession.warnings.length > 0) {
     for (const warning of compiledSession.warnings) {
       emitDiagnostic2(diagnostics, {
-        type: "replay_contract_error",
+        type: "replay_compile_warning",
         details: `Compile warning: ${warning}`
       });
     }
@@ -4669,7 +4706,7 @@ function replay(client, opts = {}) {
       if (spec.block_incompatible && spec.block_incompatible.length > 0) {
         const detail = `Provider '${provider}' is blocked by provider_constraints: ${spec.block_incompatible.join("; ")}`;
         const err = new ReplayConfigError("provider_incompatible", detail);
-        emitDiagnostic2(diagnostics, { type: "replay_contract_error", details: detail });
+        emitDiagnostic2(diagnostics, { type: "replay_compile_error", details: detail });
         return createBlockingInactiveSession(client, sessionId, detail, err);
       }
       if (spec.warn_incompatible && spec.warn_incompatible.length > 0) {
@@ -4703,10 +4740,10 @@ function replay(client, opts = {}) {
     emitDiagnostic2(diagnostics, { type: "replay_inactive", reason: "unsupported_client" });
     return createInactiveSession(client, sessionId, "Could not resolve terminal resource");
   }
-  const protectionLevel = determineProtectionLevel(mode, opts.tools, contracts);
+  const apiKey = resolveApiKey2(opts);
+  const protectionLevel = determineProtectionLevel(mode, opts.tools, contracts, apiKey);
   const maxUnguardedCalls = opts.maxUnguardedCalls ?? DEFAULT_MAX_UNGUARDED_CALLS;
   const narrowingFeedback = opts.narrowingFeedback ?? "silent";
-  const apiKey = resolveApiKey2(opts);
   let runtimeClient = null;
   let runtimeSession = null;
   let runtimeInitPromise = null;
@@ -4846,7 +4883,12 @@ function replay(client, opts = {}) {
         void result.catch(() => {
         });
       }
-    } catch {
+    } catch (err) {
+      emitDiagnostic2(diagnostics, {
+        type: "replay_state_sync_error",
+        session_id: sessionId,
+        details: err instanceof Error ? err.message : "state sync failed"
+      });
     }
   }
   function appendCaptureToStore(capture) {
@@ -5039,7 +5081,7 @@ function replay(client, opts = {}) {
         const msgResult = validateToolResultMessages(messages, contracts, provider);
         if (!msgResult.passed) {
           emitDiagnostic2(diagnostics, {
-            type: "replay_contract_error",
+            type: "replay_validation_warning",
             details: `Message validation: ${msgResult.failures.map((f) => f.detail).join("; ")}`
           });
         }
@@ -5211,6 +5253,8 @@ function replay(client, opts = {}) {
         }
         timing.phase_ms += Date.now() - phaseStart;
         const argValuesStart = Date.now();
+        const workingToolCallCounts = new Map(sessionState.toolCallCounts);
+        const intraResponseTuples = [];
         for (const tc of toolCalls) {
           const contract = contracts.find((c) => c.tool === tc.name);
           if (contract?.argument_value_invariants && contract.argument_value_invariants.length > 0) {
@@ -5237,7 +5281,8 @@ function replay(client, opts = {}) {
             }
           }
           if (resolvedSessionLimits) {
-            const perToolResult = checkPerToolLimits(sessionState, tc.name, resolvedSessionLimits);
+            const workingState = { ...sessionState, toolCallCounts: workingToolCallCounts };
+            const perToolResult = checkPerToolLimits(workingState, tc.name, resolvedSessionLimits);
             if (perToolResult.exceeded) {
               validation.failures.push({
                 path: `$.tool_calls.${tc.name}`,
@@ -5249,23 +5294,30 @@ function replay(client, opts = {}) {
               });
             }
           }
+          workingToolCallCounts.set(tc.name, (workingToolCallCounts.get(tc.name) ?? 0) + 1);
           if (resolvedSessionLimits?.loop_detection) {
+            const argsHash = computeArgumentsHash(tc.arguments);
             const loopResult = checkLoopDetection(
               tc.name,
               tc.arguments,
               sessionState,
               resolvedSessionLimits.loop_detection
             );
-            if (loopResult.triggered) {
+            const intraMatches = intraResponseTuples.filter(
+              (t) => t.toolName === tc.name && t.argsHash === argsHash
+            ).length;
+            const totalMatches = loopResult.matchCount + intraMatches;
+            if (totalMatches >= resolvedSessionLimits.loop_detection.threshold) {
               validation.failures.push({
                 path: `$.tool_calls.${tc.name}`,
                 operator: "loop_detected",
-                expected: `< ${loopResult.threshold} occurrences in window ${loopResult.window}`,
-                found: String(loopResult.matchCount),
-                message: `Loop detected: ${tc.name} repeated ${loopResult.matchCount} times in last ${loopResult.window} steps`,
+                expected: `< ${resolvedSessionLimits.loop_detection.threshold} occurrences in window ${resolvedSessionLimits.loop_detection.window}`,
+                found: String(totalMatches),
+                message: `Loop detected: ${tc.name} repeated ${totalMatches} times in last ${resolvedSessionLimits.loop_detection.window} steps`,
                 contract_file: ""
               });
             }
+            intraResponseTuples.push({ toolName: tc.name, argsHash });
           }
         }
         timing.argument_values_ms += Date.now() - argValuesStart;
@@ -5555,7 +5607,7 @@ function replay(client, opts = {}) {
     },
     getHealth() {
       const isAuthoritative = runtimeSession != null && !runtimeDegraded;
-      const effectiveProtection = runtimeDegraded ? "protect" : protectionLevel;
+      const effectiveProtection = protectionLevel === "govern" && !isAuthoritative ? "protect" : protectionLevel;
       let durability;
       if (isAuthoritative) {
         durability = runtimeClient?.isCircuitOpen() ? "degraded-local" : "server";
@@ -5690,6 +5742,9 @@ function replay(client, opts = {}) {
     const wrapped = {};
     for (const [toolName, executor] of Object.entries(baseTools)) {
       wrapped[toolName] = async (args) => {
+        if (killed) {
+          throw new ReplayKillError(sessionId, killedAt);
+        }
         const result = await executor(args);
         if (runtimeClient && leaseFence && !runtimeDegraded) {
           for (const [callId, deferred] of deferredReceipts) {
@@ -5711,7 +5766,13 @@ function replay(client, opts = {}) {
                 if (receiptResult.stateAdvanced) {
                   sessionState = { ...sessionState, stateVersion: receiptResult.stateVersion };
                 }
-              } catch {
+              } catch (err) {
+                emitDiagnostic2(diagnostics, {
+                  type: "replay_receipt_error",
+                  session_id: sessionId,
+                  tool_name: deferred.toolName,
+                  details: err instanceof Error ? err.message : "receipt submission failed"
+                });
               }
               break;
             }
@@ -5786,7 +5847,12 @@ function replay(client, opts = {}) {
       const redactedCall = JSON.parse(redacted);
       if (buffer) buffer.push(redactedCall);
       appendCaptureToStore(redactedCall);
-    } catch {
+    } catch (err) {
+      emitDiagnostic2(diagnostics, {
+        type: "replay_capture_error",
+        session_id: sessionId,
+        details: `capture dropped (redaction failed): ${err instanceof Error ? err.message : "unknown"}`
+      });
     }
   }
 }
@@ -6301,10 +6367,27 @@ function applyOutputExtracts(state, updates) {
   };
 }
 function resolveSessionLimits(contracts) {
+  const merged = {};
+  let found = false;
   for (const c of contracts) {
-    if (c.session_limits) return c.session_limits;
+    if (!c.session_limits) continue;
+    found = true;
+    const sl = c.session_limits;
+    if (sl.max_steps !== void 0 && merged.max_steps === void 0) merged.max_steps = sl.max_steps;
+    if (sl.max_tool_calls !== void 0 && merged.max_tool_calls === void 0) merged.max_tool_calls = sl.max_tool_calls;
+    if (sl.max_cost_per_session !== void 0 && merged.max_cost_per_session === void 0) merged.max_cost_per_session = sl.max_cost_per_session;
+    if (sl.loop_detection && !merged.loop_detection) merged.loop_detection = sl.loop_detection;
+    if (sl.circuit_breaker && !merged.circuit_breaker) merged.circuit_breaker = sl.circuit_breaker;
+    if (sl.max_calls_per_tool) {
+      if (!merged.max_calls_per_tool) merged.max_calls_per_tool = {};
+      for (const [tool, limit] of Object.entries(sl.max_calls_per_tool)) {
+        if (merged.max_calls_per_tool[tool] === void 0) {
+          merged.max_calls_per_tool[tool] = limit;
+        }
+      }
+    }
   }
-  return null;
+  return found ? merged : null;
 }
 function buildStateSnapshot(state, lastNarrowing = null) {
   const lastStep = state.lastStep ? {
@@ -6533,9 +6616,10 @@ function emitDiagnostic2(diagnostics, event) {
 function toRecord10(value) {
   return value !== null && typeof value === "object" ? value : {};
 }
-function determineProtectionLevel(mode, tools, contracts) {
+function determineProtectionLevel(mode, tools, contracts, apiKey) {
   if (mode === "shadow" || mode === "log-only") return "monitor";
   if (!tools || Object.keys(tools).length === 0) return "protect";
+  if (!apiKey) return "protect";
   const stateBearingTools = contracts.filter(isStateBearing);
   if (stateBearingTools.length === 0) return "protect";
   const wrappedTools = new Set(Object.keys(tools));