@theokit/sdk 2.13.1 → 2.15.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 2.15.0
+
+### Minor Changes
+
+- d7057f2: Add a **doom-loop / no-progress guard** to the agent loop. The loop now detects when the model repeats IDENTICAL tool calls (same name + same canonical input) that make no progress — the qwen3-coder `read_file`/`not_found` failure mode where the model retries the same failing call and the run grinds to the iteration ceiling — and stops early with a typed `no_progress` terminal instead of hanging. A pure `DoomLoopTracker` (canonical key-sorted-JSON signature + a consecutive-identical counter) escalates from a one-time guidance nudge at a soft threshold to a hard stop; the hard stop surfaces on `RunResult.stoppedByDoomLoop` and, through the continuation driver, as `terminal: "no_progress"` (so the outer loop does not re-send). It complements — does not replace — the existing empty-round `no_progress` (a different failure mode: model stuck repeating vs model gone silent). On by default with generous thresholds (soft 3 / hard 5); tune or disable per send via `SendOptions.doomLoop` (`false` to disable, or `{ softThreshold, hardThreshold }` to tune). Dependency-free. Grounded in a SOTA study of cline's LoopDetectionTracker + opencode's doom-loop.
+
+## 2.14.0
+
+### Minor Changes
+
+- 6ee4217: Add a public, isolated tool-input **sanitization** primitive on the new `@theokit/sdk/sanitize` subpath, plus a declarative `defineTool({ sanitize })` opt-in. Custom tools can now clean the raw arguments a model emits before they reach the tool schema: `sanitizeToolInput(input, options?)` trims whitespace by default and — opt-in — coerces string values toward their expected type (`"5"`→`5`, `"true"`→`true`, JSON-encoded strings→arrays/objects) and repairs malformed JSON (via `jsonrepair`). Coercion is guarded against silent corruption: numeric coercion round-trips and stays finite, so ID-like strings (`"12345678901234567890"`, `"007"`) and `NaN`/`Infinity` are left as strings; JSON repair only runs on JSON-looking values; a non-object input is returned untouched (the primitive is total — it never throws). When a Zod object schema is passed, coercion is schema-aware (a `z.string()` field keeps `"5"` a string). `defineTool({ sanitize: true })` trims the raw args before validation; `defineTool({ sanitize: { coerce: true } })` additionally coerces toward the tool's own schema — absent, `defineTool` behaviour is unchanged. Internally, the leaked-dialect recovery (`hermes-tool-extract`) now reuses the same primitive, so the public surface and the internal path never diverge. Grounded in a SOTA study of openclaw / agentfw / opencode / cline / vercel-ai-sdk.
+
 ## 2.13.1
 
 ### Patch Changes

package/dist/a2a/index.cjs

@@ -2336,6 +2336,7 @@ function applyScriptMetrics(base, script) {
   if (script.usage !== void 0) base.usage = script.usage;
   if (script.cost !== void 0) base.cost = script.cost;
   if (script.stoppedAtIterationLimit === true) base.stoppedAtIterationLimit = true;
+  if (script.stoppedByDoomLoop === true) base.stoppedByDoomLoop = true;
 }
 var FixtureRunBase;
 var init_fixture_run_base = __esm({
@@ -6812,6 +6813,98 @@ var init_budget_gate = __esm({
   }
 });
 
+// src/internal/agent-loop/doom-loop-tracker.ts
+function createDoomLoopTracker(option) {
+  if (option === false) return void 0;
+  return new DoomLoopTracker(option);
+}
+function assertValidThresholds(soft, hard) {
+  for (const [label, value] of [
+    ["softThreshold", soft],
+    ["hardThreshold", hard]
+  ]) {
+    if (!Number.isInteger(value) || value < 1) {
+      throw new ConfigurationError(
+        `doomLoop.${label} must be a positive integer (received ${value}).`,
+        { code: "invalid_doom_loop_threshold" }
+      );
+    }
+  }
+}
+function sortKeys(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(sortKeys);
+  const out = {};
+  for (const key of Object.keys(value).sort()) {
+    out[key] = sortKeys(value[key]);
+  }
+  return out;
+}
+function signatureOf(call) {
+  const { input } = call;
+  let inputSig;
+  if (input === null || input === void 0) inputSig = "null";
+  else if (typeof input !== "object") inputSig = String(input);
+  else {
+    try {
+      inputSig = JSON.stringify(sortKeys(input)) ?? "null";
+    } catch {
+      inputSig = String(input);
+    }
+  }
+  return `${call.name}\0${inputSig}`;
+}
+function firstDoomLoopVerdict(tracker, calls) {
+  let escalation = { kind: "ok" };
+  for (const call of calls) {
+    const v = tracker.inspect(call);
+    if (v.kind === "hard") return v;
+    if (v.kind === "soft" && escalation.kind === "ok") escalation = v;
+  }
+  return escalation;
+}
+var DEFAULT_CONFIG, DoomLoopTracker;
+var init_doom_loop_tracker = __esm({
+  "src/internal/agent-loop/doom-loop-tracker.ts"() {
+    init_errors();
+    DEFAULT_CONFIG = { softThreshold: 3, hardThreshold: 5 };
+    DoomLoopTracker = class {
+      #config;
+      #lastSignature = "";
+      #count = 0;
+      constructor(config) {
+        const softThreshold = config?.softThreshold ?? DEFAULT_CONFIG.softThreshold;
+        const hardThreshold = config?.hardThreshold ?? DEFAULT_CONFIG.hardThreshold;
+        assertValidThresholds(softThreshold, hardThreshold);
+        this.#config = { softThreshold, hardThreshold };
+      }
+      inspect(call) {
+        const signature = signatureOf(call);
+        this.#count = signature === this.#lastSignature ? this.#count + 1 : 1;
+        this.#lastSignature = signature;
+        const count = this.#count;
+        if (count >= this.#config.hardThreshold) {
+          return {
+            kind: "hard",
+            message: `Detected ${count} consecutive identical calls to \`${call.name}\`; stopping to avoid a loop.`
+          };
+        }
+        if (count === this.#config.softThreshold) {
+          return {
+            kind: "soft",
+            message: `Detected ${count} consecutive identical calls to \`${call.name}\`; try a different approach.`
+          };
+        }
+        return { kind: "ok" };
+      }
+      reset() {
+        this.#lastSignature = "";
+        this.#count = 0;
+      }
+    };
+  }
+});
+
 // src/internal/budget/usage-accumulator.ts
 var UsageAccumulator;
 var init_usage_accumulator = __esm({
@@ -7001,6 +7094,7 @@ async function initLoopContext(inputs) {
     tools,
     finalText: "",
     finalStatus: "finished",
+    doomLoop: createDoomLoopTracker(inputs.doomLoop),
     usage: new UsageAccumulator(),
     nudgeAttempts: 0,
     stopFeedbackAttempts: 0,
@@ -7053,6 +7147,7 @@ function sanitize(name) {
 var init_loop_context_init = __esm({
   "src/internal/agent-loop/loop-context-init.ts"() {
     init_usage_accumulator();
+    init_doom_loop_tracker();
     init_message_builders();
   }
 });
@@ -8165,6 +8260,7 @@ async function runAgentLoop(inputs) {
       ctx.finalStatus = "error";
     }
     sendSpan?.setAttribute("status", ctx.finalStatus);
+    if (ctx.stoppedByDoomLoop === true) sendSpan?.setAttribute("stoppedByDoomLoop", true);
     if (inputs.telemetry?.includeContent === true && ctx.finalText.length > 0) {
       sendSpan?.addEvent("response", { content: ctx.finalText });
     }
@@ -8191,7 +8287,8 @@ async function runAgentLoop(inputs) {
       ...usage !== void 0 ? { usage } : {},
       ...cost !== void 0 ? { cost } : {},
       ...ctx.error !== void 0 ? { error: ctx.error } : {},
-      ...ctx.stoppedAtIterationLimit === true ? { stoppedAtIterationLimit: true } : {}
+      ...ctx.stoppedAtIterationLimit === true ? { stoppedAtIterationLimit: true } : {},
+      ...ctx.stoppedByDoomLoop === true ? { stoppedByDoomLoop: true } : {}
     };
   } finally {
     if (ctxRef !== void 0 && ctxRef.memoryProviderHandle !== void 0 && inputs.memoryProvider !== void 0) {
@@ -8350,8 +8447,26 @@ async function continueOrTerminate(inputs, ctx, llmOutput) {
     }
   }
   pushToolConversationSteps(ctx, llmOutput.toolCalls, toolResults);
+  if (await inspectDoomLoop(inputs, ctx, llmOutput.toolCalls) === "stop") return "done";
   return handleToolErrorContinuation(inputs, ctx, toolResults);
 }
+async function inspectDoomLoop(inputs, ctx, toolCalls) {
+  if (ctx.doomLoop === void 0) return "continue";
+  const verdict = firstDoomLoopVerdict(ctx.doomLoop, toolCalls);
+  if (verdict.kind === "hard") {
+    ctx.stoppedByDoomLoop = true;
+    await emitAssistantTextStep(
+      inputs,
+      ctx,
+      verdict.message ?? "Stopped: repeated identical tool calls made no progress."
+    );
+    return "stop";
+  }
+  if (verdict.kind === "soft") {
+    ctx.messages.push({ role: "user", content: [{ type: "text", text: verdict.message ?? "" }] });
+  }
+  return "continue";
+}
 var MAX_NUDGE_ATTEMPTS, MAX_STOP_FEEDBACK_ATTEMPTS;
 var init_loop = __esm({
   "src/internal/agent-loop/loop.ts"() {
@@ -8359,6 +8474,7 @@ var init_loop = __esm({
     init_safe_call();
     init_validate_response();
     init_budget_gate();
+    init_doom_loop_tracker();
     init_loop_context_init();
     init_loop_llm_stream();
     init_message_builders();
@@ -10096,6 +10212,124 @@ var init_ollama_native = __esm({
     ollamaSystemText = collapseSystemText;
   }
 });
+function loadJsonrepair() {
+  if (cachedJsonrepair === void 0) {
+    const req = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+    cachedJsonrepair = req("jsonrepair").jsonrepair;
+  }
+  return cachedJsonrepair;
+}
+function isPlainObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function toFiniteNumber(raw) {
+  if (raw === "") return void 0;
+  const n = Number(raw);
+  return Number.isFinite(n) && String(n) === raw ? n : void 0;
+}
+function tryJson(raw, repair) {
+  const t = raw.trimStart();
+  if (!(t.startsWith("{") || t.startsWith("["))) return void 0;
+  try {
+    return JSON.parse(repair ? loadJsonrepair()(t) : t);
+  } catch {
+    return void 0;
+  }
+}
+function heuristicCoerce(raw, repairJson) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw === "null") return null;
+  const n = toFiniteNumber(raw);
+  if (n !== void 0) return n;
+  const json = tryJson(raw, false) ?? (repairJson ? tryJson(raw, true) : void 0);
+  return json === void 0 ? raw : json;
+}
+function coerceCandidates(raw, repairJson) {
+  const out = [];
+  if (raw === "true") out.push(true);
+  else if (raw === "false") out.push(false);
+  else if (raw === "null") out.push(null);
+  const n = toFiniteNumber(raw);
+  if (n !== void 0) out.push(n);
+  const json = tryJson(raw, false) ?? (repairJson ? tryJson(raw, true) : void 0);
+  if (json !== void 0) out.push(json);
+  out.push(raw);
+  return out;
+}
+function objectShape(schema) {
+  const shape = schema?.shape;
+  return shape !== null && typeof shape === "object" ? shape : void 0;
+}
+var cachedJsonrepair;
+var init_coerce = __esm({
+  "src/sanitize/coerce.ts"() {
+  }
+});
+
+// src/sanitize/sanitize-tool-input.ts
+function applyTrim(key, value, ctx) {
+  const trimmed = value.trim();
+  if (trimmed !== value) ctx.notes.push(`trimmed "${key}"`);
+  return trimmed;
+}
+function applyCoerce(key, raw, ctx) {
+  const field = ctx.shape?.[key];
+  let coerced = raw;
+  if (field) {
+    for (const candidate of coerceCandidates(raw, ctx.repairJson)) {
+      if (field.safeParse(candidate).success) {
+        coerced = candidate;
+        break;
+      }
+    }
+  } else {
+    coerced = heuristicCoerce(raw, ctx.repairJson);
+  }
+  if (coerced !== raw) ctx.notes.push(`coerced "${key}"`);
+  return coerced;
+}
+function applyRepair(key, value, ctx) {
+  const repaired = tryJson(value, true);
+  if (repaired === void 0) return value;
+  ctx.notes.push(`repaired json "${key}"`);
+  return repaired;
+}
+function sanitizeString(key, value, ctx) {
+  let out = ctx.trim ? applyTrim(key, value, ctx) : value;
+  if (ctx.coerce && typeof out === "string") out = applyCoerce(key, out, ctx);
+  if (ctx.repairJson && !ctx.coerce && typeof out === "string") out = applyRepair(key, out, ctx);
+  return out;
+}
+function walk(input, ctx, depth) {
+  const out = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (typeof value === "string") out[key] = sanitizeString(key, value, ctx);
+    else if (ctx.deep && depth < ctx.maxDepth && isPlainObject(value))
+      out[key] = walk(value, ctx, depth + 1);
+    else out[key] = value;
+  }
+  return out;
+}
+function sanitizeToolInput(input, options) {
+  if (!isPlainObject(input)) return { value: input, changed: false, notes: [] };
+  const ctx = {
+    trim: options?.trim,
+    coerce: options?.coerce ?? false,
+    repairJson: options?.repairJson ?? false,
+    deep: options?.deep ?? false,
+    maxDepth: options?.maxDepth ?? 8,
+    shape: objectShape(options?.schema),
+    notes: []
+  };
+  const value = walk(input, ctx, 0);
+  return { value, changed: ctx.notes.length > 0, notes: ctx.notes };
+}
+var init_sanitize_tool_input = __esm({
+  "src/sanitize/sanitize-tool-input.ts"() {
+    init_coerce();
+  }
+});
 
 // src/internal/llm/hermes-tool-extract.ts
 function extractHermesToolCalls(content, makeId) {
@@ -10119,13 +10353,14 @@ function parseHermesParams(inner) {
     const key = param[1];
     const value = param[2];
     if (key === void 0 || value === void 0) continue;
-    input[key.trim()] = value.trim();
+    input[key.trim()] = value;
   }
-  return input;
+  return sanitizeToolInput(input, { trim: true }).value;
 }
 var HERMES_BLOCK, HERMES_PARAM;
 var init_hermes_tool_extract = __esm({
   "src/internal/llm/hermes-tool-extract.ts"() {
+    init_sanitize_tool_input();
     HERMES_BLOCK = /<function=\s*([^>\s]+)\s*>([\s\S]*?)<\/tool_call>/g;
     HERMES_PARAM = /<parameter=\s*([^>\s]+)\s*>([\s\S]*?)<\/parameter>/g;
   }
@@ -11324,6 +11559,8 @@ function buildLoopInputs(options, runId, userText) {
     // M1-2: per-send iteration ceiling (validated above). The loop reads
     // inputs.maxIterations (default 8 when unset).
     ...maxIterations !== void 0 ? { maxIterations } : {},
+    // Doom-loop guard config (default on; `false` disables, object tunes thresholds).
+    ...options.sendOptions.doomLoop !== void 0 ? { doomLoop: options.sendOptions.doomLoop } : {},
     // D315-D317 — tool lifecycle hooks (cost tracking + audit + retry/alert)
     ...options.agentOptions.onToolStart !== void 0 ? { onToolStart: options.agentOptions.onToolStart } : {},
     ...options.agentOptions.onToolEnd !== void 0 ? { onToolEnd: options.agentOptions.onToolEnd } : {},
@@ -11472,6 +11709,7 @@ var init_real_local_run = __esm({
         if (output.usage !== void 0) this.script.usage = output.usage;
         if (output.cost !== void 0) this.script.cost = output.cost;
         if (output.stoppedAtIterationLimit === true) this.script.stoppedAtIterationLimit = true;
+        if (output.stoppedByDoomLoop === true) this.script.stoppedByDoomLoop = true;
         if (output.error !== void 0 && this.script.errorDetail === void 0) {
           this.script.errorDetail = {
             message: output.error.message,
@@ -14463,6 +14701,7 @@ function isEmptyRound(result) {
   return (result.result ?? "").trim() === "";
 }
 function classifyRound(result, round, maxRounds, emptyStreak) {
+  if (result.stoppedByDoomLoop === true) return "no_progress";
   if (result.stoppedAtIterationLimit !== true) return "done";
   if (isEmptyRound(result) && emptyStreak >= 1) return "no_progress";
   if (round >= maxRounds) return "step_limit";