@kenkaiiii/gg-agent 5.49.9 → 5.49.11

package/dist/index.d.cts

@@ -401,6 +401,20 @@ declare function isBillingError(err: unknown): boolean;
  */
 declare function isUsageLimitError(err: unknown): boolean;
 declare function agentLoop(messages: Message[], options: AgentOptions): AsyncGenerator<AgentEvent, AgentResult>;
+/**
+ * A tool call that never reached its tool. Nothing ran, so nothing changed.
+ */
+declare function cancelledBeforeStartText(name: string): string;
+/**
+ * A tool call that started running and was cut off before reporting back.
+ *
+ * The distinction from {@link cancelledBeforeStartText} is the whole point: a
+ * dispatched `git push`, deploy or MCP call may well have COMPLETED before the
+ * abort landed. Telling the model it was "interrupted" reads as "it did not
+ * happen", so the model repeats the side effect — or reports to the user that
+ * something never ran when it did.
+ */
+declare function indeterminateOutcomeText(name: string): string;
 
 /**
  * A local inference server (llama.cpp, vLLM, Ollama, LM Studio) can spend
@@ -411,4 +425,4 @@ declare function agentLoop(messages: Message[], options: AgentOptions): AsyncGen
  */
 declare function isLocalBackendUrl(baseUrl?: string): boolean;
 
-export { Agent, type AgentDoneEvent, type AgentErrorEvent, type AgentEvent, type AgentFollowUpMessageEvent, type AgentOptions, type AgentResult, type AgentRetryEvent, type AgentServerToolCallEvent, type AgentServerToolResultEvent, type AgentSteeringMessageEvent, AgentStream, type AgentTextDeltaEvent, type AgentThinkingDeltaEvent, type AgentTool, type AgentToolCallDeltaEvent, type AgentToolCallEndEvent, type AgentToolCallStartEvent, type AgentToolCallUpdateEvent, type AgentTurnEndEvent, type AgentTurnTiming, type StreamDiagnosticFn, type StructuredToolResult, type ToolContext, type ToolExecuteResult, type ToolExecutionMode, type TransformContextOptions, agentLoop, isAbortError, isBillingError, isContextOverflow, isLocalBackendUrl, isUsageLimitError, setStreamDiagnostic };
+export { Agent, type AgentDoneEvent, type AgentErrorEvent, type AgentEvent, type AgentFollowUpMessageEvent, type AgentOptions, type AgentResult, type AgentRetryEvent, type AgentServerToolCallEvent, type AgentServerToolResultEvent, type AgentSteeringMessageEvent, AgentStream, type AgentTextDeltaEvent, type AgentThinkingDeltaEvent, type AgentTool, type AgentToolCallDeltaEvent, type AgentToolCallEndEvent, type AgentToolCallStartEvent, type AgentToolCallUpdateEvent, type AgentTurnEndEvent, type AgentTurnTiming, type StreamDiagnosticFn, type StructuredToolResult, type ToolContext, type ToolExecuteResult, type ToolExecutionMode, type TransformContextOptions, agentLoop, cancelledBeforeStartText, indeterminateOutcomeText, isAbortError, isBillingError, isContextOverflow, isLocalBackendUrl, isUsageLimitError, setStreamDiagnostic };

package/dist/index.d.ts

@@ -401,6 +401,20 @@ declare function isBillingError(err: unknown): boolean;
  */
 declare function isUsageLimitError(err: unknown): boolean;
 declare function agentLoop(messages: Message[], options: AgentOptions): AsyncGenerator<AgentEvent, AgentResult>;
+/**
+ * A tool call that never reached its tool. Nothing ran, so nothing changed.
+ */
+declare function cancelledBeforeStartText(name: string): string;
+/**
+ * A tool call that started running and was cut off before reporting back.
+ *
+ * The distinction from {@link cancelledBeforeStartText} is the whole point: a
+ * dispatched `git push`, deploy or MCP call may well have COMPLETED before the
+ * abort landed. Telling the model it was "interrupted" reads as "it did not
+ * happen", so the model repeats the side effect — or reports to the user that
+ * something never ran when it did.
+ */
+declare function indeterminateOutcomeText(name: string): string;
 
 /**
  * A local inference server (llama.cpp, vLLM, Ollama, LM Studio) can spend
@@ -411,4 +425,4 @@ declare function agentLoop(messages: Message[], options: AgentOptions): AsyncGen
  */
 declare function isLocalBackendUrl(baseUrl?: string): boolean;
 
-export { Agent, type AgentDoneEvent, type AgentErrorEvent, type AgentEvent, type AgentFollowUpMessageEvent, type AgentOptions, type AgentResult, type AgentRetryEvent, type AgentServerToolCallEvent, type AgentServerToolResultEvent, type AgentSteeringMessageEvent, AgentStream, type AgentTextDeltaEvent, type AgentThinkingDeltaEvent, type AgentTool, type AgentToolCallDeltaEvent, type AgentToolCallEndEvent, type AgentToolCallStartEvent, type AgentToolCallUpdateEvent, type AgentTurnEndEvent, type AgentTurnTiming, type StreamDiagnosticFn, type StructuredToolResult, type ToolContext, type ToolExecuteResult, type ToolExecutionMode, type TransformContextOptions, agentLoop, isAbortError, isBillingError, isContextOverflow, isLocalBackendUrl, isUsageLimitError, setStreamDiagnostic };
+export { Agent, type AgentDoneEvent, type AgentErrorEvent, type AgentEvent, type AgentFollowUpMessageEvent, type AgentOptions, type AgentResult, type AgentRetryEvent, type AgentServerToolCallEvent, type AgentServerToolResultEvent, type AgentSteeringMessageEvent, AgentStream, type AgentTextDeltaEvent, type AgentThinkingDeltaEvent, type AgentTool, type AgentToolCallDeltaEvent, type AgentToolCallEndEvent, type AgentToolCallStartEvent, type AgentToolCallUpdateEvent, type AgentTurnEndEvent, type AgentTurnTiming, type StreamDiagnosticFn, type StructuredToolResult, type ToolContext, type ToolExecuteResult, type ToolExecutionMode, type TransformContextOptions, agentLoop, cancelledBeforeStartText, indeterminateOutcomeText, isAbortError, isBillingError, isContextOverflow, isLocalBackendUrl, isUsageLimitError, setStreamDiagnostic };

package/dist/index.js

@@ -1320,6 +1320,7 @@ async function* executeToolCallsMixed(toolCalls, initialToolResults, options) {
   const eventStream = new 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 phases = [];
@@ -1344,6 +1345,7 @@ async function* executeToolCallsMixed(toolCalls, initialToolResults, options) {
       for (const phase of phases) {
         if (options.signal?.aborted) break;
         if (phase.sequential) {
+          dispatchedIds.add(phase.sequential.id);
           const record = await executeSingleToolCall(
             phase.sequential,
             options,
@@ -1351,6 +1353,7 @@ async function* executeToolCallsMixed(toolCalls, initialToolResults, options) {
           );
           resultsById.set(record.toolCallId, record);
         } else if (phase.parallel.length === 1) {
+          dispatchedIds.add(phase.parallel[0].id);
           const record = await executeSingleToolCall(
             phase.parallel[0],
             options,
@@ -1360,6 +1363,7 @@ async function* executeToolCallsMixed(toolCalls, initialToolResults, options) {
         } else {
           await Promise.all(
             phase.parallel.map(async (toolCall) => {
+              dispatchedIds.add(toolCall.id);
               const record = await executeSingleToolCall(
                 toolCall,
                 options,
@@ -1390,7 +1394,7 @@ async function* executeToolCallsMixed(toolCalls, initialToolResults, options) {
     options.signal?.removeEventListener("abort", abortHandler);
     state.finalized = true;
   }
-  const toolResults = buildToolResults(initialToolResults, toolCalls, resultsById);
+  const toolResults = buildToolResults(initialToolResults, toolCalls, resultsById, dispatchedIds);
   capToolResults(toolResults, options.maxToolResultChars);
   capTurnToolResults(toolResults, options.maxTurnToolResultChars);
   return { toolResults, aborted };
@@ -1399,10 +1403,12 @@ async function* executeToolCallsParallel(toolCalls, initialToolResults, options)
   const eventStream = new 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,
@@ -1430,12 +1436,18 @@ async function* executeToolCallsParallel(toolCalls, initialToolResults, options)
     options.signal?.removeEventListener("abort", abortHandler);
     state.finalized = true;
   }
-  const toolResults = buildToolResults(initialToolResults, toolCalls, resultsById);
+  const toolResults = buildToolResults(initialToolResults, toolCalls, resultsById, dispatchedIds);
   capToolResults(toolResults, options.maxToolResultChars);
   capTurnToolResults(toolResults, options.maxTurnToolResultChars);
   return { toolResults, aborted };
 }
-function buildToolResults(initialToolResults, toolCalls, resultsById) {
+function cancelledBeforeStartText(name) {
+  return `\`${name}\` was cancelled before it started, so it had no effect. Safe to retry.`;
+}
+function indeterminateOutcomeText(name) {
+  return `\`${name}\` started running and was cut off before it reported back, so its outcome is UNKNOWN \u2014 it may have completed. Check the real state (re-read the file, re-run a status command) before retrying it, and do not tell the user it did not happen.`;
+}
+function buildToolResults(initialToolResults, toolCalls, resultsById, dispatchedIds) {
   const toolResults = [...initialToolResults];
   for (const toolCall of toolCalls) {
     const result = resultsById.get(toolCall.id);
@@ -1447,10 +1459,11 @@ function buildToolResults(initialToolResults, toolCalls, resultsById) {
         isError: result.isError || void 0
       });
     } else {
+      const dispatched = dispatchedIds?.has(toolCall.id) ?? true;
       toolResults.push({
         type: "tool_result",
         toolCallId: toolCall.id,
-        content: "Tool execution was aborted.",
+        content: dispatched ? indeterminateOutcomeText(toolCall.name) : cancelledBeforeStartText(toolCall.name),
         isError: true
       });
     }
@@ -1598,32 +1611,22 @@ function repairToolPairingAdjacent(messages) {
     const msg = messages[i];
     if (msg.role !== "assistant") continue;
     if (typeof msg.content === "string" || !Array.isArray(msg.content)) continue;
-    const toolCallIds = msg.content.filter((p) => p.type === "tool_call").map((p) => p.id);
-    if (toolCallIds.length === 0) continue;
+    const orphanCalls = msg.content.filter((p) => p.type === "tool_call").map((p) => p);
+    if (orphanCalls.length === 0) continue;
+    const repaired = (call) => ({
+      type: "tool_result",
+      toolCallId: call.id,
+      content: indeterminateOutcomeText(call.name),
+      isError: true
+    });
     const next = messages[i + 1];
     if (next?.role === "tool" && Array.isArray(next.content)) {
       const existingIds = new Set(next.content.map((r) => r.toolCallId));
-      const missing = toolCallIds.filter((id) => !existingIds.has(id));
-      if (missing.length > 0) {
-        for (const id of missing) {
-          next.content.push({
-            type: "tool_result",
-            toolCallId: id,
-            content: "Tool execution was interrupted.",
-            isError: true
-          });
-        }
+      for (const call of orphanCalls) {
+        if (!existingIds.has(call.id)) next.content.push(repaired(call));
       }
     } else {
-      messages.splice(i + 1, 0, {
-        role: "tool",
-        content: toolCallIds.map((id) => ({
-          type: "tool_result",
-          toolCallId: id,
-          content: "Tool execution was interrupted.",
-          isError: true
-        }))
-      });
+      messages.splice(i + 1, 0, { role: "tool", content: orphanCalls.map(repaired) });
     }
   }
   const toolCallIdSet = /* @__PURE__ */ new Set();
@@ -1782,6 +1785,8 @@ export {
   Agent,
   AgentStream,
   agentLoop,
+  cancelledBeforeStartText,
+  indeterminateOutcomeText,
   isAbortError,
   isBillingError,
   isContextOverflow,