@kenkaiiii/gg-agent 5.68.1 → 5.70.0

package/dist/index.cjs

@@ -41,11 +41,11 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/agent.ts
-var import_gg_ai2 = require("@kenkaiiii/gg-ai");
+var import_gg_ai3 = require("@kenkaiiii/gg-ai");
 
 // src/agent-loop.ts
 var import_zod = require("zod");
-var import_gg_ai = require("@kenkaiiii/gg-ai");
+var import_gg_ai2 = require("@kenkaiiii/gg-ai");
 
 // src/local-backend.ts
 function isLocalBackendUrl(baseUrl) {
@@ -69,6 +69,107 @@ function isLocalBackendUrl(baseUrl) {
   return false;
 }
 
+// src/tool-call-hints.ts
+var import_gg_ai = require("@kenkaiiii/gg-ai");
+function normalizeName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function editDistance(a, b) {
+  let beforePrevious = [];
+  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const current = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      let distance = Math.min(
+        (previous[j] ?? 0) + 1,
+        (current[j - 1] ?? 0) + 1,
+        (previous[j - 1] ?? 0) + cost
+      );
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+        distance = Math.min(distance, (beforePrevious[j - 2] ?? 0) + 1);
+      }
+      current[j] = distance;
+    }
+    beforePrevious = previous;
+    previous = current;
+  }
+  return previous[b.length] ?? 0;
+}
+function closestName(name, candidates) {
+  const target = normalizeName(name);
+  if (!target) return void 0;
+  const limit = Math.min(3, Math.max(1, Math.floor(target.length / 3)));
+  let best;
+  for (const candidate of [...candidates].sort()) {
+    if (candidate === name) continue;
+    const distance = editDistance(target, normalizeName(candidate));
+    if (distance > limit) continue;
+    if (!best || distance < best.distance) best = { name: candidate, distance };
+  }
+  return best?.name;
+}
+function unknownToolMessage(name, available) {
+  const suggestion = closestName(name, available);
+  if (suggestion) return `Unknown tool: ${name}. Did you mean \`${suggestion}\`?`;
+  const names = [...available].sort();
+  const listed = names.length > 40 ? `${names.slice(0, 40).join(", ")}, \u2026` : names.join(", ");
+  const searchHint = available.includes("tool_search") ? " If the capability is not listed, call `tool_search` to load it." : "";
+  return `Unknown tool: ${name}. Available tools: ${listed}.${searchHint}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function typeLabel(node) {
+  if (!isRecord(node)) return "any";
+  if (Array.isArray(node.enum)) {
+    return node.enum.map((value) => JSON.stringify(value)).join(" | ");
+  }
+  const variants = node.anyOf ?? node.oneOf;
+  if (Array.isArray(variants)) {
+    return [...new Set(variants.map(typeLabel))].filter((t) => t !== "null").join(" | ") || "any";
+  }
+  if (node.type === "array") return `${typeLabel(node.items)}[]`;
+  if (Array.isArray(node.type)) {
+    return node.type.filter((t) => t !== "null").join(" | ") || "any";
+  }
+  return typeof node.type === "string" ? node.type : "any";
+}
+function objectShape(tool) {
+  let schema;
+  try {
+    schema = (0, import_gg_ai.resolveToolSchema)(tool);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(schema) || !isRecord(schema.properties)) return void 0;
+  const required = new Set(
+    Array.isArray(schema.required) ? schema.required.filter((r) => typeof r === "string") : []
+  );
+  return { properties: schema.properties, required };
+}
+function argumentHints(tool, args) {
+  const shape = objectShape(tool);
+  if (!shape) return "";
+  const names = Object.keys(shape.properties);
+  if (names.length === 0) return `Expected arguments: none.`;
+  const fields = names.map((name) => {
+    const optional = shape.required.has(name) ? "" : "?";
+    return `${name}${optional}: ${typeLabel(shape.properties[name])}`;
+  });
+  const lines = [`Expected arguments: { ${fields.join(", ")} }`];
+  if (isRecord(args)) {
+    for (const key of Object.keys(args).sort()) {
+      if (key in shape.properties) continue;
+      const suggestion = closestName(key, names);
+      lines.push(
+        suggestion ? `Unknown field \`${key}\` \u2014 did you mean \`${suggestion}\`?` : `Unknown field \`${key}\` is not a parameter of this tool.`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+
 // src/output-ceiling.ts
 var TTL_MS = 24 * 60 * 60 * 1e3;
 var MIN_PLAUSIBLE_CEILING = 256;
@@ -253,9 +354,32 @@ ${rule.reminder.trim()}
 // src/agent-loop.ts
 var DEFAULT_MAX_TURNS = 300;
 var DEFAULT_TOOL_TIMEOUT_MS = 3e5;
+var PREEMPT_GRACE_MS = 500;
+var STEER_INTERRUPTED_TEXT = "Interrupted: the user sent a new message.";
+var ATOMIC_TOOL_NAMES = /* @__PURE__ */ new Set(["edit", "write", "multi_edit", "apply_patch", "notebook_edit"]);
+function isInterruptibleTool(tool, name) {
+  if (tool?.interruptible !== void 0) return tool.interruptible;
+  return !ATOMIC_TOOL_NAMES.has(name);
+}
+function markSteerInterrupted(record) {
+  const content = record.content;
+  let next;
+  if (typeof content === "string") {
+    next = content.trim() ? `${STEER_INTERRUPTED_TEXT}
+Partial output:
+${content}` : STEER_INTERRUPTED_TEXT;
+  } else {
+    next = [
+      { type: "text", text: `${STEER_INTERRUPTED_TEXT}
+Partial output:` },
+      ...content
+    ];
+  }
+  return { toolCallId: record.toolCallId, content: next, isError: true };
+}
 var _toolRedaction;
 function toolRedactionOptions() {
-  _toolRedaction ??= { secrets: (0, import_gg_ai.environmentSecrets)(process.env) };
+  _toolRedaction ??= { secrets: (0, import_gg_ai2.environmentSecrets)(process.env) };
   return _toolRedaction;
 }
 var _diagFn = null;
@@ -338,7 +462,7 @@ function isBillingError(err) {
   if (!(err instanceof Error)) return false;
   const statusCode = err.statusCode;
   if (statusCode === 402) return true;
-  return (0, import_gg_ai.isHardBillingMessage)(err.message);
+  return (0, import_gg_ai2.isHardBillingMessage)(err.message);
 }
 function isUsageLimitError(err) {
   if (!(err instanceof Error)) return false;
@@ -707,7 +831,7 @@ async function* agentLoop(messages, options) {
             });
           }
         }
-        const result = (0, import_gg_ai.stream)({
+        const result = (0, import_gg_ai2.stream)({
           provider: options.provider,
           model: options.model,
           messages,
@@ -1170,7 +1294,7 @@ async function* agentLoop(messages, options) {
           });
           yield {
             type: "error",
-            error: new import_gg_ai.GGAIError(
+            error: new import_gg_ai2.GGAIError(
               `The connection to the API provider stopped responding after ${MAX_STALL_RETRIES} automatic retries. Your conversation is preserved.`,
               {
                 source: "network",
@@ -1403,10 +1527,14 @@ async function* agentLoop(messages, options) {
         fatalToolArgumentRecoverable = recoverable;
         fatalToolArgumentToolName = toolName;
       };
+      const preempt = new AbortController();
+      const unsubscribeSteering = options.onSteeringAvailable?.(() => preempt.abort());
       const executionOptions = {
         signal: options.signal,
+        preemptSignal: options.onSteeringAvailable ? preempt.signal : void 0,
         maxToolResultChars: options.maxToolResultChars,
         maxTurnToolResultChars: options.maxTurnToolResultChars,
+        transformToolResult: options.transformToolResult,
         toolMap,
         invalidToolArgumentCounts,
         markFatalToolArgumentError,
@@ -1415,7 +1543,15 @@ async function* agentLoop(messages, options) {
       const hasSequentialToolCall = toolCalls.some(
         (toolCall) => toolMap.get(toolCall.name)?.executionMode === "sequential"
       );
-      const executionResult = hasSequentialToolCall ? yield* executeToolCallsMixed(toolCalls, toolResults, executionOptions) : yield* executeToolCallsParallel(toolCalls, toolResults, executionOptions);
+      let executionResult;
+      try {
+        executionResult = hasSequentialToolCall ? yield* executeToolCallsMixed(toolCalls, toolResults, executionOptions) : yield* executeToolCallsParallel(toolCalls, toolResults, executionOptions);
+      } finally {
+        unsubscribeSteering?.();
+      }
+      if (executionResult.preempted) {
+        diag("steer_preempted_tools", { turn, provider: options.provider, model: options.model });
+      }
       messages.push({ role: "tool", content: executionResult.toolResults });
       yield { type: "checkpoint", turn };
       const toolsAborted = executionResult.aborted;
@@ -1572,7 +1708,7 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
     options.seenToolCalls.add(signature);
   }
   if (!tool) {
-    resultContent = `Unknown tool: ${toolCall.name}`;
+    resultContent = unknownToolMessage(toolCall.name, [...options.toolMap.keys()]);
     isError = true;
   } else {
     try {
@@ -1589,8 +1725,12 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
       }
       const callerSignal = options.signal;
       const toolTimeout = AbortSignal.timeout(tool.timeoutMs ?? DEFAULT_TOOL_TIMEOUT_MS);
+      const preemptSignal = isInterruptibleTool(tool, toolCall.name) ? options.preemptSignal : void 0;
+      const toolSignals = [callerSignal, toolTimeout, preemptSignal].filter(
+        (s) => s !== void 0
+      );
       const ctx = {
-        signal: callerSignal ? AbortSignal.any([callerSignal, toolTimeout]) : toolTimeout,
+        signal: toolSignals.length === 1 ? toolTimeout : AbortSignal.any(toolSignals),
         toolCallId: toolCall.id,
         onUpdate: (update) => {
           pushEvent({
@@ -1602,8 +1742,17 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
       };
       const raw = await tool.execute(parsed, ctx);
       const normalized = normalizeToolResult(raw);
-      resultContent = (0, import_gg_ai.redactValue)(normalized.content, toolRedactionOptions());
-      details = (0, import_gg_ai.redactValue)(normalized.details, toolRedactionOptions());
+      resultContent = (0, import_gg_ai2.redactValue)(normalized.content, toolRedactionOptions());
+      details = (0, import_gg_ai2.redactValue)(normalized.details, toolRedactionOptions());
+      if (options.transformToolResult) {
+        try {
+          resultContent = options.transformToolResult(
+            { name: toolCall.name, args: toolCall.args },
+            resultContent
+          );
+        } catch {
+        }
+      }
       for (const key of options.invalidToolArgumentCounts.keys()) {
         if (key.startsWith(`${toolCall.name}:`)) options.invalidToolArgumentCounts.delete(key);
       }
@@ -1615,12 +1764,14 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
         const failureCount = (options.invalidToolArgumentCounts.get(failureKey) ?? 0) + 1;
         options.invalidToolArgumentCounts.set(failureKey, failureCount);
         invalidArgAttempt = failureCount;
+        const hints = argumentHints(tool, toolCall.args);
         resultContent = `Invalid arguments for tool \`${toolCall.name}\`:
-` + prettyError + "\nRe-issue the call with each field as the correct type.";
+` + prettyError + (hints ? `
+${hints}` : "") + "\nRe-issue the call with each field as the correct type.";
         if (failureCount >= 3) {
           const recoverable = Object.keys(toolCall.args ?? {}).length === 0;
           options.markFatalToolArgumentError(
-            new import_gg_ai.GGAIError(
+            new import_gg_ai2.GGAIError(
               `The model repeatedly issued invalid arguments for tool \`${toolCall.name}\`. This is usually an upstream model/tool-calling bug` + (recoverable ? " (the provider's stream returned empty tool-call arguments)" : "") + `. Your conversation is preserved; send another message or switch models to continue.`,
               {
                 source: "provider",
@@ -1632,15 +1783,24 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
           );
         }
       } else {
-        resultContent = (0, import_gg_ai.redactValue)(
+        resultContent = (0, import_gg_ai2.redactValue)(
           err instanceof Error ? err.message : String(err),
           toolRedactionOptions()
         );
       }
     }
   }
-  resultContent = (0, import_gg_ai.redactValue)(resultContent, toolRedactionOptions());
-  details = (0, import_gg_ai.redactValue)(details, toolRedactionOptions());
+  resultContent = (0, import_gg_ai2.redactValue)(resultContent, toolRedactionOptions());
+  details = (0, import_gg_ai2.redactValue)(details, toolRedactionOptions());
+  if (options.preemptSignal?.aborted && isInterruptibleTool(options.toolMap.get(toolCall.name), toolCall.name)) {
+    const marked = markSteerInterrupted({
+      toolCallId: toolCall.id,
+      content: resultContent,
+      isError
+    });
+    resultContent = marked.content;
+    isError = true;
+  }
   const durationMs = Date.now() - startTime;
   pushEvent({
     type: "tool_call_end",
@@ -1653,13 +1813,67 @@ async function executeSingleToolCall(toolCall, options, pushEvent) {
   });
   return { toolCallId: toolCall.id, content: resultContent, isError };
 }
+function createPreemptTracker(options, eventStream, state, resultsById, dispatchedIds) {
+  const running = /* @__PURE__ */ new Map();
+  let graceTimer;
+  const preemptSignal = options.preemptSignal;
+  const abandon = () => {
+    graceTimer = void 0;
+    for (const [id, entry] of running) {
+      if (!entry.interruptible || resultsById.has(id)) continue;
+      resultsById.set(id, { toolCallId: id, content: STEER_INTERRUPTED_TEXT, isError: true });
+      pushToolEvent(eventStream, state, {
+        type: "tool_call_end",
+        toolCallId: id,
+        result: STEER_INTERRUPTED_TEXT,
+        isError: true,
+        durationMs: Date.now() - entry.startedAt
+      });
+      running.delete(id);
+    }
+    if (running.size === 0) eventStream.close();
+  };
+  const onPreempt = () => {
+    if (graceTimer === void 0) graceTimer = setTimeout(abandon, PREEMPT_GRACE_MS);
+  };
+  preemptSignal?.addEventListener("abort", onPreempt, { once: true });
+  return {
+    async run(toolCall) {
+      if (options.preemptSignal?.aborted) return;
+      dispatchedIds.add(toolCall.id);
+      const interruptible = isInterruptibleTool(options.toolMap.get(toolCall.name), toolCall.name);
+      running.set(toolCall.id, { toolCall, interruptible, startedAt: Date.now() });
+      const record = await executeSingleToolCall(
+        toolCall,
+        options,
+        (event) => pushToolEvent(eventStream, state, event)
+      );
+      running.delete(toolCall.id);
+      if (resultsById.has(toolCall.id)) return;
+      const alreadyMarked = typeof record.content === "string" ? record.content.startsWith(STEER_INTERRUPTED_TEXT) : record.content[0]?.type === "text" && record.content[0].text.startsWith(STEER_INTERRUPTED_TEXT);
+      resultsById.set(
+        toolCall.id,
+        interruptible && preemptSignal?.aborted && !alreadyMarked ? markSteerInterrupted(record) : record
+      );
+      if (preemptSignal?.aborted && graceTimer === void 0 && running.size === 0) {
+        eventStream.close();
+      }
+    },
+    preempted: () => preemptSignal?.aborted === true,
+    dispose: () => {
+      if (graceTimer !== void 0) clearTimeout(graceTimer);
+      preemptSignal?.removeEventListener("abort", onPreempt);
+    }
+  };
+}
 async function* executeToolCallsMixed(toolCalls, initialToolResults, options) {
-  const eventStream = new import_gg_ai.EventStream();
+  const eventStream = new import_gg_ai2.EventStream();
   const state = { finalized: false };
   const resultsById = /* @__PURE__ */ new Map();
   const dispatchedIds = /* @__PURE__ */ new Set();
   const abortHandler = () => eventStream.abort(new Error("aborted"));
   options.signal?.addEventListener("abort", abortHandler, { once: true });
+  const tracker = createPreemptTracker(options, eventStream, state, resultsById, dispatchedIds);
   const phases = [];
   let currentParallel = [];
   for (const toolCall of toolCalls) {
@@ -1680,40 +1894,18 @@ async function* executeToolCallsMixed(toolCalls, initialToolResults, options) {
   void (async () => {
     try {
       for (const phase of phases) {
-        if (options.signal?.aborted) break;
+        if (options.signal?.aborted || options.preemptSignal?.aborted) break;
         if (phase.sequential) {
           const signature = JSON.stringify([
             phase.sequential.name,
             canonicalToolArgs(phase.sequential.args)
           ]);
           if (!options.seenToolCalls.has(signature)) options.seenToolCalls.clear();
-          dispatchedIds.add(phase.sequential.id);
-          const record = await executeSingleToolCall(
-            phase.sequential,
-            options,
-            (event) => pushToolEvent(eventStream, state, event)
-          );
-          resultsById.set(record.toolCallId, record);
+          await tracker.run(phase.sequential);
         } else if (phase.parallel.length === 1) {
-          dispatchedIds.add(phase.parallel[0].id);
-          const record = await executeSingleToolCall(
-            phase.parallel[0],
-            options,
-            (event) => pushToolEvent(eventStream, state, event)
-          );
-          resultsById.set(record.toolCallId, record);
+          await tracker.run(phase.parallel[0]);
         } else {
-          await Promise.all(
-            phase.parallel.map(async (toolCall) => {
-              dispatchedIds.add(toolCall.id);
-              const record = await executeSingleToolCall(
-                toolCall,
-                options,
-                (event) => pushToolEvent(eventStream, state, event)
-              );
-              resultsById.set(record.toolCallId, record);
-            })
-          );
+          await Promise.all(phase.parallel.map((toolCall) => tracker.run(toolCall)));
         }
       }
       if (!state.finalized) eventStream.close();
@@ -1734,31 +1926,23 @@ async function* executeToolCallsMixed(toolCalls, initialToolResults, options) {
     }
   } finally {
     options.signal?.removeEventListener("abort", abortHandler);
+    tracker.dispose();
     state.finalized = true;
   }
   const toolResults = buildToolResults(initialToolResults, toolCalls, resultsById, dispatchedIds);
   capToolResults(toolResults, options.maxToolResultChars);
   capTurnToolResults(toolResults, options.maxTurnToolResultChars);
-  return { toolResults, aborted };
+  return { toolResults, aborted, preempted: !aborted && tracker.preempted() };
 }
 async function* executeToolCallsParallel(toolCalls, initialToolResults, options) {
-  const eventStream = new import_gg_ai.EventStream();
+  const eventStream = new import_gg_ai2.EventStream();
   const state = { finalized: false };
   const resultsById = /* @__PURE__ */ new Map();
   const dispatchedIds = /* @__PURE__ */ new Set();
   const abortHandler = () => eventStream.abort(new Error("aborted"));
   options.signal?.addEventListener("abort", abortHandler, { once: true });
-  Promise.all(
-    toolCalls.map(async (toolCall) => {
-      dispatchedIds.add(toolCall.id);
-      const record = await executeSingleToolCall(
-        toolCall,
-        options,
-        (event) => pushToolEvent(eventStream, state, event)
-      );
-      resultsById.set(record.toolCallId, record);
-    })
-  ).then(() => {
+  const tracker = createPreemptTracker(options, eventStream, state, resultsById, dispatchedIds);
+  Promise.all(toolCalls.map((toolCall) => tracker.run(toolCall))).then(() => {
     if (!state.finalized) eventStream.close();
   }).catch((err) => {
     if (!state.finalized) eventStream.abort(err instanceof Error ? err : new Error(String(err)));
@@ -1776,12 +1960,13 @@ async function* executeToolCallsParallel(toolCalls, initialToolResults, options)
     }
   } finally {
     options.signal?.removeEventListener("abort", abortHandler);
+    tracker.dispose();
     state.finalized = true;
   }
   const toolResults = buildToolResults(initialToolResults, toolCalls, resultsById, dispatchedIds);
   capToolResults(toolResults, options.maxToolResultChars);
   capTurnToolResults(toolResults, options.maxTurnToolResultChars);
-  return { toolResults, aborted };
+  return { toolResults, aborted, preempted: !aborted && tracker.preempted() };
 }
 function cancelledBeforeStartText(name) {
   return `\`${name}\` was cancelled before it started, so it had no effect. Safe to retry.`;
@@ -1821,8 +2006,8 @@ function capToolResults(toolResults, maxToolResultChars) {
     const originalChars = toolResult.content.length;
     const headChars = Math.floor(max * 0.7);
     const tailChars = max - headChars;
-    const head = (0, import_gg_ai.sliceHead)(toolResult.content, headChars);
-    const tail = (0, import_gg_ai.sliceTail)(toolResult.content, tailChars);
+    const head = (0, import_gg_ai2.sliceHead)(toolResult.content, headChars);
+    const tail = (0, import_gg_ai2.sliceTail)(toolResult.content, tailChars);
     const omitted = originalChars - head.length - tail.length;
     toolResult.content = head + `
 
@@ -1858,11 +2043,11 @@ function capTurnToolResults(toolResults, maxTurnToolResultChars) {
     const headChars = Math.floor(fairShare * 0.7);
     const tailChars = fairShare - headChars;
     const omitted = originalChars - fairShare;
-    toolResult.content = (0, import_gg_ai.sliceHead)(toolResult.content, headChars) + `
+    toolResult.content = (0, import_gg_ai2.sliceHead)(toolResult.content, headChars) + `
 
 [... ${omitted} characters trimmed: this turn's combined tool results exceeded the per-turn budget. Re-run this call alone with narrower filters or offset/limit if you need the omitted content ...]
 
-` + (0, import_gg_ai.sliceTail)(toolResult.content, tailChars);
+` + (0, import_gg_ai2.sliceTail)(toolResult.content, tailChars);
     toolResult.capped = {
       originalChars: toolResult.capped?.originalChars ?? originalChars,
       keptChars: toolResult.content.length,
@@ -1881,8 +2066,8 @@ function truncateToolResultText(text, maxChars) {
   if (text.length <= maxChars) return text;
   const tailChars = Math.min(Math.floor(maxChars * 0.3), 2e4);
   const headChars = Math.max(maxChars - tailChars, 0);
-  const head = (0, import_gg_ai.sliceHead)(text, headChars);
-  const tail = (0, import_gg_ai.sliceTail)(text, tailChars);
+  const head = (0, import_gg_ai2.sliceHead)(text, headChars);
+  const tail = (0, import_gg_ai2.sliceTail)(text, tailChars);
   const omitted = text.length - head.length - tail.length;
   return `${head}
 
@@ -2031,7 +2216,7 @@ var AgentStream = class {
   rejectResult;
   hasConsumer = false;
   constructor(generator, onDone) {
-    this.events = new import_gg_ai2.EventStream();
+    this.events = new import_gg_ai3.EventStream();
     this.resultPromise = new Promise((resolve, reject) => {
       this.resolveResult = resolve;
       this.rejectResult = reject;
@@ -2077,6 +2262,7 @@ var Agent = class {
   options;
   steeringQueue = [];
   followUpQueue = [];
+  steeringListeners = /* @__PURE__ */ new Set();
   constructor(options) {
     this.options = options;
     if (options.system) {
@@ -2101,9 +2287,14 @@ var Agent = class {
   get running() {
     return this._running;
   }
-  /** Queue a steering message for injection after current tool execution completes. */
+  /**
+   * Queue a steering message. Instant interrupt: if tools are running, the
+   * interruptible ones are preempted right away and the message is injected
+   * before the next model call (the turn continues — unlike abort/Stop).
+   */
   steer(msg) {
     this.steeringQueue.push(msg);
+    for (const listener of [...this.steeringListeners]) listener();
   }
   /** Queue a follow-up message for injection when the agent would otherwise stop. */
   followUp(msg) {
@@ -2123,6 +2314,14 @@ var Agent = class {
         const all = [...callerResult ?? [], ...queued];
         return all.length > 0 ? all : null;
       },
+      onSteeringAvailable: (listener) => {
+        this.steeringListeners.add(listener);
+        const unsubscribeCaller = this.options.onSteeringAvailable?.(listener);
+        return () => {
+          this.steeringListeners.delete(listener);
+          unsubscribeCaller?.();
+        };
+      },
       getFollowUpMessages: async () => {
         const callerResult = await this.options.getFollowUpMessages?.() ?? [];
         const queued = this.followUpQueue.splice(0);