@agent-native/core 0.122.4 → 0.123.0

package/src/agent/engine/tool-call-journal-seed.ts

@@ -47,6 +47,7 @@ export interface PriorTurnToolResultSummary {
  */
 export async function loadPriorTurnToolCallJournal(
   threadId: string | undefined,
+  turnId?: string,
 ): Promise<{
   toolCallJournal: ToolCallJournal | null;
   priorToolCalls: PriorTurnToolCallSummary[];
@@ -59,7 +60,7 @@ export async function loadPriorTurnToolCallJournal(
     return { toolCallJournal, priorToolCalls, priorToolResults };
   }
   try {
-    const priorEvents = await getCurrentTurnEventsForThread(threadId);
+    const priorEvents = await getCurrentTurnEventsForThread(threadId, turnId);
     if (priorEvents.length > 0) {
       for (const event of priorEvents) {
         if (event.type === "tool_start") {

package/src/agent/engine/translate-anthropic.ts

@@ -589,6 +589,105 @@ export function anthropicChunkToEngineEvents(
   return events;
 }
 
+// ---------------------------------------------------------------------------
+// Streamed tool-input reconciliation (shared by every engine adapter)
+// ---------------------------------------------------------------------------
+
+/**
+ * Tool arguments arrive split across an arbitrary number of deltas. Every
+ * engine announces a tool call the moment the first delta lands, so a stream
+ * that dies mid-arguments leaves the turn advertising a call it never
+ * delivered. Accumulating the delta text is the only way to tell "assembled
+ * fine" from "cut off", instead of dropping the call and reporting success.
+ */
+export interface StreamedToolInputState {
+  byId: Map<string, { name: string; text: string; delivered: boolean }>;
+}
+
+export function createStreamedToolInputState(): StreamedToolInputState {
+  return { byId: new Map() };
+}
+
+/**
+ * Feed an engine's own outgoing event into the accumulator. Works for every
+ * adapter because they all emit the same normalized progress events.
+ */
+export function observeStreamedToolInput(
+  state: StreamedToolInputState,
+  event: EngineEvent,
+): void {
+  if (event.type === "tool-input-start" || event.type === "tool-input-delta") {
+    const id = event.id;
+    if (!id) return;
+    const existing = state.byId.get(id);
+    const text = (event.type === "tool-input-delta" && event.text) || "";
+    if (existing) {
+      if (!existing.name && event.name) existing.name = event.name;
+      existing.text += text;
+      return;
+    }
+    state.byId.set(id, { name: event.name ?? "", text, delivered: false });
+    return;
+  }
+  if (event.type === "tool-call" || event.type === "tool-call-error") {
+    markStreamedToolInputDelivered(state, event.id);
+  }
+}
+
+export function markStreamedToolInputDelivered(
+  state: StreamedToolInputState,
+  id: string,
+): void {
+  const existing = state.byId.get(id);
+  if (existing) existing.delivered = true;
+  else state.byId.set(id, { name: "", text: "", delivered: true });
+}
+
+const TRUNCATED_TOOL_INPUT_ERROR =
+  "The arguments never finished streaming, so this call was not executed and nothing changed. Call the tool again with complete arguments.";
+
+/**
+ * Reconcile what the stream announced against what it actually delivered.
+ * Announced calls whose accumulated arguments parse are handed back as real
+ * tool calls; the rest become in-band tool-call errors the model can read and
+ * retry from. Nothing is dropped.
+ */
+export function finalizeStreamedToolInputs(
+  state: StreamedToolInputState,
+  deliveredIds: Iterable<string> = [],
+): EngineEvent[] {
+  for (const id of deliveredIds) markStreamedToolInputDelivered(state, id);
+  const events: EngineEvent[] = [];
+  for (const [id, entry] of state.byId) {
+    if (entry.delivered) continue;
+    const input = parseStreamedToolInput(entry.text);
+    if (input !== undefined) {
+      events.push({ type: "tool-call", id, name: entry.name, input });
+    } else {
+      events.push({
+        type: "tool-call-error",
+        id,
+        name: entry.name || "unknown-tool",
+        input: entry.text,
+        error: TRUNCATED_TOOL_INPUT_ERROR,
+      });
+    }
+  }
+  return events;
+}
+
+function parseStreamedToolInput(
+  text: string,
+): Record<string, unknown> | undefined {
+  if (!text.trim()) return undefined;
+  try {
+    const parsed = JSON.parse(text);
+    return isRecord(parsed) ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Build tool_result blocks to append to messages after tool dispatch
 // ---------------------------------------------------------------------------

package/src/agent/loop-settings.ts

@@ -9,10 +9,32 @@ import {
 } from "../settings/index.js";
 
 export const AGENT_LOOP_SETTINGS_KEY = "agent-loop";
-export const DEFAULT_AGENT_MAX_ITERATIONS = 100;
+/**
+ * Now that the budget is terminal rather than self-resetting, this has to clear
+ * real deep work: production contains a legitimate 117-tool-call analysis, so
+ * the old 100 would have cut it off. Runaway turns are caught by repetition
+ * detection (`MAX_IDENTICAL_TOOL_CALLS`), not by this ceiling.
+ */
+export const DEFAULT_AGENT_MAX_ITERATIONS = 400;
 export const MIN_AGENT_MAX_ITERATIONS = 1;
 export const MAX_AGENT_MAX_ITERATIONS = 1000;
 
+/**
+ * Per-TURN input-token ceiling. Iteration count and wall clock alone do not
+ * bound spend: cost grows quadratically with tool-call count because every
+ * retained tool result is re-sent on each iteration. A measured worst-case
+ * production chunk consumed 16.06M input tokens; a normal turn is well under
+ * 150k.
+ *
+ * Deliberately set ABOVE that worst case: this is a runaway backstop, not a
+ * work limit. A deep multi-source analysis is allowed to be expensive — the
+ * cheap-query-that-spirals case it was meant to catch is caught earlier and
+ * more precisely by repetition detection.
+ */
+export const DEFAULT_AGENT_MAX_RUN_INPUT_TOKENS = 20_000_000;
+export const MIN_AGENT_MAX_RUN_INPUT_TOKENS = 10_000;
+export const MAX_AGENT_MAX_RUN_INPUT_TOKENS = 200_000_000;
+
 export type AgentLoopSettingsScope = "org" | "user" | "default";
 export type AgentLoopSettingsSource = "org" | "user" | "env" | "default";
 
@@ -21,6 +43,9 @@ export interface AgentLoopSettings {
   defaultMaxIterations: number;
   minMaxIterations: number;
   maxMaxIterations: number;
+  /** Per-turn input-token ceiling — see DEFAULT_AGENT_MAX_RUN_INPUT_TOKENS. */
+  maxRunInputTokens: number;
+  defaultMaxRunInputTokens: number;
   scope: AgentLoopSettingsScope;
   source: AgentLoopSettingsSource;
 }
@@ -72,6 +97,47 @@ export function validateMaxIterationsInput(
   return { ok: true, value: parsed };
 }
 
+export function normalizeMaxRunInputTokens(
+  value: unknown,
+  fallback = DEFAULT_AGENT_MAX_RUN_INPUT_TOKENS,
+): number {
+  const parsed = parseInteger(value);
+  if (parsed == null) return fallback;
+  return Math.min(
+    MAX_AGENT_MAX_RUN_INPUT_TOKENS,
+    Math.max(MIN_AGENT_MAX_RUN_INPUT_TOKENS, parsed),
+  );
+}
+
+export function validateMaxRunInputTokensInput(
+  value: unknown,
+): { ok: true; value: number } | { ok: false; error: string } {
+  const parsed = parseInteger(value);
+  if (parsed == null) {
+    return { ok: false, error: "maxRunInputTokens must be an integer." };
+  }
+  if (parsed < MIN_AGENT_MAX_RUN_INPUT_TOKENS) {
+    return {
+      ok: false,
+      error: `maxRunInputTokens must be at least ${MIN_AGENT_MAX_RUN_INPUT_TOKENS}.`,
+    };
+  }
+  if (parsed > MAX_AGENT_MAX_RUN_INPUT_TOKENS) {
+    return {
+      ok: false,
+      error: `maxRunInputTokens must be at most ${MAX_AGENT_MAX_RUN_INPUT_TOKENS}.`,
+    };
+  }
+  return { ok: true, value: parsed };
+}
+
+export function getDefaultMaxRunInputTokens(): number {
+  return normalizeMaxRunInputTokens(
+    process.env.AGENT_MAX_RUN_INPUT_TOKENS,
+    DEFAULT_AGENT_MAX_RUN_INPUT_TOKENS,
+  );
+}
+
 function envDefaultSource(): AgentLoopSettingsSource {
   return parseInteger(process.env.AGENT_MAX_ITERATIONS) == null
     ? "default"
@@ -91,8 +157,11 @@ function fromStored(
   scope: AgentLoopSettingsScope,
 ): AgentLoopSettings {
   const defaultMaxIterations = getDefaultMaxIterations();
+  const defaultMaxRunInputTokens = getDefaultMaxRunInputTokens();
   const hasStoredValue =
     stored && Object.prototype.hasOwnProperty.call(stored, "maxIterations");
+  const hasStoredTokenValue =
+    stored && Object.prototype.hasOwnProperty.call(stored, "maxRunInputTokens");
   return {
     maxIterations: hasStoredValue
       ? normalizeMaxIterations(stored.maxIterations, defaultMaxIterations)
@@ -100,6 +169,13 @@ function fromStored(
     defaultMaxIterations,
     minMaxIterations: MIN_AGENT_MAX_ITERATIONS,
     maxMaxIterations: MAX_AGENT_MAX_ITERATIONS,
+    maxRunInputTokens: hasStoredTokenValue
+      ? normalizeMaxRunInputTokens(
+          stored.maxRunInputTokens,
+          defaultMaxRunInputTokens,
+        )
+      : defaultMaxRunInputTokens,
+    defaultMaxRunInputTokens,
     scope,
     source: hasStoredValue ? source : envDefaultSource(),
   };
@@ -125,16 +201,29 @@ export async function readAgentLoopSettings(ctx: {
 export async function writeAgentLoopSettings(
   ctx: { userEmail?: string | null; orgId?: string | null },
   maxIterations: number,
+  maxRunInputTokens?: number,
 ): Promise<AgentLoopSettings> {
   const validation = validateMaxIterationsInput(maxIterations);
   if (validation.ok === false) {
     throw new Error(validation.error);
   }
 
+  let tokenValue: number | undefined;
+  if (maxRunInputTokens !== undefined) {
+    const tokenValidation = validateMaxRunInputTokensInput(maxRunInputTokens);
+    if (tokenValidation.ok === false) {
+      throw new Error(tokenValidation.error);
+    }
+    tokenValue = tokenValidation.value;
+  }
+
+  const stored = {
+    maxIterations: validation.value,
+    ...(tokenValue === undefined ? {} : { maxRunInputTokens: tokenValue }),
+  };
+
   if (ctx.orgId) {
-    await putOrgSetting(ctx.orgId, AGENT_LOOP_SETTINGS_KEY, {
-      maxIterations: validation.value,
-    });
+    await putOrgSetting(ctx.orgId, AGENT_LOOP_SETTINGS_KEY, stored);
     return readAgentLoopSettings(ctx);
   }
 
@@ -142,9 +231,7 @@ export async function writeAgentLoopSettings(
     throw new Error("Authentication required to update agent loop settings.");
   }
 
-  await putUserSetting(ctx.userEmail, AGENT_LOOP_SETTINGS_KEY, {
-    maxIterations: validation.value,
-  });
+  await putUserSetting(ctx.userEmail, AGENT_LOOP_SETTINGS_KEY, stored);
   return readAgentLoopSettings(ctx);
 }