@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-GRHOXDKB.js

@@ -0,0 +1,1104 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  GATEWAY_SCHEMA_RUNTIME_ID,
+  RESPONSE_SCHEMA_RUNTIME_ID,
+  responseSchemaDialectFor
+} from "./chunk-OQ2EOAHA.js";
+import {
+  hashToolCall
+} from "./chunk-7QXCO3AF.js";
+import {
+  isDispositionedToolResultError
+} from "./chunk-OPD7GL6F.js";
+import {
+  engineStreamSimple,
+  resolvedRequestContext
+} from "./chunk-L7G7K4I2.js";
+import {
+  classify
+} from "./chunk-VYRQHORQ.js";
+import {
+  protectArtifact,
+  protectedArtifactMutationBlockReason
+} from "./chunk-P4GNZPXO.js";
+import {
+  resolveReadPath
+} from "./chunk-C2CPOIH2.js";
+import {
+  ToolNames
+} from "./chunk-V4XJWDHR.js";
+import {
+  GUARDRAIL_DEFAULTS,
+  resolveGuardrail,
+  workerSynthesisReserveBlockReason,
+  workerSynthesisReserveDirective,
+  workerToolCallCapExceededReason,
+  workerToolCallCapSynthesisReason
+} from "./chunk-C27U2TYG.js";
+import {
+  BusChannels
+} from "./chunk-PS6JAWJZ.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/safety/protected-artifacts-registration.ts
+init_esm_shims();
+var PROTECTED_ARTIFACTS_REGISTRATION_ID = "guard.protected-artifacts";
+function createProtectedArtifactsRegistration(options = {}) {
+  let state = cloneState(options.initialState ?? { artifacts: [] });
+  let health = { kind: "healthy" };
+  const markDegraded = (reason) => {
+    if (health.kind === "degraded") return;
+    const degraded = {
+      kind: "degraded",
+      reason,
+      since: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    health = degraded;
+    try {
+      options.onDurabilityFailure?.({ ...degraded });
+    } catch {
+    }
+  };
+  const absorb = (input, context) => {
+    for (const effect of context?.priorEffects ?? []) {
+      if (effect.kind !== "protect_path") continue;
+      const artifact = artifactFromEffect(effect, input);
+      state = protectArtifact(state, artifact);
+      try {
+        emitProtect(options.onProtect, artifact, input);
+      } catch (error) {
+        markDegraded(`protected artifact persistence failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  };
+  const blockReason = (input) => {
+    const toolName = input.toolName ?? "";
+    const args = input.toolArgs !== void 0 ? { ...input.toolArgs } : void 0;
+    if (health.kind === "degraded") {
+      const actionClass = classify({ tool: toolName, ...args !== void 0 ? { args } : {} }).actionClass;
+      if (actionClass !== "read") {
+        return `protected artifact durability degraded: ${health.reason}; non-read tool '${toolName}' is blocked until protection state is trustworthy`;
+      }
+    }
+    return protectedArtifactMutationBlockReason(state, toolName, args);
+  };
+  return {
+    id: PROTECTED_ARTIFACTS_REGISTRATION_ID,
+    description: "blocks mutations of protected paths and absorbs protect_path effects",
+    hooks: ["before_tool", "after_tool"],
+    state: () => cloneState(state),
+    health: () => ({ ...health }),
+    replaceState(next) {
+      state = cloneState(next);
+      health = { kind: "healthy" };
+    },
+    markDegraded,
+    evaluate(input, context) {
+      absorb(input, context);
+      if (input.hook !== "before_tool") return [];
+      const reason = blockReason(input);
+      if (reason === null) return [];
+      return [{ kind: "block_tool", reason, severity: "hard-block" }];
+    }
+  };
+}
+function artifactFromEffect(effect, input) {
+  const artifact = {
+    path: effect.path,
+    protectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    reason: effect.reason,
+    source: "middleware"
+  };
+  const validationCommand = input.metadata?.validationCommand;
+  if (typeof validationCommand === "string" && validationCommand.length > 0) {
+    artifact.validationCommand = validationCommand;
+    if (input.metadata?.validationExitCode === 0) artifact.validationExitCode = 0;
+  }
+  return artifact;
+}
+function emitProtect(sink, artifact, input) {
+  if (!sink) return;
+  const event = {
+    kind: "protect",
+    artifact: cloneArtifact(artifact),
+    toolName: input.toolName ?? ""
+  };
+  if (input.runId !== void 0) event.runId = input.runId;
+  if (input.sessionId !== void 0) event.sessionId = input.sessionId;
+  if (input.turnId !== void 0) event.turnId = input.turnId;
+  if (input.toolCallId !== void 0) event.toolCallId = input.toolCallId;
+  if (input.correlationId !== void 0) event.correlationId = input.correlationId;
+  sink(event);
+}
+function cloneState(state) {
+  let next = { artifacts: [] };
+  for (const artifact of state.artifacts) {
+    next = protectArtifact(next, artifact);
+  }
+  return next;
+}
+function cloneArtifact(artifact) {
+  const clone = {
+    path: artifact.path,
+    protectedAt: artifact.protectedAt,
+    reason: artifact.reason,
+    source: artifact.source
+  };
+  if (artifact.validationCommand !== void 0) clone.validationCommand = artifact.validationCommand;
+  if (artifact.validationExitCode !== void 0) clone.validationExitCode = artifact.validationExitCode;
+  return clone;
+}
+
+// src/engine/loop-guard.ts
+init_esm_shims();
+var LOOP_GUARD_REGISTRATION_ID = "guard.loop";
+var INTERACTIVE_LOOP_BLOCK_BUDGET = 2;
+var WORKER_LOOP_BLOCK_CALLS_PER_BLOCK = 10;
+function workerLoopBlockBudget(toolCalls) {
+  if (!Number.isSafeInteger(toolCalls) || toolCalls <= 0) return INTERACTIVE_LOOP_BLOCK_BUDGET;
+  return Math.max(INTERACTIVE_LOOP_BLOCK_BUDGET, Math.ceil(toolCalls / WORKER_LOOP_BLOCK_CALLS_PER_BLOCK));
+}
+var LOOP_SYNTHESIS_BACKSTOP_DENIALS = 2;
+var WIDE_BATCH_DENIAL_FLOOR = 32;
+var DEFAULT_WORKER_TOOL_CALL_CAP = GUARDRAIL_DEFAULTS.workerToolCallCap;
+var DEFAULT_ORCH_TURN_TOOL_CALL_BUDGET = GUARDRAIL_DEFAULTS.turnToolCallBudget;
+var ORCH_TURN_TOOL_CALL_HARD_MARGIN = 15;
+var LOOP_GUARD_TURN_LIMIT = 32;
+var SUCCEEDED_FINGERPRINT_LIMIT = 128;
+var NO_TURN_BUCKET = "no-turn";
+var SIZE_ONLY_ARG_KEYS = /* @__PURE__ */ new Set(["limit", "offset", "max_bytes", "context"]);
+var RESULT_STAGNATION_THRESHOLD = 3;
+var CROSS_ARGUMENT_RESULT_MIN_BYTES = 64;
+function stagnationFingerprint(tool, args) {
+  const reduced = {};
+  for (const [key, value] of Object.entries(args ?? {})) {
+    if (!SIZE_ONLY_ARG_KEYS.has(key)) reduced[key] = value;
+  }
+  return hashToolCall(tool, reduced);
+}
+function stagnationBlockReason(tool, identicalResults) {
+  return `loop detected: the last ${identicalResults} ${tool} calls returned byte-identical results even though size arguments (limit/offset) changed. Raising them is not producing new information. Re-read the result above, change the query or tool, or answer from what you have.`;
+}
+function crossArgumentResultMessage(tool, distinctArguments) {
+  return `loop guard: ${distinctArguments} distinct ${tool} arguments returned the same substantial result this turn. The tool may be ignoring an argument; re-read the result, change tools, or answer from what you have.`;
+}
+function loopBlockBaseReason(tool, repeatCount, priorSuccesses) {
+  const evidence = priorSuccesses > 0 ? `This exact call already succeeded ${priorSuccesses} ${priorSuccesses === 1 ? "time" : "times"} this run; its result is already in the conversation above \u2014 re-read that result before calling tools again. ` : "";
+  return `loop detected: ${tool} was called ${repeatCount} times with identical arguments among this turn's recent tool calls. Repeating the exact call is blocked. ${evidence}Change strategy: vary the arguments, use a different tool, or explain what new information you expect before retrying.`;
+}
+function isLockedSynthesisFallbackOnly(message) {
+  if (!message || typeof message !== "object" || message.role !== "assistant") return false;
+  const content = message.content;
+  if (!Array.isArray(content)) return false;
+  const text = content.filter((block) => block?.type === "text" && typeof block.text === "string").map((block) => block.text).join("").trim();
+  return text === lockedSynthesisFallbackText();
+}
+var LOCKED_SYNTHESIS_REPROMPT_TOOL = "clio_synthesis_reprompt";
+function lockedSynthesisSystemPrompt(systemPrompt, requiredResult) {
+  return [
+    systemPrompt,
+    "# Current execution phase: final synthesis",
+    "Tools are disabled for the rest of this run. Earlier instructions to use tools apply only to the completed tool phase. Do not emit tool calls or tool-call markup. Return the final result now using the evidence already observed; preserve all safety rules and the required result format. Do not invent missing evidence.",
+    ...requiredResult ? [`Required terminal result: ${requiredResult}`] : []
+  ].join("\n\n");
+}
+function lockedSynthesisRepromptMessages(attempt, origin, requiredResult) {
+  const id = `clio-synthesis-reprompt-${attempt}`;
+  const timestamp = Date.now();
+  return [
+    {
+      role: "assistant",
+      content: [{ type: "toolCall", id, name: LOCKED_SYNTHESIS_REPROMPT_TOOL, arguments: {} }],
+      stopReason: "toolUse",
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+      },
+      ...origin,
+      timestamp
+    },
+    {
+      role: "toolResult",
+      toolCallId: id,
+      toolName: LOCKED_SYNTHESIS_REPROMPT_TOOL,
+      content: [
+        {
+          type: "text",
+          text: "Your previous reply contained only tool-call markup, which cannot run: tool calls are disabled for the rest of this run. Everything you gathered is already in the conversation above. Write the final answer now in the required result format (JSON when a result contract requires it; otherwise prose), with no tool-call markup of any kind." + (requiredResult ? `
+Required terminal result: ${requiredResult}` : "")
+        }
+      ],
+      isError: true,
+      timestamp
+    }
+  ];
+}
+function synthesisLockoutDirective() {
+  return "loop guard: this turn reached its tool-call limit after repeated identical calls, so tool calls are now disabled for the rest of this turn. Everything you retrieved is already in the conversation above. Answer now from what you have gathered, preserving the required result format (JSON for a JSON result contract; otherwise prose). Do not write tool-call markup such as <tool_call> blocks; tool calls are disabled and will not run.";
+}
+function synthesisBackstopReason(tool) {
+  return `loop guard: tool calls stayed disabled and ${tool} was called again instead of answering, so the turn is being stopped. Summarize what you found for the operator.`;
+}
+function workerExplorationSynthesisDirective(limit) {
+  return `worker exploration budget reached (${limit}); exploration tools are now disabled for this run. Return the required result format from the evidence already gathered: keep JSON when the result contract requires JSON, and keep citations grounded in actual reads. Do not retry or substitute another tool call.`;
+}
+function disallowedToolsText(deliveryTools) {
+  const candidates = ["code_nav", "ls", "grep", "find", "context", "git", "shell commands"];
+  const excluded = candidates.filter((tool) => !deliveryTools.includes(tool));
+  return excluded.join(", ");
+}
+function workerLiveReadReserveDirective(remaining, deliveryTools) {
+  const admitted = deliveryTools.length > 0 ? `read and ${deliveryTools.join("/")}` : "the read tool";
+  const finish = deliveryTools.length > 0 ? `Finish the work: re-read what you will cite and write it with ${deliveryTools.join(" or ")}.` : "Read a specific live file needed for the handoff.";
+  return `worker live-read reserve: broad orientation is complete and ${remaining} ${remaining === 1 ? "call remains" : "calls remain"}. Only ${admitted} ${deliveryTools.length > 0 ? "are" : "is"} admitted now. ${finish} Do not substitute ${disallowedToolsText(deliveryTools)}.`;
+}
+function workerDeliveryOnlyDirective(limit, deliveryTools) {
+  return `worker discovery budget reached (${limit}); exploration tools are disabled for the rest of this run. Only read and ${deliveryTools.join("/")} are admitted now. Write what you have with ${deliveryTools.join(" or ")} and finish. Do not substitute ${disallowedToolsText(deliveryTools)}.`;
+}
+var DEAD_TOOL_CALL_MARKUP_PATTERNS = [
+  /<tool_call>[\s\S]*?<\/tool_call>/gi,
+  /<function=[\w.-]+>[\s\S]*?<\/function>/gi,
+  /<tool_call>\s*(?:<function=|[{[])[\s\S]*$/i,
+  /<function=[\w.-]+>[\s\S]*$/i
+];
+function stripDeadToolCallMarkup(text) {
+  let out = text;
+  for (const pattern of DEAD_TOOL_CALL_MARKUP_PATTERNS) {
+    out = out.replace(pattern, "");
+  }
+  return out === text ? text : out.trim();
+}
+function lockedSynthesisFallbackText() {
+  return "[Clio Coder] loop guard: tool calls were disabled for the rest of this turn, but the reply contained only tool-call markup, which cannot run and was removed. Ask me to continue with a different approach, or narrow the request.";
+}
+function sanitizeLockedSynthesisMessage(message) {
+  if (!message || typeof message !== "object" || message.role !== "assistant") return false;
+  const record = message;
+  const stopReason = record.stopReason;
+  if (stopReason !== void 0 && stopReason !== "stop" && stopReason !== "length") return false;
+  if (!Array.isArray(record.content)) return false;
+  const blocks = record.content;
+  if (blocks.some((block) => block?.type === "toolCall")) return false;
+  let changed = false;
+  for (const block of blocks) {
+    if (block?.type !== "text" || typeof block.text !== "string") continue;
+    const stripped = stripDeadToolCallMarkup(block.text);
+    if (stripped !== block.text) {
+      block.text = stripped;
+      changed = true;
+    }
+  }
+  if (!changed) return false;
+  const remaining = blocks.filter((block) => block?.type === "text" && typeof block.text === "string").map((block) => block.text).join("").trim();
+  if (remaining.length === 0) {
+    const firstText = blocks.find(
+      (block) => block?.type === "text" && typeof block.text === "string"
+    );
+    if (firstText) firstText.text = lockedSynthesisFallbackText();
+    else blocks.push({ type: "text", text: lockedSynthesisFallbackText() });
+  }
+  return true;
+}
+function isLoopGuardSynthesisBackstopReason(reason) {
+  return /^loop guard: tool calls stayed disabled and .+ was called again instead of answering/.test(reason);
+}
+function readOrchTurnToolCallBudget() {
+  const soft = resolveGuardrail("turnToolCallBudget");
+  return { soft, hard: soft + ORCH_TURN_TOOL_CALL_HARD_MARGIN };
+}
+function createLoopGuardRegistration(options) {
+  const budget = options.turnBlockBudget ?? INTERACTIVE_LOOP_BLOCK_BUDGET;
+  const cap = options.toolBudgetAdvisory ? void 0 : options.toolCallCap;
+  let advisoryEmitted = false;
+  let softLimit = !options.toolBudgetAdvisory && options.toolCallSoftLimit !== void 0 && Number.isSafeInteger(options.toolCallSoftLimit) && options.toolCallSoftLimit > 0 && (cap === void 0 || options.toolCallSoftLimit <= cap) ? options.toolCallSoftLimit : void 0;
+  const synthesisLockout = options.turnSynthesisLockout === true;
+  let softReadReserve = options.toolCallSoftReadReserve ?? 0;
+  let softReadReserveThreshold = softLimit !== void 0 && softReadReserve > 0 && softLimit > softReadReserve ? softLimit - softReadReserve : null;
+  const deliveryTools = [...new Set(options.deliveryTools ?? [])];
+  const reserveAdmits = (tool) => isReserveAdmittedTool(tool, deliveryTools);
+  let softAdmittedCount = 0;
+  let softReadReserveEntered = false;
+  let reserveDenials = { denials: 0 };
+  let deniedAttempts = 0;
+  const denialBudget = options.toolCallCap === void 0 ? void 0 : Math.max(options.toolCallCap, WIDE_BATCH_DENIAL_FLOOR);
+  const boundRunDenials = (effects, input) => {
+    if (denialBudget === void 0 || !effects.some((effect) => effect.kind === "block_tool")) return effects;
+    deniedAttempts += 1;
+    if (deniedAttempts <= denialBudget) return effects;
+    return [{ kind: "block_tool", reason: synthesisBackstopReason(input.toolName ?? "unknown"), severity: "hard-block" }];
+  };
+  const reserve = options.toolCallReserve ?? 0;
+  const reserveThreshold = cap !== void 0 && reserve > 0 && cap > reserve ? cap - reserve : null;
+  let reserveDirectiveEmitted = false;
+  const blocksByTurn = /* @__PURE__ */ new Map();
+  const callsByTurn = /* @__PURE__ */ new Map();
+  const mutationEpochByTurn = /* @__PURE__ */ new Map();
+  const lockoutByTurn = /* @__PURE__ */ new Map();
+  let capLockout = null;
+  let softLockout = null;
+  const succeededFingerprints = /* @__PURE__ */ new Map();
+  const stagnationByTurn = /* @__PURE__ */ new Map();
+  const eofByTurn = /* @__PURE__ */ new Map();
+  const readCoverage = /* @__PURE__ */ new Map();
+  const redundantReadsByTurn = /* @__PURE__ */ new Map();
+  const crossArgumentResultsByTurn = /* @__PURE__ */ new Map();
+  let count = 0;
+  const enterSoftReadReserve = () => {
+    if (softReadReserveEntered) return;
+    softReadReserveEntered = true;
+    options.onSoftReadReserve?.();
+  };
+  const bumpBoundedCounter = (store, key, limit = LOOP_GUARD_TURN_LIMIT) => {
+    if (!store.has(key)) {
+      while (store.size >= limit) {
+        const oldest = store.keys().next().value;
+        if (typeof oldest !== "string") break;
+        store.delete(oldest);
+      }
+    }
+    const next = (store.get(key) ?? 0) + 1;
+    store.set(key, next);
+    return next;
+  };
+  const resultCarriesEvidence = (details) => {
+    const observation = details?.observation;
+    if (observation === null || typeof observation !== "object" || Array.isArray(observation)) return true;
+    const record = observation;
+    return !(record.truncated === true && record.shownCount === 0);
+  };
+  const recordSuccessfulResult = (input) => {
+    if (input.metadata?.resultKind !== "ok") return;
+    if (input.toolName === ToolNames.Write || input.toolName === ToolNames.Edit) {
+      bumpBoundedCounter(mutationEpochByTurn, input.turnId ?? NO_TURN_BUCKET);
+      readCoverage.clear();
+      redundantReadsByTurn.clear();
+    }
+    if (!resultCarriesEvidence(input.toolResultDetails)) return;
+    const tool = input.toolName;
+    if (typeof tool !== "string" || tool.length === 0) return;
+    bumpBoundedCounter(succeededFingerprints, hashToolCall(tool, input.toolArgs ?? {}), SUCCEEDED_FINGERPRINT_LIMIT);
+  };
+  const recordResultForStagnation = (input) => {
+    const turnKey = input.turnId ?? NO_TURN_BUCKET;
+    const tool = input.toolName;
+    const resultFingerprint = input.metadata?.resultFingerprint;
+    if (typeof tool !== "string" || tool.length === 0 || input.metadata?.resultKind !== "ok" || typeof resultFingerprint !== "string") {
+      stagnationByTurn.delete(turnKey);
+      return;
+    }
+    const reducedFingerprint = stagnationFingerprint(tool, input.toolArgs);
+    const previous = stagnationByTurn.get(turnKey);
+    if (previous !== void 0 && previous.reducedFingerprint === reducedFingerprint && previous.resultFingerprint === resultFingerprint) {
+      previous.streak += 1;
+      return;
+    }
+    if (!stagnationByTurn.has(turnKey)) {
+      while (stagnationByTurn.size >= LOOP_GUARD_TURN_LIMIT) {
+        const oldest = stagnationByTurn.keys().next().value;
+        if (typeof oldest !== "string") break;
+        stagnationByTurn.delete(oldest);
+      }
+    }
+    stagnationByTurn.set(turnKey, { reducedFingerprint, resultFingerprint, streak: 1 });
+  };
+  const crossArgumentResultEffects = (input) => {
+    const turnKey = input.turnId ?? NO_TURN_BUCKET;
+    const tool = input.toolName;
+    const resultFingerprint = input.metadata?.resultFingerprint;
+    const resultBytes = input.metadata?.resultBytes;
+    if (typeof tool !== "string" || tool.length === 0 || input.metadata?.actionClass !== "read" || input.metadata?.resultKind !== "ok" || typeof resultFingerprint !== "string" || typeof resultBytes !== "number" || resultBytes < CROSS_ARGUMENT_RESULT_MIN_BYTES || !resultCarriesEvidence(input.toolResultDetails)) {
+      crossArgumentResultsByTurn.delete(turnKey);
+      return [];
+    }
+    const argumentFingerprint = stagnationFingerprint(tool, input.toolArgs);
+    const previous = crossArgumentResultsByTurn.get(turnKey);
+    if (previous?.tool === tool && previous.resultFingerprint === resultFingerprint) {
+      if (previous.warned) return [];
+      previous.argumentFingerprints.add(argumentFingerprint);
+      if (previous.argumentFingerprints.size >= RESULT_STAGNATION_THRESHOLD) {
+        previous.warned = true;
+        return [
+          {
+            kind: "annotate_tool_result",
+            message: crossArgumentResultMessage(tool, previous.argumentFingerprints.size),
+            severity: "warn"
+          }
+        ];
+      }
+      return [];
+    }
+    if (!crossArgumentResultsByTurn.has(turnKey)) {
+      while (crossArgumentResultsByTurn.size >= LOOP_GUARD_TURN_LIMIT) {
+        const oldest = crossArgumentResultsByTurn.keys().next().value;
+        if (typeof oldest !== "string") break;
+        crossArgumentResultsByTurn.delete(oldest);
+      }
+    }
+    crossArgumentResultsByTurn.set(turnKey, {
+      tool,
+      resultFingerprint,
+      argumentFingerprints: /* @__PURE__ */ new Set([argumentFingerprint]),
+      warned: false
+    });
+    return [];
+  };
+  const bumpTurnBlocks = (turnId) => bumpBoundedCounter(blocksByTurn, turnId);
+  const enterLockout = (input, turnKey, state) => {
+    if (!lockoutByTurn.has(turnKey)) {
+      while (lockoutByTurn.size >= LOOP_GUARD_TURN_LIMIT) {
+        const oldest = lockoutByTurn.keys().next().value;
+        if (typeof oldest !== "string") break;
+        lockoutByTurn.delete(oldest);
+      }
+    }
+    lockoutByTurn.set(turnKey, {
+      ...state,
+      denials: 0,
+      ...input.correlationId !== void 0 ? { correlationId: input.correlationId } : {}
+    });
+  };
+  const reachesLockoutBackstop = (state, input) => {
+    if (input.correlationId !== void 0 && state.correlationId === input.correlationId) return false;
+    state.denials += 1;
+    if (input.correlationId !== void 0) state.correlationId = input.correlationId;
+    else delete state.correlationId;
+    return state.denials > LOOP_SYNTHESIS_BACKSTOP_DENIALS;
+  };
+  const emitLoopBlocked = (input, info, at) => {
+    const payload = {
+      tool: info.tool,
+      repeatCount: info.repeatCount,
+      blocksThisTurn: info.blocksThisTurn,
+      budget,
+      interrupted: info.disposition === "stop",
+      disposition: info.disposition,
+      at,
+      ...input.turnId !== void 0 ? { turnId: input.turnId } : {}
+    };
+    options.bus?.emit(BusChannels.LoopBlocked, payload);
+  };
+  const emitBudgetEvent = (input, turnBudget, callsThisTurn, interrupted, at) => {
+    const payload = {
+      tool: input.toolName ?? "unknown",
+      callsThisTurn,
+      softBudget: turnBudget.soft,
+      hardCeiling: turnBudget.hard,
+      interrupted,
+      at,
+      ...input.turnId !== void 0 ? { turnId: input.turnId } : {}
+    };
+    options.bus?.emit(BusChannels.ToolBudgetExceeded, payload);
+  };
+  const evaluateTurnBudget = (input, now) => {
+    const budgetSource = options.turnToolCallBudget;
+    const turnBudget = typeof budgetSource === "function" ? budgetSource() : budgetSource;
+    if (turnBudget === void 0) return null;
+    const turnKey = input.turnId ?? NO_TURN_BUCKET;
+    const callsThisTurn = bumpBoundedCounter(callsByTurn, turnKey);
+    if (callsThisTurn >= turnBudget.hard) {
+      if (callsThisTurn === turnBudget.hard) emitBudgetEvent(input, turnBudget, callsThisTurn, true, now);
+      return [
+        {
+          kind: "block_tool",
+          reason: `tool-call budget exhausted: ${callsThisTurn} tool calls in this turn reached the hard ceiling (${turnBudget.hard}); the turn is being stopped. Summarize what you found and wait for the operator.`,
+          severity: "hard-block"
+        }
+      ];
+    }
+    if (callsThisTurn >= turnBudget.soft) {
+      if (callsThisTurn === turnBudget.soft) emitBudgetEvent(input, turnBudget, callsThisTurn, false, now);
+      return [
+        {
+          kind: "block_tool",
+          reason: `tool-call budget: you have made ${callsThisTurn} tool calls in this turn (soft budget ${turnBudget.soft}). Every further tool call this turn will be blocked, so do not retry this call and do not substitute another one. Summarize what you have found so far in the required result format, state the single next step you propose, and wait for the operator.`,
+          severity: "hard-block"
+        }
+      ];
+    }
+    return null;
+  };
+  const blockAsLoop = (input, turnKey, tool, repeatCount, baseReason, now) => {
+    const blocksThisTurn = bumpTurnBlocks(turnKey);
+    const reachedBudget = blocksThisTurn >= budget;
+    if (synthesisLockout && reachedBudget) {
+      enterLockout(input, turnKey, { tool, repeatCount, blocksThisTurn });
+      options.onSynthesisLockout?.();
+      emitLoopBlocked(input, { tool, repeatCount, blocksThisTurn, disposition: "lockout" }, now);
+      return [{ kind: "block_tool", reason: synthesisLockoutDirective(), severity: "hard-block" }];
+    }
+    emitLoopBlocked(input, { tool, repeatCount, blocksThisTurn, disposition: reachedBudget ? "stop" : "block" }, now);
+    const reason = reachedBudget ? `${baseReason} Loop budget exhausted (${blocksThisTurn} blocks this turn); the agent is being stopped.` : baseReason;
+    return [{ kind: "block_tool", reason, severity: "hard-block" }];
+  };
+  const readCoverageEffects = (input) => {
+    const turnKey = input.turnId ?? NO_TURN_BUCKET;
+    const reset = () => {
+      redundantReadsByTurn.delete(turnKey);
+      return [];
+    };
+    const details = input.toolResultDetails;
+    const file = details?.file;
+    const observation = details?.observation;
+    const path = input.toolArgs?.path;
+    const offset = input.toolArgs?.offset ?? 1;
+    const resultBytes = input.metadata?.resultBytes;
+    const deliveredCap = Math.min(options.readResultMaxBytes ?? 0, resolveGuardrail("readMaxBytes"));
+    if (!Number.isFinite(deliveredCap) || deliveredCap <= 0 || typeof resultBytes !== "number" || !Number.isFinite(resultBytes) || resultBytes > deliveredCap || input.toolName !== ToolNames.Read || input.metadata?.resultKind !== "ok" || typeof path !== "string" || input.toolArgs?.tail !== void 0 || typeof offset !== "number" || !Number.isSafeInteger(offset) || offset < 1 || typeof file?.bytes !== "number" || !Number.isFinite(file.bytes) || typeof file.mtimeMs !== "number" || !Number.isFinite(file.mtimeMs) || details?.fileChange !== void 0 || observation?.tool !== ToolNames.Read || observation.unit !== "lines" || observation.format !== "text" || typeof observation.shownCount !== "number" || !Number.isSafeInteger(observation.shownCount) || observation.shownCount <= 0)
+      return reset();
+    const end = offset + observation.shownCount - 1;
+    const coveredEnd = end - (observation.truncated === true ? 1 : 0);
+    if (!Number.isSafeInteger(end)) return reset();
+    let canonicalPath;
+    try {
+      canonicalPath = resolveReadPath(path);
+    } catch {
+      return reset();
+    }
+    const key = `${turnKey}\0${canonicalPath}\0${input.toolArgs?.line_numbers === true}`;
+    let entry = readCoverage.get(key);
+    if (!entry || entry.bytes !== file.bytes || entry.mtimeMs !== file.mtimeMs) {
+      entry = { bytes: file.bytes, mtimeMs: file.mtimeMs, ranges: [] };
+    }
+    const redundant = entry.ranges.some(([start, stop]) => start <= offset && stop >= end);
+    const ranges = [...entry.ranges];
+    if (coveredEnd >= offset) ranges.push([offset, coveredEnd]);
+    ranges.sort((a, b) => a[0] - b[0]);
+    entry.ranges = [];
+    for (const range of ranges) {
+      const last = entry.ranges.at(-1);
+      if (last && range[0] <= last[1] + 1) last[1] = Math.max(last[1], range[1]);
+      else entry.ranges.push(range);
+    }
+    entry.ranges = entry.ranges.slice(-SUCCEEDED_FINGERPRINT_LIMIT);
+    readCoverage.delete(key);
+    if (readCoverage.size >= SUCCEEDED_FINGERPRINT_LIMIT) {
+      const oldest = readCoverage.keys().next().value;
+      if (oldest !== void 0) readCoverage.delete(oldest);
+    }
+    readCoverage.set(key, entry);
+    if (!redundant) return reset();
+    const streak = bumpBoundedCounter(redundantReadsByTurn, turnKey);
+    if (streak < RESULT_STAGNATION_THRESHOLD || lockoutByTurn.has(turnKey)) return [];
+    const reason = `loop detected: ${streak} consecutive read calls returned only source lines already observed from unchanged files. Reuse the evidence above and return the required result format; do not page through it again.`;
+    return blockAsLoop(input, turnKey, ToolNames.Read, streak, reason, options.now?.() ?? Date.now()).map(
+      (effect) => effect.kind === "block_tool" ? { kind: "annotate_tool_result", message: effect.reason, severity: "warn" } : effect
+    );
+  };
+  const readEofEffects = (input) => {
+    const turnKey = input.turnId ?? NO_TURN_BUCKET;
+    const details = input.toolResultDetails;
+    const file = details?.file;
+    if (input.toolName !== ToolNames.Read || input.metadata?.resultKind !== "error" || details?.code !== "read_past_eof" || typeof input.toolArgs?.path !== "string" || typeof file?.bytes !== "number" || !Number.isFinite(file.bytes) || typeof file.mtimeMs !== "number" || !Number.isFinite(file.mtimeMs) || typeof details.totalLines !== "number" || !Number.isSafeInteger(details.totalLines) || details.totalLines < 0) {
+      eofByTurn.delete(turnKey);
+      return [];
+    }
+    let path;
+    try {
+      path = resolveReadPath(input.toolArgs.path);
+    } catch {
+      eofByTurn.delete(turnKey);
+      return [];
+    }
+    const identity = JSON.stringify([path, file.bytes, file.mtimeMs, details.totalLines]);
+    const previous = eofByTurn.get(turnKey);
+    const streak = previous?.identity === identity ? previous.streak + 1 : 1;
+    if (!eofByTurn.has(turnKey) && eofByTurn.size >= LOOP_GUARD_TURN_LIMIT) {
+      const oldest = eofByTurn.keys().next().value;
+      if (oldest !== void 0) eofByTurn.delete(oldest);
+    }
+    eofByTurn.set(turnKey, { identity, streak });
+    if (streak < 2 || lockoutByTurn.has(turnKey)) return [];
+    const reason = `loop detected: ${streak} consecutive reads went past the end of the same unchanged file. Changing offset or limit cannot reveal more content. Reuse the evidence already returned and synthesize the answer.`;
+    return blockAsLoop(input, turnKey, ToolNames.Read, streak, reason, options.now?.() ?? Date.now()).map(
+      (effect) => effect.kind === "block_tool" ? { kind: "annotate_tool_result", message: effect.reason, severity: "warn" } : effect
+    );
+  };
+  return {
+    id: LOOP_GUARD_REGISTRATION_ID,
+    description: "blocks repeated tool calls, enforces tool-call caps, and annotates substantial identical read results across distinct arguments",
+    hooks: ["before_tool", "after_tool"],
+    callCount: () => count,
+    extendWorkerToolCallPhase(phase) {
+      if (lockoutByTurn.size > 0 || capLockout !== null || softLimit === void 0 || !Number.isSafeInteger(phase.toolCalls) || !Number.isSafeInteger(phase.readReserve) || phase.toolCalls <= 0 || phase.readReserve < 0 || phase.readReserve >= phase.toolCalls || cap !== void 0 && phase.toolCalls > cap || phase.toolCalls < softLimit || phase.toolCalls === softLimit && phase.readReserve <= softReadReserve) {
+        return false;
+      }
+      softLimit = phase.toolCalls;
+      softReadReserve = phase.readReserve;
+      softReadReserveThreshold = softReadReserve > 0 && softLimit > softReadReserve ? softLimit - softReadReserve : null;
+      softReadReserveEntered = false;
+      softLockout = null;
+      reserveDenials = { denials: 0 };
+      return true;
+    },
+    evaluate(input) {
+      if (input.metadata?.nested === true) return [];
+      if (input.hook === "after_tool") {
+        recordSuccessfulResult(input);
+        recordResultForStagnation(input);
+        const effects = [...crossArgumentResultEffects(input), ...readCoverageEffects(input), ...readEofEffects(input)];
+        if (options.toolBudgetAdvisory && !advisoryEmitted && count >= (options.toolCallSoftLimit ?? options.toolCallCap ?? Infinity)) {
+          advisoryEmitted = true;
+          effects.push({
+            kind: "annotate_tool_result",
+            message: `Advisory tool estimate reached (${count} calls). Reassess remaining work and finish the assignment; tools remain available. Explicit task requirements still apply.`,
+            severity: "warn"
+          });
+        }
+        if (softReadReserveEntered && softLockout === null && deliveryTools.length === 0 && input.toolName === ToolNames.Read) {
+          effects.push({ kind: "require_tool", toolName: ToolNames.Read });
+        }
+        if (reserveThreshold !== null && cap !== void 0 && !reserveDirectiveEmitted && count > reserveThreshold && count <= cap) {
+          reserveDirectiveEmitted = true;
+          effects.push({
+            kind: "annotate_tool_result",
+            message: workerSynthesisReserveDirective(Math.max(0, cap - count), cap),
+            severity: "warn"
+          });
+        }
+        return effects;
+      }
+      const now = options.now?.() ?? Date.now();
+      const turnKey = input.turnId ?? NO_TURN_BUCKET;
+      const decide = () => {
+        if (capLockout !== null && cap !== void 0) {
+          if (reachesLockoutBackstop(capLockout, input)) {
+            return [
+              { kind: "block_tool", reason: synthesisBackstopReason(input.toolName ?? "unknown"), severity: "hard-block" }
+            ];
+          }
+          return [{ kind: "block_tool", reason: workerToolCallCapSynthesisReason(cap), severity: "hard-block" }];
+        }
+        if (softLockout !== null && softLimit !== void 0) {
+          if (reachesLockoutBackstop(softLockout, input)) {
+            return [
+              { kind: "block_tool", reason: synthesisBackstopReason(input.toolName ?? "unknown"), severity: "hard-block" }
+            ];
+          }
+          return [{ kind: "block_tool", reason: workerExplorationSynthesisDirective(softLimit), severity: "hard-block" }];
+        }
+        const lockout = synthesisLockout ? lockoutByTurn.get(turnKey) : void 0;
+        if (lockout !== void 0) {
+          if (reachesLockoutBackstop(lockout, input)) {
+            emitLoopBlocked(
+              input,
+              {
+                tool: lockout.tool,
+                repeatCount: lockout.repeatCount,
+                blocksThisTurn: lockout.blocksThisTurn,
+                disposition: "stop"
+              },
+              now
+            );
+            return [{ kind: "block_tool", reason: synthesisBackstopReason(lockout.tool), severity: "hard-block" }];
+          }
+          return [{ kind: "block_tool", reason: synthesisLockoutDirective(), severity: "hard-block" }];
+        }
+        if (softLimit !== void 0) {
+          const spentSoftLimit = softAdmittedCount >= softLimit;
+          if (spentSoftLimit && deliveryTools.length === 0) {
+            softLockout = {
+              denials: 0,
+              ...input.correlationId !== void 0 ? { correlationId: input.correlationId } : {}
+            };
+            options.onSynthesisLockout?.();
+            return [{ kind: "block_tool", reason: workerExplorationSynthesisDirective(softLimit), severity: "hard-block" }];
+          }
+          const inReserve = softReadReserveThreshold !== null && softAdmittedCount >= softReadReserveThreshold;
+          if (spentSoftLimit || inReserve) {
+            enterSoftReadReserve();
+            if (!reserveAdmits(input.toolName)) {
+              if (reachesLockoutBackstop(reserveDenials, input)) {
+                softLockout = {
+                  denials: 0,
+                  ...input.correlationId !== void 0 ? { correlationId: input.correlationId } : {}
+                };
+                options.onSynthesisLockout?.();
+                return [{ kind: "block_tool", reason: workerExplorationSynthesisDirective(softLimit), severity: "hard-block" }];
+              }
+              return [
+                {
+                  kind: "block_tool",
+                  reason: spentSoftLimit ? workerDeliveryOnlyDirective(softLimit, deliveryTools) : workerLiveReadReserveDirective(softLimit - softAdmittedCount, deliveryTools),
+                  severity: "hard-block"
+                }
+              ];
+            }
+          }
+        }
+        if (reserveThreshold !== null && cap !== void 0 && count >= reserveThreshold && !reserveAdmits(input.toolName)) {
+          if (reachesLockoutBackstop(reserveDenials, input)) {
+            if (synthesisLockout) {
+              capLockout = {
+                denials: 0,
+                ...input.correlationId !== void 0 ? { correlationId: input.correlationId } : {}
+              };
+              options.onSynthesisLockout?.();
+            }
+            return [{ kind: "block_tool", reason: workerToolCallCapSynthesisReason(cap), severity: "hard-block" }];
+          }
+          return [
+            {
+              kind: "block_tool",
+              reason: workerSynthesisReserveBlockReason(input.toolName ?? "unknown", Math.max(1, cap - count), cap),
+              severity: "hard-block"
+            }
+          ];
+        }
+        count += 1;
+        reserveDenials = { denials: 0 };
+        if (softLimit !== void 0) {
+          softAdmittedCount += 1;
+          if (softReadReserveThreshold !== null && softAdmittedCount >= softReadReserveThreshold) enterSoftReadReserve();
+          if (softAdmittedCount >= softLimit) {
+            if (deliveryTools.length === 0) {
+              softLockout = {
+                denials: 0,
+                ...input.correlationId !== void 0 ? { correlationId: input.correlationId } : {}
+              };
+              options.onSynthesisLockout?.();
+            }
+            options.onSoftLimitFinalCallAdmitted?.(input.toolCallId);
+          }
+        }
+        if (cap !== void 0 && count > cap) {
+          if (!synthesisLockout) {
+            return [{ kind: "block_tool", reason: workerToolCallCapExceededReason(cap), severity: "hard-block" }];
+          }
+          capLockout = {
+            denials: 0,
+            ...input.correlationId !== void 0 ? { correlationId: input.correlationId } : {}
+          };
+          options.onSynthesisLockout?.();
+          return [{ kind: "block_tool", reason: workerToolCallCapSynthesisReason(cap), severity: "hard-block" }];
+        }
+        const fingerprint = input.metadata?.callFingerprint;
+        if (typeof fingerprint !== "string" || fingerprint.length === 0) {
+          return evaluateTurnBudget(input, now) ?? [];
+        }
+        const epoch = mutationEpochByTurn.get(turnKey) ?? 0;
+        const verdict = options.safety.observeLoop(`${turnKey}|${epoch}|${fingerprint}`, now);
+        if (verdict.looping) {
+          const tool = input.toolName ?? "unknown";
+          const priorSuccesses = succeededFingerprints.get(fingerprint) ?? 0;
+          return blockAsLoop(
+            input,
+            turnKey,
+            tool,
+            verdict.count,
+            loopBlockBaseReason(tool, verdict.count, priorSuccesses),
+            now
+          );
+        }
+        const toolName = input.toolName;
+        if (typeof toolName === "string" && toolName.length > 0) {
+          const entry = stagnationByTurn.get(turnKey);
+          if (entry !== void 0 && entry.streak >= RESULT_STAGNATION_THRESHOLD - 1 && entry.reducedFingerprint === stagnationFingerprint(toolName, input.toolArgs)) {
+            return blockAsLoop(
+              input,
+              turnKey,
+              toolName,
+              entry.streak + 1,
+              stagnationBlockReason(toolName, entry.streak),
+              now
+            );
+          }
+        }
+        return evaluateTurnBudget(input, now) ?? [];
+      };
+      return boundRunDenials(decide(), input);
+    }
+  };
+}
+function isReserveAdmittedTool(tool, deliveryTools) {
+  return tool === ToolNames.Read || tool !== void 0 && deliveryTools.includes(tool);
+}
+function resolveDeliveryTools(allowedTools, product) {
+  const candidates = product === "orientation" ? [ToolNames.Write, ToolNames.Edit, ToolNames.CodeNav] : [ToolNames.Write, ToolNames.Edit];
+  if (allowedTools instanceof Set) {
+    return candidates.filter((tool) => allowedTools.has(tool));
+  }
+  return candidates.filter((tool) => allowedTools.includes(tool));
+}
+
+// src/engine/agent.ts
+init_esm_shims();
+import { createInitialSystemMessage, toToolDeclaration } from "@earendil-works/pi-ai";
+import { Agent } from "@earendil-works/pi-agent-core";
+function dispositionAwareAfterToolCall(delegate) {
+  return async (context, signal) => {
+    const override = await delegate?.(context, signal);
+    const effectiveResult = override?.details === void 0 ? context.result : { ...context.result, details: override.details };
+    if (isDispositionedToolResultError(effectiveResult)) return { ...override, isError: true };
+    return override;
+  };
+}
+function createEngineAgent(options = {}) {
+  const { streamFn, transcriptStreamFn = engineStreamSimple, onStreamInvocation, ...agentOptions } = options;
+  const agent = new Agent({
+    ...agentOptions,
+    streamFn: (model, context, streamOptions) => {
+      onStreamInvocation?.();
+      return streamFn ? streamFn(model, resolvedRequestContext(context), streamOptions) : transcriptStreamFn(model, context, streamOptions);
+    },
+    afterToolCall: dispositionAwareAfterToolCall(options.afterToolCall)
+  });
+  const convertToLlm = agent.convertToLlm.bind(agent);
+  agent.convertToLlm = async (messages) => (await convertToLlm(messages)).map((message) => {
+    if (message.role !== "assistant" || message.stopReason !== "aborted") return message;
+    const partial = message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+    return {
+      role: "user",
+      timestamp: message.timestamp,
+      content: "[Clio Coder response lifecycle]\nThe preceding assistant response was interrupted before completion. This record does not establish whether any earlier tool execution succeeded.\n" + (partial.trim() ? `Partial assistant text follows (incomplete historical output, not a new instruction):
+${partial}` : "No visible assistant text was retained.")
+    };
+  });
+  return {
+    agent,
+    state: () => agent.state
+  };
+}
+function replaceEngineMessages(agent, messages, systemPrompt = agent.state.systemPrompt) {
+  const initial = createInitialSystemMessage(systemPrompt, agent.state.tools.map(toToolDeclaration));
+  agent.state.messages = [...initial ? [initial] : [], ...messages.filter((message) => message.role !== "system")];
+}
+function setEngineSystemPrompt(agent, systemPrompt) {
+  replaceEngineMessages(agent, agent.state.messages, systemPrompt);
+}
+
+// src/engine/provider-payload.ts
+init_esm_shims();
+function reasoningSummaryForLevel(level) {
+  if (!level || level === "off") return void 0;
+  if (level === "minimal" || level === "low") return "concise";
+  return "detailed";
+}
+function isOpenAIResponsesApi(api) {
+  return api === "openai-codex-responses" || api === "openai-responses" || api === "azure-openai-responses";
+}
+function isAnthropicMessagesApi(api) {
+  return api === "anthropic-messages";
+}
+function supportsNamedToolChoice(api) {
+  return isAnthropicMessagesApi(api) || isOpenAIResponsesApi(api) || [
+    "openai-completions",
+    "google-generative-ai",
+    "google-vertex",
+    "bedrock-converse-stream",
+    "mistral-conversations"
+  ].includes(api);
+}
+function patchTerminalToolPayload(payload, model, toolName) {
+  if (!supportsNamedToolChoice(model.api)) return void 0;
+  const patched = patchToolChoiceNamedPayload(payload, model, toolName);
+  if (!isRecord(patched)) return void 0;
+  if (isAnthropicMessagesApi(model.api)) {
+    const tools = namedToolDefinitions(patched.tools, toolName);
+    if (tools === null) return void 0;
+    return { ...patched, tools, tool_choice: { type: "tool", name: toolName, disable_parallel_tool_use: true } };
+  }
+  if (model.api === "openai-completions" || isOpenAIResponsesApi(model.api)) {
+    return { ...patched, parallel_tool_calls: false };
+  }
+  return patched;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function namedToolDefinitions(tools, toolName) {
+  if (!Array.isArray(tools)) return null;
+  const narrowed = [];
+  for (const tool of tools) {
+    if (!isRecord(tool)) continue;
+    const directName = typeof tool.name === "string" ? tool.name : void 0;
+    const functionName = isRecord(tool.function) && typeof tool.function.name === "string" ? tool.function.name : void 0;
+    const toolSpecName = isRecord(tool.toolSpec) && typeof tool.toolSpec.name === "string" ? tool.toolSpec.name : void 0;
+    if (directName === toolName || functionName === toolName || toolSpecName === toolName) {
+      narrowed.push(tool);
+      continue;
+    }
+    if (Array.isArray(tool.functionDeclarations)) {
+      const declarations = tool.functionDeclarations.filter(
+        (declaration) => isRecord(declaration) && declaration.name === toolName
+      );
+      if (declarations.length > 0) narrowed.push({ ...tool, functionDeclarations: declarations });
+    }
+  }
+  return narrowed.length > 0 ? narrowed : null;
+}
+function patchOpenAIReasoningSummaryPayload(payload, model, thinkingLevel) {
+  if (!isOpenAIResponsesApi(model.api)) return void 0;
+  const summary = reasoningSummaryForLevel(thinkingLevel);
+  if (!summary || !isRecord(payload)) return void 0;
+  const record = payload;
+  const reasoning = record.reasoning;
+  if (!isRecord(reasoning)) return void 0;
+  return {
+    ...record,
+    reasoning: {
+      ...reasoning,
+      summary
+    }
+  };
+}
+function patchProviderThinkingPayload(payload, model, thinkingLevel) {
+  return patchOpenAIReasoningSummaryPayload(payload, model, thinkingLevel);
+}
+function patchToolChoiceNonePayload(payload, model) {
+  if (!isRecord(payload)) return void 0;
+  if (!("tools" in payload) || payload.tools === void 0 || payload.tools === null) return void 0;
+  if (isAnthropicMessagesApi(model.api)) return { ...payload, tool_choice: { type: "none" } };
+  return { ...payload, tool_choice: "none" };
+}
+function patchToolSurfaceLockedPayload(payload, model) {
+  if (!isRecord(payload)) return void 0;
+  if (!("tools" in payload) || payload.tools === void 0 || payload.tools === null) return void 0;
+  if (isAnthropicMessagesApi(model.api)) return patchToolChoiceNonePayload(payload, model);
+  const stripped = { ...payload };
+  delete stripped.tools;
+  delete stripped.tool_choice;
+  return stripped;
+}
+function patchToolChoiceNamedPayload(payload, model, toolName) {
+  if (!isRecord(payload) || toolName.trim().length === 0) return void 0;
+  if (isAnthropicMessagesApi(model.api)) {
+    const tools2 = namedToolDefinitions(payload.tools, toolName);
+    if (tools2 === null) return void 0;
+    const patched = { ...payload };
+    delete patched.thinking;
+    if (isRecord(patched.output_config) && "effort" in patched.output_config) {
+      const outputConfig = { ...patched.output_config };
+      delete outputConfig.effort;
+      if (Object.keys(outputConfig).length > 0) patched.output_config = outputConfig;
+      else delete patched.output_config;
+    }
+    return { ...patched, tool_choice: { type: "tool", name: toolName } };
+  }
+  if (model.api === "google-generative-ai" || model.api === "google-vertex") {
+    if (!isRecord(payload.config) || payload.config.tools === void 0 || payload.config.tools === null)
+      return void 0;
+    const tools2 = namedToolDefinitions(payload.config.tools, toolName);
+    if (tools2 === null) return void 0;
+    const toolConfig = isRecord(payload.config.toolConfig) ? payload.config.toolConfig : {};
+    return {
+      ...payload,
+      config: {
+        ...payload.config,
+        tools: tools2,
+        toolConfig: {
+          ...toolConfig,
+          functionCallingConfig: { mode: "ANY", allowedFunctionNames: [toolName] }
+        }
+      }
+    };
+  }
+  if (model.api === "bedrock-converse-stream") {
+    if (!isRecord(payload.toolConfig) || payload.toolConfig.tools === void 0 || payload.toolConfig.tools === null) {
+      return void 0;
+    }
+    const tools2 = namedToolDefinitions(payload.toolConfig.tools, toolName);
+    if (tools2 === null) return void 0;
+    return { ...payload, toolConfig: { ...payload.toolConfig, tools: tools2, toolChoice: { tool: { name: toolName } } } };
+  }
+  const tools = namedToolDefinitions(payload.tools, toolName);
+  if (tools === null) return void 0;
+  if (isOpenAIResponsesApi(model.api)) {
+    return { ...payload, tools, tool_choice: { type: "function", name: toolName } };
+  }
+  if (model.api === "mistral-conversations") {
+    return { ...payload, tools, toolChoice: { type: "function", function: { name: toolName } } };
+  }
+  return { ...payload, tools, tool_choice: "required" };
+}
+function patchLlamaCppResponseSchemaPayload(payload, runtimeId, responseSchema) {
+  if (responseSchema === void 0) return void 0;
+  if (runtimeId !== RESPONSE_SCHEMA_RUNTIME_ID && runtimeId !== GATEWAY_SCHEMA_RUNTIME_ID) {
+    throw new Error(`responseSchema requires the native llamacpp or litellm runtime; received '${runtimeId}'`);
+  }
+  if (!isRecord(payload)) throw new Error("cannot apply responseSchema to a non-object provider payload");
+  const dialect = responseSchemaDialectFor(runtimeId);
+  return dialect === null ? void 0 : patchResponseSchemaPayloadForDialect(payload, dialect, responseSchema, "clio_result");
+}
+function patchResponseSchemaPayloadForDialect(payload, dialect, responseSchema, schemaName) {
+  if (!isRecord(payload)) return void 0;
+  if (dialect === "llamacpp-json-object") {
+    return { ...payload, response_format: { type: "json_object", schema: responseSchema } };
+  }
+  return {
+    ...payload,
+    response_format: {
+      type: "json_schema",
+      json_schema: { name: schemaName, strict: true, schema: responseSchema }
+    }
+  };
+}
+function patchWorkerRequestPayload(payload, model, options) {
+  let patched = payload;
+  let changed = false;
+  const thinkingPatched = patchProviderThinkingPayload(patched, model, options.thinkingLevel);
+  if (thinkingPatched !== void 0) {
+    patched = thinkingPatched;
+    changed = true;
+  }
+  const schemaPatched = patchLlamaCppResponseSchemaPayload(patched, options.runtimeId, options.responseSchema);
+  if (schemaPatched !== void 0) {
+    patched = schemaPatched;
+    changed = true;
+  }
+  if (options.terminalToolName !== void 0) {
+    const terminal = patchTerminalToolPayload(patched, model, options.terminalToolName);
+    if (terminal !== void 0) return terminal;
+  }
+  if (options.toolSurfaceLocked === true) {
+    const lockedPatched = patchToolSurfaceLockedPayload(patched, model);
+    if (lockedPatched !== void 0) {
+      patched = lockedPatched;
+      changed = true;
+    }
+  } else if (options.toolChoiceNone === true) {
+    const toolChoicePatched = patchToolChoiceNonePayload(patched, model);
+    if (toolChoicePatched !== void 0) {
+      patched = toolChoicePatched;
+      changed = true;
+    }
+  } else if (options.toolChoiceName !== void 0) {
+    const toolChoicePatched = patchToolChoiceNamedPayload(patched, model, options.toolChoiceName);
+    if (toolChoicePatched !== void 0) {
+      patched = toolChoicePatched;
+      changed = true;
+    }
+  }
+  return changed ? patched : void 0;
+}
+
+export {
+  createProtectedArtifactsRegistration,
+  INTERACTIVE_LOOP_BLOCK_BUDGET,
+  workerLoopBlockBudget,
+  isLockedSynthesisFallbackOnly,
+  lockedSynthesisSystemPrompt,
+  lockedSynthesisRepromptMessages,
+  lockedSynthesisFallbackText,
+  sanitizeLockedSynthesisMessage,
+  isLoopGuardSynthesisBackstopReason,
+  readOrchTurnToolCallBudget,
+  createLoopGuardRegistration,
+  isReserveAdmittedTool,
+  resolveDeliveryTools,
+  createEngineAgent,
+  replaceEngineMessages,
+  setEngineSystemPrompt,
+  supportsNamedToolChoice,
+  patchProviderThinkingPayload,
+  patchToolChoiceNonePayload,
+  patchToolChoiceNamedPayload,
+  patchResponseSchemaPayloadForDialect,
+  patchWorkerRequestPayload
+};
+//# sourceMappingURL=chunk-GRHOXDKB.js.map