@theokit/sdk 2.14.0 → 2.15.1

package/dist/cron.d.cts

@@ -1,2 +1,2 @@
-import './run-TMdc7gmo.cjs';
-export { K as Cron } from './cron-CpxLdAXc.cjs';
+import './run-DXy_MVwz.cjs';
+export { K as Cron } from './cron-BxLSz1UH.cjs';

package/dist/cron.d.ts

@@ -1,2 +1,2 @@
-import './run-TMdc7gmo.js';
-export { K as Cron } from './cron-CL_9nfhQ.js';
+import './run-DXy_MVwz.js';
+export { K as Cron } from './cron-DcaoP7aW.js';

package/dist/cron.js

@@ -1455,6 +1455,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";
@@ -4492,6 +4493,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;
 }
 
 // src/internal/runtime/cloud/cloud-run.ts
@@ -8273,6 +8275,93 @@ function evaluateBudgetGate(tracker) {
   }
 }
 
+// src/internal/agent-loop/doom-loop-tracker.ts
+init_errors();
+function createDoomLoopTracker(option) {
+  if (option === false) return void 0;
+  return new DoomLoopTracker(option);
+}
+var DEFAULT_CONFIG = { softThreshold: 3, hardThreshold: 5 };
+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}`;
+}
+var 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;
+  }
+};
+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;
+}
+
 // src/internal/budget/usage-accumulator.ts
 var UsageAccumulator = class {
   input = 0;
@@ -8453,6 +8542,7 @@ async function initLoopContext(inputs) {
     tools,
     finalText: "",
     finalStatus: "finished",
+    doomLoop: createDoomLoopTracker(inputs.doomLoop),
     usage: new UsageAccumulator(),
     nudgeAttempts: 0,
     stopFeedbackAttempts: 0,
@@ -9477,6 +9567,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 });
     }
@@ -9503,7 +9594,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) {
@@ -9662,8 +9754,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";
+}
 
 // src/internal/llm/fallback-client.ts
 init_errors();
@@ -11065,11 +11175,16 @@ function sanitizeToolInput(input, options) {
 // src/internal/llm/hermes-tool-extract.ts
 var HERMES_BLOCK = /<function=\s*([^>\s]+)\s*>([\s\S]*?)<\/tool_call>/g;
 var HERMES_PARAM = /<parameter=\s*([^>\s]+)\s*>([\s\S]*?)<\/parameter>/g;
-function extractHermesToolCalls(content, makeId) {
+function extractHermesToolCalls(content, makeId, allowedToolNames) {
+  const isPromoted = (name) => name.length > 0 && (allowedToolNames === void 0 || allowedToolNames.has(name));
   const toolCalls = [];
+  const droppedNames = [];
   for (const block of content.matchAll(HERMES_BLOCK)) {
     const name = (block[1] ?? "").trim();
-    if (name.length === 0) continue;
+    if (!isPromoted(name)) {
+      if (name.length > 0 && allowedToolNames !== void 0) droppedNames.push(name);
+      continue;
+    }
     toolCalls.push({
       type: "tool_use",
       id: makeId(),
@@ -11077,8 +11192,11 @@ function extractHermesToolCalls(content, makeId) {
       input: parseHermesParams(block[2] ?? "")
     });
   }
-  const residualText = toolCalls.length === 0 ? content : content.replace(HERMES_BLOCK, "").trim();
-  return { toolCalls, residualText };
+  const residualText = toolCalls.length === 0 ? content : content.replace(
+    HERMES_BLOCK,
+    (full, rawName) => isPromoted((rawName ?? "").trim()) ? "" : full
+  ).trim();
+  return { toolCalls, residualText, droppedNames };
 }
 function parseHermesParams(inner) {
   const input = {};
@@ -11162,7 +11280,10 @@ var OpenAIClient = class {
     }
     const accumulator = new OpenAIStreamAccumulator(
       this.options.extractToolCallsFromContent ?? false,
-      providerId
+      providerId,
+      // R5: request-scoped allowlist — leaked recovery only promotes a block whose name is a tool the
+      // model was actually given. Empty set (no tools) recovers nothing.
+      new Set(request.tools?.map((tool) => tool.name) ?? [])
     );
     for await (const record of parseSseStream(response.body, signal)) {
       if (record.data === "[DONE]") break;
@@ -11192,13 +11313,18 @@ var OpenAIStreamAccumulator = class {
   /**
    * @param extractFromContent opt-in leaked-dialect safe-parse (theokit#58). Default false.
    * @param providerName provider id, used only to label the recovery log line.
+   * @param allowedToolNames R5 request-scoped allowlist — built from `request.tools` at `stream()`;
+   *   leaked recovery in `finish()` only promotes a block whose name is in this set. `undefined`
+   *   (direct construction) recovers all (back-compat); an empty set recovers nothing.
    */
-  constructor(extractFromContent = false, providerName = "openai") {
+  constructor(extractFromContent = false, providerName = "openai", allowedToolNames) {
     this.extractFromContent = extractFromContent;
     this.providerName = providerName;
+    this.allowedToolNames = allowedToolNames;
   }
   extractFromContent;
   providerName;
+  allowedToolNames;
   text = "";
   stopReason = "end_turn";
   inputTokens;
@@ -11269,7 +11395,8 @@ var OpenAIStreamAccumulator = class {
     if (this.extractFromContent && toolCalls.length === 0) {
       const recovered = extractHermesToolCalls(
         this.text,
-        () => `hermes-${globalThis.crypto.randomUUID()}`
+        () => `hermes-${globalThis.crypto.randomUUID()}`,
+        this.allowedToolNames
       );
       if (recovered.toolCalls.length > 0) {
         toolCalls.push(...recovered.toolCalls);
@@ -11277,6 +11404,12 @@ var OpenAIStreamAccumulator = class {
         stopReason = "tool_use";
         process.stderr.write(
           `[theokit-sdk] recovered ${recovered.toolCalls.length} leaked tool call(s) from assistant content (provider="${this.providerName}", names=${recovered.toolCalls.map((c) => c.name).join(",")})
+`
+        );
+      }
+      if (recovered.droppedNames.length > 0) {
+        process.stderr.write(
+          `[theokit-sdk] dropped ${recovered.droppedNames.length} leaked block(s) whose name is not a tool in the request (provider="${this.providerName}", names=${recovered.droppedNames.join(",")})
 `
         );
       }
@@ -12208,6 +12341,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 } : {},
@@ -12340,6 +12475,7 @@ var RealLocalRun = class extends FixtureRunBase {
     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,