@prestyj/agent 4.2.16 → 4.2.45

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Nolan Grout
+Copyright (c) 2025 KenKai
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -11,7 +11,7 @@
 
 Give an LLM tools. It calls them. Results go back in. It loops until it's done. That's it.
 
-Built on top of [`@prestyj/ai`](../ai/README.md). Part of the [EZCoder](../../README.md) monorepo.
+Built on top of [`@prestyj/ai`](../ai/README.md). Part of the [EZCoder Framework](../../README.md) monorepo.
 
 ---
 

package/dist/index.cjs

@@ -23,6 +23,8 @@ __export(index_exports, {
   Agent: () => Agent,
   AgentStream: () => AgentStream,
   agentLoop: () => agentLoop,
+  isAbortError: () => isAbortError,
+  isBillingError: () => isBillingError,
   isContextOverflow: () => isContextOverflow
 });
 module.exports = __toCommonJS(index_exports);
@@ -33,17 +35,26 @@ var import_ai2 = require("@prestyj/ai");
 // src/agent-loop.ts
 var import_ai = require("@prestyj/ai");
 var DEFAULT_MAX_TURNS = 100;
+function isAbortError(err) {
+  if (!(err instanceof Error)) return false;
+  if (err.name === "AbortError") return true;
+  const msg = err.message.toLowerCase();
+  return msg.includes("aborted") || msg.includes("abort");
+}
 function isContextOverflow(err) {
   if (!(err instanceof Error)) return false;
   const msg = err.message.toLowerCase();
   return msg.includes("prompt is too long") || msg.includes("context_length_exceeded") || msg.includes("maximum context length") || msg.includes("token") && msg.includes("exceed");
 }
+function isBillingError(err) {
+  if (!(err instanceof Error)) return false;
+  const msg = err.message.toLowerCase();
+  return msg.includes("insufficient balance") || msg.includes("no resource package") || msg.includes("quota exceeded") || msg.includes("billing") || msg.includes("recharge");
+}
 function isOverloaded(err) {
   if (!(err instanceof Error)) return false;
+  if (isBillingError(err)) return false;
   const msg = err.message.toLowerCase();
-  if (msg.includes("insufficient balance") || msg.includes("quota exceeded") || msg.includes("billing")) {
-    return false;
-  }
   return msg.includes("overloaded") || msg.includes("rate limit") || msg.includes("too many requests") || msg.includes("429") || msg.includes("529");
 }
 async function* agentLoop(messages, options) {
@@ -55,217 +66,263 @@ async function* agentLoop(messages, options) {
   let consecutivePauses = 0;
   let overflowRetries = 0;
   let overloadRetries = 0;
+  let emptyResponseRetries = 0;
   const MAX_OVERFLOW_RETRIES = 3;
   const MAX_OVERLOAD_RETRIES = 3;
+  const MAX_EMPTY_RESPONSE_RETRIES = 3;
   const OVERLOAD_RETRY_DELAY_MS = 3e3;
-  while (turn < maxTurns) {
-    options.signal?.throwIfAborted();
-    turn++;
-    if (options.transformContext) {
-      const transformed = await options.transformContext(messages);
-      if (transformed !== messages) {
-        messages.length = 0;
-        messages.push(...transformed);
-      }
-    }
-    let response;
-    try {
-      const result = (0, import_ai.stream)({
-        provider: options.provider,
-        model: options.model,
-        messages,
-        tools: options.tools,
-        serverTools: options.serverTools,
-        webSearch: options.webSearch,
-        maxTokens: options.maxTokens,
-        temperature: options.temperature,
-        thinking: options.thinking,
-        apiKey: options.apiKey,
-        baseUrl: options.baseUrl,
-        signal: options.signal,
-        accountId: options.accountId,
-        cacheRetention: options.cacheRetention,
-        compaction: options.compaction
-      });
-      result.response.catch(() => {
-      });
-      for await (const event of result) {
-        if (event.type === "text_delta") {
-          yield { type: "text_delta", text: event.text };
-        } else if (event.type === "thinking_delta") {
-          yield { type: "thinking_delta", text: event.text };
-        } else if (event.type === "server_toolcall") {
-          yield {
-            type: "server_tool_call",
-            id: event.id,
-            name: event.name,
-            input: event.input
-          };
-        } else if (event.type === "server_toolresult") {
-          yield {
-            type: "server_tool_result",
-            toolUseId: event.toolUseId,
-            resultType: event.resultType,
-            data: event.data
-          };
-        }
-      }
-      response = await result.response;
-    } catch (err) {
-      if (overflowRetries < MAX_OVERFLOW_RETRIES && isContextOverflow(err) && options.transformContext) {
-        overflowRetries++;
-        const transformed = await options.transformContext(messages, { force: true });
+  try {
+    while (turn < maxTurns) {
+      options.signal?.throwIfAborted();
+      turn++;
+      if (options.transformContext) {
+        const transformed = await options.transformContext(messages);
         if (transformed !== messages) {
           messages.length = 0;
           messages.push(...transformed);
         }
-        turn--;
-        continue;
       }
-      if (overloadRetries < MAX_OVERLOAD_RETRIES && isOverloaded(err)) {
-        overloadRetries++;
-        await new Promise((r) => setTimeout(r, OVERLOAD_RETRY_DELAY_MS));
-        turn--;
-        continue;
+      let response;
+      try {
+        const result = (0, import_ai.stream)({
+          provider: options.provider,
+          model: options.model,
+          messages,
+          tools: options.tools,
+          serverTools: options.serverTools,
+          webSearch: options.webSearch,
+          maxTokens: options.maxTokens,
+          temperature: options.temperature,
+          thinking: options.thinking,
+          apiKey: options.apiKey,
+          baseUrl: options.baseUrl,
+          signal: options.signal,
+          accountId: options.accountId,
+          cacheRetention: options.cacheRetention,
+          compaction: options.compaction
+        });
+        result.response.catch(() => {
+        });
+        for await (const event of result) {
+          if (event.type === "text_delta") {
+            yield { type: "text_delta", text: event.text };
+          } else if (event.type === "thinking_delta") {
+            yield { type: "thinking_delta", text: event.text };
+          } else if (event.type === "server_toolcall") {
+            yield {
+              type: "server_tool_call",
+              id: event.id,
+              name: event.name,
+              input: event.input
+            };
+          } else if (event.type === "server_toolresult") {
+            yield {
+              type: "server_tool_result",
+              toolUseId: event.toolUseId,
+              resultType: event.resultType,
+              data: event.data
+            };
+          }
+        }
+        response = await result.response;
+      } catch (err) {
+        if (overflowRetries < MAX_OVERFLOW_RETRIES && isContextOverflow(err) && options.transformContext) {
+          overflowRetries++;
+          const transformed = await options.transformContext(messages, { force: true });
+          if (transformed !== messages) {
+            messages.length = 0;
+            messages.push(...transformed);
+          }
+          turn--;
+          continue;
+        }
+        if (overloadRetries < MAX_OVERLOAD_RETRIES && isOverloaded(err)) {
+          overloadRetries++;
+          await new Promise((r) => setTimeout(r, OVERLOAD_RETRY_DELAY_MS));
+          turn--;
+          continue;
+        }
+        if (isAbortError(err) || options.signal?.aborted) {
+          break;
+        }
+        throw err;
       }
-      throw err;
-    }
-    overflowRetries = 0;
-    overloadRetries = 0;
-    totalUsage.inputTokens += response.usage.inputTokens;
-    totalUsage.outputTokens += response.usage.outputTokens;
-    if (response.usage.cacheRead) {
-      totalUsage.cacheRead = (totalUsage.cacheRead ?? 0) + response.usage.cacheRead;
-    }
-    if (response.usage.cacheWrite) {
-      totalUsage.cacheWrite = (totalUsage.cacheWrite ?? 0) + response.usage.cacheWrite;
-    }
-    messages.push(response.message);
-    yield {
-      type: "turn_end",
-      turn,
-      stopReason: response.stopReason,
-      usage: response.usage
-    };
-    if (response.stopReason === "pause_turn") {
-      consecutivePauses++;
-      if (consecutivePauses >= maxContinuations) {
-        break;
+      overflowRetries = 0;
+      overloadRetries = 0;
+      if (response.usage.outputTokens === 0 && (response.message.content === "" || Array.isArray(response.message.content) && response.message.content.length === 0)) {
+        if (emptyResponseRetries < MAX_EMPTY_RESPONSE_RETRIES) {
+          emptyResponseRetries++;
+          turn--;
+          continue;
+        }
       }
-      continue;
-    }
-    consecutivePauses = 0;
-    if (response.stopReason !== "tool_use") {
+      emptyResponseRetries = 0;
+      totalUsage.inputTokens += response.usage.inputTokens;
+      totalUsage.outputTokens += response.usage.outputTokens;
+      if (response.usage.cacheRead) {
+        totalUsage.cacheRead = (totalUsage.cacheRead ?? 0) + response.usage.cacheRead;
+      }
+      if (response.usage.cacheWrite) {
+        totalUsage.cacheWrite = (totalUsage.cacheWrite ?? 0) + response.usage.cacheWrite;
+      }
+      messages.push(response.message);
       yield {
-        type: "agent_done",
-        totalTurns: turn,
-        totalUsage: { ...totalUsage }
-      };
-      return {
-        message: response.message,
-        totalTurns: turn,
-        totalUsage: { ...totalUsage }
+        type: "turn_end",
+        turn,
+        stopReason: response.stopReason,
+        usage: response.usage
       };
-    }
-    const allToolCalls = extractToolCalls(response.message.content);
-    const toolCalls = [];
-    const toolResults = [];
-    for (const tc of allToolCalls) {
-      if (tc.name.startsWith("$")) {
-        toolResults.push({
-          type: "tool_result",
-          toolCallId: tc.id,
-          content: JSON.stringify(tc.args)
-        });
-      } else {
-        toolCalls.push(tc);
+      if (response.stopReason === "pause_turn") {
+        consecutivePauses++;
+        if (consecutivePauses >= maxContinuations) {
+          break;
+        }
+        continue;
       }
-    }
-    const eventStream = new import_ai.EventStream();
-    const executions = toolCalls.map(async (toolCall) => {
-      const startTime = Date.now();
-      eventStream.push({
-        type: "tool_call_start",
-        toolCallId: toolCall.id,
-        name: toolCall.name,
-        args: toolCall.args
-      });
-      let resultContent;
-      let details;
-      let isError = false;
-      const tool = toolMap.get(toolCall.name);
-      if (!tool) {
-        resultContent = `Unknown tool: ${toolCall.name}`;
-        isError = true;
-      } else {
-        try {
-          const parsed = tool.parameters.parse(toolCall.args);
-          const ctx = {
-            signal: options.signal ?? AbortSignal.timeout(3e5),
-            toolCallId: toolCall.id,
-            onUpdate: (update) => {
-              eventStream.push({
-                type: "tool_call_update",
-                toolCallId: toolCall.id,
-                update
-              });
+      consecutivePauses = 0;
+      const allToolCalls = extractToolCalls(response.message.content);
+      if (response.stopReason !== "tool_use" && allToolCalls.length === 0) {
+        if (options.getSteeringMessages) {
+          const steering = await options.getSteeringMessages();
+          if (steering && steering.length > 0) {
+            for (const msg of steering) {
+              yield { type: "steering_message", content: msg.content };
+              messages.push(msg);
             }
-          };
-          const raw = await tool.execute(parsed, ctx);
-          const normalized = normalizeToolResult(raw);
-          resultContent = normalized.content;
-          details = normalized.details;
-        } catch (err) {
-          isError = true;
-          resultContent = err instanceof Error ? err.message : String(err);
+            continue;
+          }
         }
+        yield {
+          type: "agent_done",
+          totalTurns: turn,
+          totalUsage: { ...totalUsage }
+        };
+        return {
+          message: response.message,
+          totalTurns: turn,
+          totalUsage: { ...totalUsage }
+        };
       }
-      const durationMs = Date.now() - startTime;
-      eventStream.push({
-        type: "tool_call_end",
-        toolCallId: toolCall.id,
-        result: resultContent,
-        details,
-        isError,
-        durationMs
-      });
-      return { toolCallId: toolCall.id, content: resultContent, isError };
-    });
-    const abortHandler = () => eventStream.abort(new Error("aborted"));
-    options.signal?.addEventListener("abort", abortHandler, { once: true });
-    let toolResultsFinalized = false;
-    Promise.all(executions).then((results) => {
-      if (toolResultsFinalized) return;
-      for (const tc of toolCalls) {
-        const r = results.find((x) => x.toolCallId === tc.id);
-        toolResults.push({
-          type: "tool_result",
-          toolCallId: tc.id,
-          content: r.content,
-          isError: r.isError || void 0
-        });
-      }
-      eventStream.close();
-    }).catch((err) => eventStream.abort(err instanceof Error ? err : new Error(String(err))));
-    try {
-      for await (const event of eventStream) {
-        yield event;
+      const toolCalls = [];
+      const toolResults = [];
+      for (const tc of allToolCalls) {
+        if (tc.name.startsWith("$")) {
+          toolResults.push({
+            type: "tool_result",
+            toolCallId: tc.id,
+            content: JSON.stringify(tc.args)
+          });
+        } else {
+          toolCalls.push(tc);
+        }
       }
-    } finally {
-      options.signal?.removeEventListener("abort", abortHandler);
-      toolResultsFinalized = true;
-      for (const tc of toolCalls) {
-        if (!toolResults.some((r) => r.toolCallId === tc.id)) {
+      const eventStream = new import_ai.EventStream();
+      const executions = toolCalls.map(async (toolCall) => {
+        const startTime = Date.now();
+        eventStream.push({
+          type: "tool_call_start",
+          toolCallId: toolCall.id,
+          name: toolCall.name,
+          args: toolCall.args
+        });
+        let resultContent;
+        let details;
+        let isError = false;
+        const tool = toolMap.get(toolCall.name);
+        if (!tool) {
+          resultContent = `Unknown tool: ${toolCall.name}`;
+          isError = true;
+        } else {
+          try {
+            const parsed = tool.parameters.parse(toolCall.args);
+            const ctx = {
+              signal: options.signal ?? AbortSignal.timeout(3e5),
+              toolCallId: toolCall.id,
+              onUpdate: (update) => {
+                eventStream.push({
+                  type: "tool_call_update",
+                  toolCallId: toolCall.id,
+                  update
+                });
+              }
+            };
+            const raw = await tool.execute(parsed, ctx);
+            const normalized = normalizeToolResult(raw);
+            resultContent = normalized.content;
+            details = normalized.details;
+          } catch (err) {
+            isError = true;
+            resultContent = err instanceof Error ? err.message : String(err);
+          }
+        }
+        const durationMs = Date.now() - startTime;
+        eventStream.push({
+          type: "tool_call_end",
+          toolCallId: toolCall.id,
+          result: resultContent,
+          details,
+          isError,
+          durationMs
+        });
+        return { toolCallId: toolCall.id, content: resultContent, isError };
+      });
+      const abortHandler = () => eventStream.abort(new Error("aborted"));
+      options.signal?.addEventListener("abort", abortHandler, { once: true });
+      let toolResultsFinalized = false;
+      Promise.all(executions).then((results) => {
+        if (toolResultsFinalized) return;
+        const resultsMap = new Map(results.map((r) => [r.toolCallId, r]));
+        for (const tc of toolCalls) {
+          const r = resultsMap.get(tc.id);
           toolResults.push({
             type: "tool_result",
             toolCallId: tc.id,
-            content: "Tool execution was aborted.",
-            isError: true
+            content: r.content,
+            isError: r.isError || void 0
           });
         }
+        eventStream.close();
+      }).catch((err) => eventStream.abort(err instanceof Error ? err : new Error(String(err))));
+      let toolsAborted = false;
+      try {
+        for await (const event of eventStream) {
+          yield event;
+        }
+      } catch (err) {
+        if (isAbortError(err) || options.signal?.aborted) {
+          toolsAborted = true;
+        } else {
+          throw err;
+        }
+      } finally {
+        options.signal?.removeEventListener("abort", abortHandler);
+        toolResultsFinalized = true;
+        const resolvedIds = new Set(toolResults.map((r) => r.toolCallId));
+        for (const tc of toolCalls) {
+          if (!resolvedIds.has(tc.id)) {
+            toolResults.push({
+              type: "tool_result",
+              toolCallId: tc.id,
+              content: "Tool execution was aborted.",
+              isError: true
+            });
+          }
+        }
+        messages.push({ role: "tool", content: toolResults });
+      }
+      if (toolsAborted) break;
+      if (options.getSteeringMessages) {
+        const steering = await options.getSteeringMessages();
+        if (steering && steering.length > 0) {
+          for (const msg of steering) {
+            yield { type: "steering_message", content: msg.content };
+            messages.push(msg);
+          }
+        }
       }
-      messages.push({ role: "tool", content: toolResults });
     }
+  } finally {
+    sanitizeOrphanedServerTools(messages);
   }
   let lastAssistant;
   for (let i = messages.length - 1; i >= 0; i--) {
@@ -292,6 +349,33 @@ function extractToolCalls(content) {
   if (typeof content === "string") return [];
   return content.filter((part) => part.type === "tool_call");
 }
+function sanitizeOrphanedServerTools(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role !== "assistant") continue;
+    if (typeof msg.content === "string" || !Array.isArray(msg.content)) break;
+    const serverToolIds = /* @__PURE__ */ new Set();
+    const resultToolIds = /* @__PURE__ */ new Set();
+    for (const part of msg.content) {
+      if (part.type === "server_tool_call") serverToolIds.add(part.id);
+      if (part.type === "server_tool_result") resultToolIds.add(part.toolUseId);
+    }
+    const orphanedIds = /* @__PURE__ */ new Set();
+    for (const id of serverToolIds) {
+      if (!resultToolIds.has(id)) orphanedIds.add(id);
+    }
+    if (orphanedIds.size === 0) break;
+    const filtered = msg.content.filter(
+      (part) => !(part.type === "server_tool_call" && orphanedIds.has(part.id))
+    );
+    if (filtered.length === 0) {
+      messages.splice(i, 1);
+    } else {
+      msg.content = filtered;
+    }
+    break;
+  }
+}
 
 // src/agent.ts
 var AgentStream = class {
@@ -371,6 +455,8 @@ var Agent = class {
   Agent,
   AgentStream,
   agentLoop,
+  isAbortError,
+  isBillingError,
   isContextOverflow
 });
 //# sourceMappingURL=index.cjs.map