@anvia/core 0.26.0 → 1.0.0-rc.1

package/dist/{chunk-BALBBVI3.js → chunk-IL3ZSNJI.js}

@@ -1,29 +1,37 @@
 import {
-  toReadableStream
-} from "./chunk-XUUY2L2D.js";
+  isSkillTool
+} from "./chunk-YK4WAAS4.js";
 import {
+  assertFiniteSearchThreshold,
+  assertPositiveSearchLimit,
+  isToolIndex
+} from "./chunk-6WGGTJE6.js";
+import {
+  ToolNotFoundError,
+  assertToolApprovalRequirement,
+  createTool,
   parseToolArgs,
+  prepareToolCall,
+  toolMayRequireApproval,
   toolResultContentToText
-} from "./chunk-HYUYZEAJ.js";
-import {
-  runControl,
-  toolCallControl
-} from "./chunk-2ODTMRHP.js";
+} from "./chunk-R2LJSQUW.js";
 import {
   MemoryCompactionConflictError,
   MemoryCompactionError,
   createMemoryCompactionSummary,
-  cumulativeCompactedMessageCount
-} from "./chunk-MRQLEK2B.js";
+  cumulativeCompactedMessageCount,
+  resolveMemoryOptions
+} from "./chunk-5XKDW36Z.js";
 import {
   mapWithConcurrency
-} from "./chunk-OIMLU4SF.js";
-import {
-  CompletionRequestBuilder
-} from "./chunk-Q25IWLBT.js";
+} from "./chunk-DZ3CKYTH.js";
 import {
+  createCompletionRequest,
   isStreamingCompletionModel
-} from "./chunk-MC3CCKEB.js";
+} from "./chunk-M3IOWB4Y.js";
+import {
+  toProviderJsonSchema
+} from "./chunk-RFDVKCIE.js";
 import {
   AssistantContent,
   Message,
@@ -31,16 +39,23 @@ import {
   Usage,
   assertCompletionRequestSupported,
   getAssistantGenerationMetadata,
+  isProviderTool,
   textFromAssistantContent
 } from "./chunk-ADH7NNCS.js";
+import {
+  resolveRetryOptions,
+  retryDelayMs,
+  retryErrorAttributes,
+  waitForRetry
+} from "./chunk-A3UBYTJT.js";
 import {
   appendGuardrailPolicies,
   hasEnforcedOutputGuardrails,
   runInputGuardrails,
   runOutputGuardrails
-} from "./chunk-CWUJUSOS.js";
+} from "./chunk-FNQB2JEH.js";
 
-// src/request/errors.ts
+// src/agent/errors.ts
 var MaxTurnsError = class extends Error {
   constructor(maxTurns, chatHistory, prompt) {
     super(`Reached max turn limit: ${maxTurns}`);
@@ -53,1657 +68,1904 @@ var MaxTurnsError = class extends Error {
   chatHistory;
   prompt;
 };
-var PromptCancelledError = class extends Error {
+var AgentRunCancelledError = class extends Error {
   constructor(chatHistory, reason) {
-    super(`Prompt cancelled: ${reason}`);
+    super(`Agent run cancelled: ${reason}`);
     this.chatHistory = chatHistory;
     this.reason = reason;
-    this.name = "PromptCancelledError";
+    this.name = "AgentRunCancelledError";
   }
   chatHistory;
   reason;
 };
-var ToolApprovalRequiredError = class extends Error {
-  constructor(request) {
-    super(`Tool approval required for ${request.toolName}, but no approval handler is configured.`);
-    this.request = request;
-    this.name = "ToolApprovalRequiredError";
+
+// src/agent/tool-state.ts
+var agentToolStates = /* @__PURE__ */ new WeakMap();
+function registerAgentToolState(agent, publicState, toolsByName) {
+  agentToolStates.set(agent, { publicState, toolsByName });
+}
+function getAgentToolState(agent) {
+  return getStoredAgentToolState(agent).publicState;
+}
+function getRegisteredAgentTool(agent, toolName) {
+  return getStoredAgentToolState(agent).toolsByName.get(toolName);
+}
+function getStoredAgentToolState(agent) {
+  const state = agentToolStates.get(agent);
+  if (state === void 0) {
+    throw new TypeError("Agent tool state is unavailable.");
+  }
+  return state;
+}
+
+// src/hooks/control.ts
+function createHook(hook) {
+  return hook;
+}
+function cancelRun(reason) {
+  return { type: "terminate", reason };
+}
+function skipTool(reason) {
+  return { type: "skip", reason };
+}
+function requestToolApproval(options = {}) {
+  const action = {
+    type: "approval_request"
+  };
+  if (options.reason !== void 0) {
+    action.reason = options.reason;
+  }
+  if (options.rejectMessage !== void 0) {
+    action.rejectMessage = options.rejectMessage;
+  }
+  return action;
+}
+var runControl = {
+  continue() {
+    return { type: "continue" };
+  },
+  cancel(reason) {
+    return cancelRun(reason);
+  }
+};
+var toolCallControl = {
+  run() {
+    return { type: "continue" };
+  },
+  skip(reason) {
+    return skipTool(reason);
+  },
+  cancel(reason) {
+    return { type: "terminate", reason };
+  },
+  requestApproval(options) {
+    return requestToolApproval(options);
   }
-  request;
 };
 
-// src/internal/async-queue.ts
-function createAsyncQueue() {
-  const values = [];
-  const waiters = [];
-  let closed = false;
-  let error;
-  function flush() {
-    while (waiters.length > 0 && values.length > 0) {
-      const waiter = waiters.shift();
-      const value = values.shift();
-      if (waiter !== void 0) {
-        waiter.resolve({ value, done: false });
-      }
-    }
-    if (values.length > 0 || waiters.length === 0 || !closed) {
-      return;
-    }
-    while (waiters.length > 0) {
-      const waiter = waiters.shift();
-      if (waiter === void 0) {
-        continue;
-      }
-      if (error !== void 0) {
-        waiter.reject(error);
-      } else {
-        waiter.resolve({ value: void 0, done: true });
-      }
-    }
+// src/internal/agent-runtime/approval-details.ts
+var approvalDetails = /* @__PURE__ */ new WeakMap();
+function registerAgentApprovalRequestDetails(approval, request) {
+  approvalDetails.set(approval, request);
+}
+function getAgentApprovalRequestDetails(approval) {
+  return approvalDetails.get(approval);
+}
+
+// src/agent/context-index.ts
+function createContextIndex(index, options) {
+  const topK = assertPositiveSearchLimit(options.topK);
+  const threshold = assertFiniteSearchThreshold(options.threshold);
+  return Object.freeze({
+    ...options,
+    topK,
+    ...threshold === void 0 ? {} : { threshold },
+    kind: "context-index",
+    index
+  });
+}
+function isContextIndex(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  if (candidate.kind !== "context-index" || typeof candidate.index !== "object") {
+    return false;
   }
+  return candidate.index !== null && typeof candidate.index.search === "function";
+}
+
+// src/internal/agent-runtime/run-options.ts
+var internalAgentRunOptions = /* @__PURE__ */ Symbol("internalAgentRunOptions");
+function withInternalAgentRunOptions(options, internal) {
   return {
-    enqueue(value) {
-      if (closed) {
-        return;
-      }
-      values.push(value);
-      flush();
+    ...options,
+    [internalAgentRunOptions]: internal
+  };
+}
+function getInternalAgentRunOptions(options) {
+  return options[internalAgentRunOptions];
+}
+
+// src/agent/agent.ts
+import { z } from "zod";
+
+// src/agent/lifecycle.ts
+function composeAgentLifecycle(first, second) {
+  if (first === void 0) return second;
+  if (second === void 0) return first;
+  return {
+    async onStart(event) {
+      await first.onStart?.(lifecycleSnapshot(event));
+      await second.onStart?.(lifecycleSnapshot(event));
     },
-    close() {
-      closed = true;
-      flush();
+    async onStepFinish(event) {
+      await first.onStepFinish?.(lifecycleSnapshot(event));
+      await second.onStepFinish?.(lifecycleSnapshot(event));
     },
-    throw(thrown) {
-      closed = true;
-      error = thrown;
-      flush();
+    async onToolStart(event) {
+      await first.onToolStart?.(lifecycleSnapshot(event));
+      await second.onToolStart?.(lifecycleSnapshot(event));
     },
-    [Symbol.asyncIterator]() {
-      return {
-        next() {
-          if (values.length > 0) {
-            const value = values.shift();
-            return Promise.resolve({ value, done: false });
-          }
-          if (error !== void 0) {
-            return Promise.reject(error);
-          }
-          if (closed) {
-            return Promise.resolve({ value: void 0, done: true });
-          }
-          return new Promise((resolve, reject) => {
-            waiters.push({ resolve, reject });
-          });
-        }
-      };
+    async onToolFinish(event) {
+      await first.onToolFinish?.(lifecycleSnapshot(event));
+      await second.onToolFinish?.(lifecycleSnapshot(event));
+    },
+    async onFinish(event) {
+      await first.onFinish?.(lifecycleSnapshot(event));
+      await second.onFinish?.(lifecycleSnapshot(event));
+    },
+    async onError(event) {
+      await first.onError?.(lifecycleSnapshot(event));
+      await second.onError?.(lifecycleSnapshot(event));
     }
   };
 }
+function lifecycleSnapshot(value) {
+  try {
+    return globalThis.structuredClone(value);
+  } catch {
+    return cloneLifecycleFallback(value, /* @__PURE__ */ new WeakMap());
+  }
+}
+function cloneLifecycleFallback(value, seen) {
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  const existing = seen.get(value);
+  if (existing !== void 0) {
+    return existing;
+  }
+  if (Array.isArray(value)) {
+    const clone2 = [];
+    seen.set(value, clone2);
+    clone2.push(...value.map((item) => cloneLifecycleFallback(item, seen)));
+    return clone2;
+  }
+  if (Object.getPrototypeOf(value) !== Object.prototype) {
+    return value;
+  }
+  const clone = {};
+  seen.set(value, clone);
+  for (const [key, item] of Object.entries(value)) {
+    clone[key] = cloneLifecycleFallback(item, seen);
+  }
+  return clone;
+}
 
-// src/internal/prompt-runtime/memory.ts
-var PromptRequestMemory = class {
-  constructor(agent, memoryContext, initialHistory) {
-    this.agent = agent;
-    this.memoryContext = memoryContext;
-    this.initialHistory = initialHistory;
+// src/observability/snapshot.ts
+function observerSnapshot(value) {
+  if (containsError(value, /* @__PURE__ */ new WeakSet())) {
+    return cloneObserverFallback(value, /* @__PURE__ */ new WeakMap());
   }
-  agent;
-  memoryContext;
-  initialHistory;
-  memoryPolicy() {
-    return this.memory()?.options.savePolicy;
+  try {
+    return globalThis.structuredClone(value);
+  } catch {
+    return cloneObserverFallback(value, /* @__PURE__ */ new WeakMap());
   }
-  pendingTurnMessages(newMessages) {
-    return this.memoryPolicy() === "turn" ? [...newMessages] : [];
+}
+function cloneObserverFallback(value, seen) {
+  if (typeof value !== "object" || value === null) {
+    return value;
   }
-  async prepareRun(runId, newMessages) {
-    const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0) {
-      return {
-        history: this.initialHistory,
-        usage: Usage.empty()
-      };
-    }
-    const preparation = await this.prepareStoredHistory(memory, runId, newMessages.length);
-    const memoryHistory = preparation.history;
-    const chatHistory = [...memoryHistory, ...this.initialHistory];
-    if (memory.options.savePolicy === "message") {
-      await memory.store.append({
-        context: this.memoryContext,
-        runId,
-        turn: 1,
-        messages: newMessages
-      });
-    }
-    return {
-      ...preparation,
-      history: chatHistory
-    };
+  const existing = seen.get(value);
+  if (existing !== void 0) {
+    return existing;
   }
-  async commitMessages(runId, turn, messages, pendingTurnMessages) {
-    const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0 || messages.length === 0) {
-      return;
+  if (Array.isArray(value)) {
+    const clone2 = [];
+    seen.set(value, clone2);
+    clone2.push(...value.map((item) => cloneObserverFallback(item, seen)));
+    return clone2;
+  }
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  if (value instanceof Error) {
+    const clone2 = Object.create(Object.getPrototypeOf(value));
+    seen.set(value, clone2);
+    Object.defineProperties(clone2, {
+      name: { configurable: true, writable: true, value: value.name },
+      message: { configurable: true, writable: true, value: value.message }
+    });
+    if (value.stack !== void 0) {
+      Object.defineProperty(clone2, "stack", {
+        configurable: true,
+        writable: true,
+        value: value.stack
+      });
     }
-    if (memory.options.savePolicy === "message") {
-      await memory.store.append({
-        context: this.memoryContext,
-        runId,
-        turn,
-        messages
+    if (value.cause !== void 0) {
+      Object.defineProperty(clone2, "cause", {
+        configurable: true,
+        writable: true,
+        value: cloneObserverFallback(value.cause, seen)
       });
-    } else if (memory.options.savePolicy === "turn") {
-      pendingTurnMessages.push(...messages);
     }
-  }
-  async commitCompletedTurn(runId, turn, pendingTurnMessages) {
-    const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0 || memory.options.savePolicy !== "turn" || pendingTurnMessages.length === 0) {
-      return;
+    for (const key of Object.getOwnPropertyNames(value)) {
+      if (key === "name" || key === "message" || key === "stack" || key === "cause") continue;
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor === void 0) continue;
+      if ("value" in descriptor) {
+        descriptor.value = cloneObserverFallback(descriptor.value, seen);
+      }
+      Object.defineProperty(clone2, key, descriptor);
     }
-    await memory.store.append({
-      context: this.memoryContext,
-      runId,
-      turn,
-      messages: [...pendingTurnMessages]
-    });
-    pendingTurnMessages.length = 0;
+    return clone2;
   }
-  async commitCompletedRun(runId, turn, newMessages, pendingTurnMessages) {
-    await this.commitCompletedTurn(runId, turn, pendingTurnMessages);
-    const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0 || memory.options.savePolicy !== "run") {
-      return;
-    }
-    await memory.store.append({
-      context: this.memoryContext,
-      runId,
-      turn,
-      messages: [...newMessages]
-    });
+  if (Object.getPrototypeOf(value) !== Object.prototype) {
+    return value;
   }
-  async recordError(runId, error, newMessages) {
-    const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0) {
-      return;
-    }
-    await memory.store.recordError?.({
-      context: this.memoryContext,
-      runId,
-      error,
-      messages: [...newMessages]
-    });
+  const clone = {};
+  seen.set(value, clone);
+  for (const [key, item] of Object.entries(value)) {
+    clone[key] = cloneObserverFallback(item, seen);
   }
-  memory() {
-    return this.memoryContext === void 0 ? void 0 : this.agent.memory;
+  return clone;
+}
+function containsError(value, seen) {
+  if (typeof value !== "object" || value === null) return false;
+  if (value instanceof Error) return true;
+  if (seen.has(value)) return false;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.some((item) => containsError(item, seen));
   }
-  async prepareStoredHistory(memory, runId, incomingMessageCount) {
-    const context = this.memoryContext;
-    if (context === void 0) {
-      return { history: [], usage: Usage.empty() };
-    }
-    const options = memory.options.compaction;
-    const capability = memory.store.compaction;
-    if (options === void 0 || capability === void 0) {
-      return {
-        history: await memory.store.load(context),
-        usage: Usage.empty()
-      };
+  if (Object.getPrototypeOf(value) !== Object.prototype) return false;
+  return Object.values(value).some((item) => containsError(item, seen));
+}
+
+// src/observability/group.ts
+async function startAgentRunObservers(registrations, args, failOnObserverError) {
+  const runObservers = [];
+  for (const registration of registrations) {
+    try {
+      const runObserver = await registration.observer.startRun(observerSnapshot(args));
+      if (runObserver !== void 0) {
+        runObservers.push(runObserver);
+      }
+    } catch (error) {
+      if (failOnObserverError || registration.failOnObserverError === true) {
+        throw error;
+      }
     }
-    let usage = Usage.empty();
-    let conflictRetries = 0;
-    for (let attempt = 0; attempt <= options.conflictRetries; attempt += 1) {
-      const snapshot = await capability.load(context);
-      const compactedMessageCount = compactedPrefixLength(
-        snapshot.messages,
-        incomingMessageCount,
-        options.maxMessages,
-        options.keepRecentUserTurns
-      );
-      if (compactedMessageCount === 0) {
-        return { history: snapshot.messages, usage };
+  }
+  return new ActiveAgentRunObservers(runObservers, failOnObserverError);
+}
+var ActiveAgentRunObservers = class {
+  constructor(runObservers, failOnObserverError) {
+    this.runObservers = runObservers;
+    this.failOnObserverError = failOnObserverError;
+    this.trace = runObservers.find((observer) => observer.trace !== void 0)?.trace;
+  }
+  runObservers;
+  failOnObserverError;
+  trace;
+  async startGeneration(args) {
+    const generationObservers = [];
+    for (const runObserver of this.runObservers) {
+      if (runObserver.startGeneration === void 0) {
+        continue;
       }
-      const prefix = snapshot.messages.slice(0, compactedMessageCount);
-      let result;
       try {
-        result = await options.compactor({
-          context,
-          messages: prefix
-        });
+        const generationObserver = await runObserver.startGeneration(observerSnapshot(args));
+        if (generationObserver !== void 0) {
+          generationObservers.push(generationObserver);
+        }
       } catch (error) {
-        throw remappedCompactorError(error, usage);
-      }
-      if (result.usage !== void 0) {
-        usage = Usage.add(usage, result.usage);
+        this.handleError(error);
       }
-      const summaryText = result.summary.trim();
-      if (summaryText.length === 0) {
-        throw new MemoryCompactionError("Memory compactor returned an empty summary.", {
-          usage
-        });
+    }
+    return new ActiveGenerationObservers(generationObservers, this.failOnObserverError);
+  }
+  async startTool(args) {
+    const toolObservers = [];
+    for (const runObserver of this.runObservers) {
+      if (runObserver.startTool === void 0) {
+        continue;
       }
-      const summary = createMemoryCompactionSummary(
-        summaryText,
-        cumulativeCompactedMessageCount(prefix)
-      );
-      let commit;
       try {
-        commit = await capability.commit({
-          context,
-          revision: snapshot.revision,
-          compactedMessageCount,
-          summary,
-          runId: `memory-compaction:${runId}:${attempt + 1}`
-        });
+        const toolObserver = await runObserver.startTool(observerSnapshot(args));
+        if (toolObserver !== void 0) {
+          toolObservers.push(toolObserver);
+        }
       } catch (error) {
-        throw new MemoryCompactionError("Memory compaction store commit failed.", {
-          cause: error,
-          usage
-        });
+        this.handleError(error);
       }
-      if (commit === "committed") {
-        const retained = snapshot.messages.slice(compactedMessageCount);
-        return {
-          history: [summary, ...retained],
-          usage,
-          compaction: {
-            originalMessageCount: snapshot.messages.length,
-            compactedMessageCount,
-            retainedMessageCount: retained.length,
-            conflictRetries
-          }
-        };
+    }
+    return new ActiveToolObservers(toolObservers, this.failOnObserverError);
+  }
+  async end(args) {
+    for (const runObserver of this.runObservers) {
+      try {
+        await runObserver.end(observerSnapshot(args));
+      } catch (error) {
+        this.handleError(error);
       }
-      conflictRetries += 1;
     }
-    throw new MemoryCompactionConflictError(options.conflictRetries + 1, usage);
   }
-};
-function compactedPrefixLength(messages, incomingMessageCount, maxMessages, keepRecentUserTurns) {
-  if (messages.length + incomingMessageCount <= maxMessages) {
-    return 0;
+  async error(args) {
+    for (const runObserver of this.runObservers) {
+      if (runObserver.error === void 0) {
+        continue;
+      }
+      try {
+        await runObserver.error(observerSnapshot(args));
+      } catch (error) {
+        this.handleError(error);
+      }
+    }
   }
-  const userMessageIndexes = messages.flatMap(
-    (message, index) => message.role === "user" ? [index] : []
-  );
-  if (userMessageIndexes.length <= keepRecentUserTurns) {
-    return 0;
+  async event(args) {
+    for (const runObserver of this.runObservers) {
+      if (runObserver.event === void 0) {
+        continue;
+      }
+      try {
+        await runObserver.event(observerSnapshot(args));
+      } catch (error) {
+        this.handleError(error);
+      }
+    }
   }
-  return userMessageIndexes[userMessageIndexes.length - keepRecentUserTurns] ?? 0;
-}
-function remappedCompactorError(error, usage) {
-  if (error instanceof MemoryCompactionError) {
-    const mergedUsage = error.usage === void 0 ? usage : isEmptyUsage(usage) ? error.usage : Usage.add(usage, error.usage);
-    if (mergedUsage === error.usage || error.usage === void 0 && isEmptyUsage(usage)) {
-      return error;
+  handleError(error) {
+    if (this.failOnObserverError) {
+      throw error;
     }
-    return new MemoryCompactionError(error.message, {
-      cause: error,
-      usage: mergedUsage
-    });
   }
-  return new MemoryCompactionError("Memory compactor failed.", {
-    cause: error,
-    usage
-  });
-}
-function isEmptyUsage(usage) {
-  return usage.inputTokens === 0 && usage.outputTokens === 0 && usage.totalTokens === 0 && usage.cachedInputTokens === 0 && usage.cacheCreationInputTokens === 0;
-}
-
-// src/internal/prompt-runtime/retrieval.ts
-async function fetchDynamicContext(agent, ragText) {
-  if (ragText === void 0 || ragText.length === 0 || agent.dynamicContexts.length === 0) {
-    return [];
+};
+var ActiveGenerationObservers = class {
+  constructor(generationObservers, failOnObserverError) {
+    this.generationObservers = generationObservers;
+    this.failOnObserverError = failOnObserverError;
   }
-  const documents = [];
-  for (const registration of agent.dynamicContexts) {
-    const results = await registration.index.search({
-      query: ragText,
-      topK: registration.options.topK,
-      threshold: registration.options.threshold,
-      filter: registration.options.filter
-    });
-    for (const result of results) {
-      const formatted = registration.options.format?.(result);
-      if (formatted !== void 0) {
-        documents.push(formatted);
-      } else {
-        const metadata = formatMetadata(result.metadata);
-        const document = {
-          id: result.id,
-          text: typeof result.document === "string" ? result.document : JSON.stringify(result.document, null, 2)
-        };
-        if (metadata !== void 0) {
-          document.additionalProps = metadata;
-        }
-        documents.push(document);
+  generationObservers;
+  failOnObserverError;
+  async end(args) {
+    for (const observer of this.generationObservers) {
+      try {
+        await observer.end(observerSnapshot(args));
+      } catch (error) {
+        this.handleError(error);
       }
     }
   }
-  return documents;
-}
-async function fetchToolDefinitions(agent, ragText) {
-  const staticDefinitions = await agent.toolSet.getToolDefinitions(ragText);
-  if (ragText === void 0 || ragText.length === 0 || agent.dynamicTools.length === 0) {
-    return staticDefinitions;
+  async error(args) {
+    for (const observer of this.generationObservers) {
+      if (observer.error === void 0) {
+        continue;
+      }
+      try {
+        await observer.error(observerSnapshot(args));
+      } catch (error) {
+        this.handleError(error);
+      }
+    }
   }
-  const definitions = [...staticDefinitions];
-  const names = new Set(staticDefinitions.map((definition) => definition.name));
-  for (const registration of agent.dynamicTools) {
-    const results = await registration.index.search({
-      query: ragText,
-      topK: registration.options.topK,
-      threshold: registration.options.threshold,
-      filter: registration.options.filter
-    });
-    for (const result of results) {
-      if (names.has(result.document.toolName)) {
+  async update(args) {
+    for (const observer of this.generationObservers) {
+      if (observer.update === void 0) {
         continue;
       }
-      names.add(result.document.toolName);
-      definitions.push(result.document.definition);
+      try {
+        await observer.update(observerSnapshot(args));
+      } catch (error) {
+        this.handleError(error);
+      }
     }
   }
-  return definitions;
-}
-function formatMetadata(metadata) {
-  if (metadata === void 0) {
-    return void 0;
+  handleError(error) {
+    if (this.failOnObserverError) {
+      throw error;
+    }
   }
-  return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [key, String(value)]));
-}
-
-// src/internal/prompt-runtime/stream-accumulator.ts
-var CompletionStreamAccumulator = class {
-  orderedParts = [];
-  textParts = /* @__PURE__ */ new Map();
-  reasoningByKey = /* @__PURE__ */ new Map();
-  reasoningKeyById = /* @__PURE__ */ new Map();
-  toolCalls = /* @__PURE__ */ new Map();
-  sources = /* @__PURE__ */ new Map();
-  providerToolCalls = /* @__PURE__ */ new Map();
-  finalResponse;
-  messageId;
-  nextTextKey = 0;
-  nextReasoningKey = 0;
-  accept(event) {
-    if (event.type === "text_delta") {
-      this.appendText(event.delta);
-      return { type: "text_delta", delta: event.delta };
+};
+var ActiveToolObservers = class {
+  constructor(toolObservers, failOnObserverError) {
+    this.toolObservers = toolObservers;
+    this.failOnObserverError = failOnObserverError;
+  }
+  toolObservers;
+  failOnObserverError;
+  async streamEvent(args) {
+    for (const observer of this.toolObservers) {
+      if (observer.streamEvent === void 0) {
+        continue;
+      }
+      try {
+        await observer.streamEvent(observerSnapshot(args));
+      } catch (error) {
+        this.handleError(error);
+      }
     }
-    if (event.type === "reasoning_delta") {
-      const reasoning = this.reasoningStateForEvent(event);
-      this.appendReasoning(reasoning, event);
-      return reasoningDeltaEvent(event);
+  }
+  async end(args) {
+    for (const observer of this.toolObservers) {
+      try {
+        await observer.end(observerSnapshot(args));
+      } catch (error) {
+        this.handleError(error);
+      }
     }
-    if (event.type === "tool_call_delta") {
-      const toolCall = this.toolCallStateForId(event.id);
-      if (event.callId !== void 0 && event.callId.length > 0) toolCall.callId = event.callId;
-      if (event.name !== void 0 && event.name.length > 0) toolCall.name = event.name;
-      if (event.signature !== void 0) toolCall.signature = event.signature;
-      if (event.argumentsDelta !== void 0) {
-        if (event.argumentsMode === "replace") {
-          toolCall.argumentsText = event.argumentsDelta;
-        } else {
-          toolCall.argumentsText += event.argumentsDelta;
-        }
+  }
+  async error(args) {
+    for (const observer of this.toolObservers) {
+      if (observer.error === void 0) {
+        continue;
+      }
+      try {
+        await observer.error(observerSnapshot(args));
+      } catch (error) {
+        this.handleError(error);
       }
-      return void 0;
     }
-    if (event.type === "tool_call") {
-      this.upsertToolCall(event.toolCall);
-      return { type: "tool_call", toolCall: event.toolCall };
+  }
+  handleError(error) {
+    if (this.failOnObserverError) {
+      throw error;
     }
-    if (event.type === "source") {
-      this.sources.set(sourceKey(event.source), event.source);
-      return { type: "source", source: event.source };
-    }
-    if (event.type === "provider_tool_call") {
-      this.providerToolCalls.set(event.toolCall.id, event.toolCall);
-      return { type: "provider_tool_call", toolCall: event.toolCall };
-    }
-    if (event.type === "message_id") {
-      this.messageId = event.id;
-      return void 0;
-    }
-    if (event.type === "final") {
-      this.finalResponse = event.response;
-      return void 0;
-    }
-    return void 0;
   }
-  response() {
-    const accumulatedResponse = this.buildAccumulatedResponse();
-    if (this.finalResponse !== void 0) {
-      if (accumulatedResponse.choice.length === 0) {
-        return this.withAccumulatedArtifacts(this.finalResponse, accumulatedResponse);
+};
+
+// src/internal/async-queue.ts
+function createAsyncQueue() {
+  const values = [];
+  const waiters = [];
+  let closed = false;
+  let error;
+  function flush() {
+    while (waiters.length > 0 && values.length > 0) {
+      const waiter = waiters.shift();
+      const value = values.shift();
+      if (waiter !== void 0) {
+        waiter.resolve({ value, done: false });
       }
-      return this.mergeFinalResponse(accumulatedResponse, this.finalResponse);
     }
-    return accumulatedResponse;
-  }
-  buildAccumulatedResponse() {
-    const choice = [];
-    for (const part of this.orderedParts) {
-      if (part.type === "text") {
-        const text = this.textParts.get(part.key) ?? "";
-        if (text.length > 0) {
-          choice.push({ type: "text", text });
-        }
-        continue;
-      }
-      if (part.type === "reasoning") {
-        const reasoning = this.reasoningByKey.get(part.key);
-        if (reasoning !== void 0) {
-          choice.push(reasoningContent(reasoning));
-        }
+    if (values.length > 0 || waiters.length === 0 || !closed) {
+      return;
+    }
+    while (waiters.length > 0) {
+      const waiter = waiters.shift();
+      if (waiter === void 0) {
         continue;
       }
-      const toolCall = this.toolCalls.get(part.key);
-      if (toolCall !== void 0) {
-        choice.push(
-          toolCallContent(toolCall, matchingFinalToolCall(toolCall, this.finalResponse?.choice))
-        );
+      if (error !== void 0) {
+        waiter.reject(error);
+      } else {
+        waiter.resolve({ value: void 0, done: true });
       }
     }
-    const response = {
-      choice,
-      usage: Usage.empty(),
-      rawResponse: void 0
-    };
-    if (this.messageId !== void 0) {
-      response.messageId = this.messageId;
-    }
-    const sources = [...this.sources.values()];
-    if (sources.length > 0) {
-      response.sources = sources;
-    }
-    const providerToolCalls = [...this.providerToolCalls.values()];
-    if (providerToolCalls.length > 0) {
-      response.providerToolCalls = providerToolCalls;
+  }
+  return {
+    enqueue(value) {
+      if (closed) {
+        return;
+      }
+      values.push(value);
+      flush();
+    },
+    close() {
+      closed = true;
+      flush();
+    },
+    throw(thrown) {
+      closed = true;
+      error = thrown;
+      flush();
+    },
+    [Symbol.asyncIterator]() {
+      return {
+        next() {
+          if (values.length > 0) {
+            const value = values.shift();
+            return Promise.resolve({ value, done: false });
+          }
+          if (error !== void 0) {
+            return Promise.reject(error);
+          }
+          if (closed) {
+            return Promise.resolve({ value: void 0, done: true });
+          }
+          return new Promise((resolve, reject) => {
+            waiters.push({ resolve, reject });
+          });
+        }
+      };
     }
-    return response;
+  };
+}
+
+// src/internal/rag-text.ts
+function extractRagText(message) {
+  if (message.role === "user") {
+    return message.content.flatMap((item) => item.type === "text" ? [item.text] : []).join("\n");
   }
-  upsertToolCall(toolCall) {
-    if (!this.toolCalls.has(toolCall.id)) {
-      this.orderedParts.push({ type: "tool_call", key: toolCall.id });
+  if (message.role === "tool") {
+    return message.content.flatMap((item) => item.content.flatMap((part) => part.type === "text" ? [part.text] : [])).join("\n");
+  }
+  return void 0;
+}
+
+// src/internal/agent-runtime/memory.ts
+var AgentRunMemory = class {
+  constructor(agent, memoryContext, initialHistory) {
+    this.agent = agent;
+    this.memoryContext = memoryContext;
+    this.initialHistory = initialHistory;
+  }
+  agent;
+  memoryContext;
+  initialHistory;
+  memoryPolicy() {
+    return this.memory()?.options.savePolicy;
+  }
+  pendingTurnMessages(newMessages) {
+    return this.memoryPolicy() === "turn" ? [...newMessages] : [];
+  }
+  async prepareHistory(runId, incomingMessageCount) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryContext === void 0) {
+      return {
+        history: this.initialHistory,
+        usage: Usage.empty()
+      };
     }
-    const partial = {
-      id: toolCall.id,
-      name: toolCall.function.name,
-      argumentsText: JSON.stringify(toolCall.function.arguments ?? {})
+    const preparation = await this.prepareStoredHistory(memory, runId, incomingMessageCount);
+    const memoryHistory = preparation.history;
+    const chatHistory = [...memoryHistory, ...this.initialHistory];
+    return {
+      ...preparation,
+      history: chatHistory
     };
-    if (toolCall.callId !== void 0) {
-      partial.callId = toolCall.callId;
+  }
+  async commitAcceptedInput(runId, messages) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryContext === void 0 || memory.options.savePolicy !== "message" || messages.length === 0) {
+      return;
     }
-    if (toolCall.signature !== void 0) {
-      partial.signature = toolCall.signature;
+    await memory.store.append({
+      context: this.memoryContext,
+      runId,
+      turn: 1,
+      messages
+    });
+  }
+  async commitMessages(runId, turn, messages, pendingTurnMessages) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryContext === void 0 || messages.length === 0) {
+      return;
     }
-    if (toolCall.additionalParams !== void 0) {
-      partial.additionalParams = toolCall.additionalParams;
+    if (memory.options.savePolicy === "message") {
+      await memory.store.append({
+        context: this.memoryContext,
+        runId,
+        turn,
+        messages
+      });
+    } else if (memory.options.savePolicy === "turn") {
+      pendingTurnMessages.push(...messages);
     }
-    this.toolCalls.set(toolCall.id, partial);
   }
-  mergeFinalResponse(accumulatedResponse, finalResponse) {
-    if (finalResponse.choice.length === 0) {
-      const mergedResponse = {
-        ...accumulatedResponse,
-        usage: finalResponse.usage,
-        rawResponse: finalResponse.rawResponse
-      };
-      if (finalResponse.messageId !== void 0) {
-        mergedResponse.messageId = finalResponse.messageId;
-      }
-      return this.withAccumulatedArtifacts(mergedResponse, accumulatedResponse);
-    }
-    const finalById = /* @__PURE__ */ new Map();
-    const finalByCallId = /* @__PURE__ */ new Map();
-    for (const content of finalResponse.choice) {
-      if (content.type !== "tool_call") {
-        continue;
-      }
-      finalById.set(content.id, content);
-      if (content.callId !== void 0) {
-        finalByCallId.set(content.callId, content);
-      }
+  async commitCompletedTurn(runId, turn, pendingTurnMessages) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryContext === void 0 || memory.options.savePolicy !== "turn" || pendingTurnMessages.length === 0) {
+      return;
     }
-    const matchedFinalToolCalls = /* @__PURE__ */ new Set();
-    const choice = accumulatedResponse.choice.map((content) => {
-      if (content.type !== "tool_call") {
-        return content;
-      }
-      const finalToolCall = finalById.get(content.id) ?? (content.callId === void 0 ? void 0 : finalByCallId.get(content.callId));
-      if (finalToolCall === void 0) {
-        return content;
-      }
-      matchedFinalToolCalls.add(finalToolCall);
-      return mergeFinalToolCall(content, finalToolCall);
+    await memory.store.append({
+      context: this.memoryContext,
+      runId,
+      turn,
+      messages: [...pendingTurnMessages]
     });
-    for (const content of finalResponse.choice) {
-      if (content.type !== "tool_call") {
-        continue;
-      }
-      if (!matchedFinalToolCalls.has(content)) {
-        choice.push(content);
-      }
-    }
-    return this.withAccumulatedArtifacts({ ...finalResponse, choice }, accumulatedResponse);
+    pendingTurnMessages.length = 0;
   }
-  appendText(delta) {
-    const lastPart = this.orderedParts.at(-1);
-    const key = lastPart?.type === "text" ? lastPart.key : this.createTextKey();
-    if (lastPart?.type !== "text") {
-      this.orderedParts.push({ type: "text", key });
+  async commitCompletedRun(runId, turn, newMessages, pendingTurnMessages) {
+    await this.commitCompletedTurn(runId, turn, pendingTurnMessages);
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryContext === void 0 || memory.options.savePolicy !== "run") {
+      return;
     }
-    this.textParts.set(key, `${this.textParts.get(key) ?? ""}${delta}`);
-  }
-  reasoningStateForEvent(event) {
-    if (event.id !== void 0) {
-      const existingKey = this.reasoningKeyById.get(event.id);
-      if (existingKey !== void 0) {
-        const existing = this.reasoningByKey.get(existingKey);
-        if (existing !== void 0) {
-          return existing;
-        }
-      }
-      const key2 = this.createReasoningKey();
-      const reasoning2 = { id: event.id, text: "" };
-      this.reasoningKeyById.set(event.id, key2);
-      this.reasoningByKey.set(key2, reasoning2);
-      this.orderedParts.push({ type: "reasoning", key: key2 });
-      return reasoning2;
-    }
-    const lastPart = this.orderedParts.at(-1);
-    if (lastPart?.type === "reasoning") {
-      const lastReasoning = this.reasoningByKey.get(lastPart.key);
-      if (lastReasoning !== void 0 && lastReasoning.id === void 0) {
-        return lastReasoning;
-      }
-    }
-    const key = this.createReasoningKey();
-    const reasoning = { text: "" };
-    this.reasoningByKey.set(key, reasoning);
-    this.orderedParts.push({ type: "reasoning", key });
-    return reasoning;
-  }
-  toolCallStateForId(id) {
-    const existing = this.toolCalls.get(id);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const toolCall = {
-      id,
-      name: "",
-      argumentsText: ""
-    };
-    this.toolCalls.set(id, toolCall);
-    this.orderedParts.push({ type: "tool_call", key: id });
-    return toolCall;
+    await memory.store.append({
+      context: this.memoryContext,
+      runId,
+      turn,
+      messages: [...newMessages]
+    });
   }
-  withMessageIdFallback(response, accumulatedResponse) {
-    if (response.messageId !== void 0 || accumulatedResponse.messageId === void 0) {
-      return response;
+  async recordError(runId, error, newMessages) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryContext === void 0) {
+      return;
     }
-    return { ...response, messageId: accumulatedResponse.messageId };
-  }
-  withAccumulatedArtifacts(response, accumulatedResponse) {
-    const withMessageId = this.withMessageIdFallback(response, accumulatedResponse);
-    const sources = mergeSources(accumulatedResponse.sources, response.sources);
-    const providerToolCalls = mergeProviderToolCalls(
-      accumulatedResponse.providerToolCalls,
-      response.providerToolCalls
-    );
-    return {
-      ...withMessageId,
-      ...sources.length === 0 ? {} : { sources },
-      ...providerToolCalls.length === 0 ? {} : { providerToolCalls }
-    };
-  }
-  createTextKey() {
-    this.nextTextKey += 1;
-    return `text_${this.nextTextKey.toString()}`;
+    await memory.store.recordError?.({
+      context: this.memoryContext,
+      runId,
+      error,
+      messages: [...newMessages]
+    });
   }
-  createReasoningKey() {
-    this.nextReasoningKey += 1;
-    return `reasoning_${this.nextReasoningKey.toString()}`;
+  memory() {
+    return this.memoryContext === void 0 ? void 0 : this.agent.memory;
   }
-  appendReasoning(reasoning, event) {
-    const contentType = event.contentType ?? "text";
-    if (contentType === "text" || contentType === "summary") {
-      reasoning.text += event.delta;
+  async prepareStoredHistory(memory, runId, incomingMessageCount) {
+    const context = this.memoryContext;
+    if (context === void 0) {
+      return { history: [], usage: Usage.empty() };
     }
-    if (event.contentType === void 0 && event.signature === void 0) {
-      return;
+    const options = memory.options.compaction;
+    const capability = memory.store.compaction;
+    if (options === void 0 || capability === void 0) {
+      return {
+        history: await memory.store.load(context),
+        usage: Usage.empty()
+      };
     }
-    reasoning.content ??= [];
-    const last = reasoning.content.at(-1);
-    if (contentType === "text") {
-      if (last?.type === "text") {
-        last.text += event.delta;
-        if (event.signature !== void 0) {
-          last.signature = event.signature;
-        }
-      } else {
-        reasoning.content.push(
-          event.signature === void 0 ? { type: "text", text: event.delta } : { type: "text", text: event.delta, signature: event.signature }
-        );
+    let usage = Usage.empty();
+    let conflictRetries = 0;
+    for (let attempt = 0; attempt <= options.conflictRetries; attempt += 1) {
+      const snapshot = await capability.load(context);
+      const compactedMessageCount = compactedPrefixLength(
+        snapshot.messages,
+        incomingMessageCount,
+        options.maxMessages,
+        options.keepRecentUserTurns
+      );
+      if (compactedMessageCount === 0) {
+        return { history: snapshot.messages, usage };
       }
-      return;
-    }
-    if (contentType === "summary") {
-      if (last?.type === "summary") {
-        last.text += event.delta;
-      } else {
-        reasoning.content.push({ type: "summary", text: event.delta });
+      const prefix = snapshot.messages.slice(0, compactedMessageCount);
+      let result;
+      try {
+        result = await options.compactor({
+          context,
+          messages: prefix
+        });
+      } catch (error) {
+        throw remappedCompactorError(error, usage);
       }
-      return;
-    }
-    if (contentType === "encrypted") {
-      reasoning.content.push({ type: "encrypted", data: event.delta });
-      return;
+      if (result.usage !== void 0) {
+        usage = Usage.add(usage, result.usage);
+      }
+      const summaryText = result.summary.trim();
+      if (summaryText.length === 0) {
+        throw new MemoryCompactionError("Memory compactor returned an empty summary.", {
+          usage
+        });
+      }
+      const summary = createMemoryCompactionSummary(
+        summaryText,
+        cumulativeCompactedMessageCount(prefix)
+      );
+      let commit;
+      try {
+        commit = await capability.commit({
+          context,
+          revision: snapshot.revision,
+          compactedMessageCount,
+          summary,
+          runId: `memory-compaction:${runId}:${attempt + 1}`
+        });
+      } catch (error) {
+        throw new MemoryCompactionError("Memory compaction store commit failed.", {
+          cause: error,
+          usage
+        });
+      }
+      if (commit === "committed") {
+        const retained = snapshot.messages.slice(compactedMessageCount);
+        return {
+          history: [summary, ...retained],
+          usage,
+          compaction: {
+            originalMessageCount: snapshot.messages.length,
+            compactedMessageCount,
+            retainedMessageCount: retained.length,
+            conflictRetries
+          }
+        };
+      }
+      conflictRetries += 1;
     }
-    reasoning.content.push({ type: "redacted", data: event.delta });
+    throw new MemoryCompactionConflictError(options.conflictRetries + 1, usage);
   }
 };
-function sourceKey(source) {
-  return `${source.url}\0${source.startIndex ?? ""}\0${source.endIndex ?? ""}`;
-}
-function mergeSources(accumulated, final) {
-  const sources = /* @__PURE__ */ new Map();
-  for (const source of [...accumulated ?? [], ...final ?? []]) {
-    sources.set(sourceKey(source), source);
+function compactedPrefixLength(messages, incomingMessageCount, maxMessages, keepRecentUserTurns) {
+  if (messages.length + incomingMessageCount <= maxMessages) {
+    return 0;
   }
-  return [...sources.values()];
+  const userMessageIndexes = messages.flatMap(
+    (message, index) => message.role === "user" ? [index] : []
+  );
+  if (userMessageIndexes.length <= keepRecentUserTurns) {
+    return 0;
+  }
+  return userMessageIndexes[userMessageIndexes.length - keepRecentUserTurns] ?? 0;
 }
-function mergeProviderToolCalls(accumulated, final) {
-  const toolCalls = /* @__PURE__ */ new Map();
-  for (const toolCall of [...accumulated ?? [], ...final ?? []]) {
-    toolCalls.set(toolCall.id, toolCall);
+function remappedCompactorError(error, usage) {
+  if (error instanceof MemoryCompactionError) {
+    const mergedUsage = error.usage === void 0 ? usage : isEmptyUsage(usage) ? error.usage : Usage.add(usage, error.usage);
+    if (mergedUsage === error.usage || error.usage === void 0 && isEmptyUsage(usage)) {
+      return error;
+    }
+    return new MemoryCompactionError(error.message, {
+      cause: error,
+      usage: mergedUsage
+    });
   }
-  return [...toolCalls.values()];
+  return new MemoryCompactionError("Memory compactor failed.", {
+    cause: error,
+    usage
+  });
 }
-function reasoningContent(reasoning) {
-  const content = reasoning.content === void 0 ? { type: "reasoning", text: reasoning.text } : { type: "reasoning", text: reasoning.text, content: reasoning.content };
-  return reasoning.id === void 0 ? content : { ...content, id: reasoning.id };
+function isEmptyUsage(usage) {
+  return usage.inputTokens === 0 && usage.outputTokens === 0 && usage.totalTokens === 0 && usage.cachedInputTokens === 0 && usage.cacheCreationInputTokens === 0;
 }
-function toolCallContent(toolCall, finalToolCall) {
-  const argumentsValue = finalToolCall !== void 0 && !isEmptyToolArguments(finalToolCall.function.arguments) ? finalToolCall.function.arguments : parseToolArguments(toolCall.id, toolCall.argumentsText);
-  const content = {
-    type: "tool_call",
-    id: toolCall.id,
-    function: {
-      name: toolCall.name,
-      arguments: argumentsValue
+
+// src/internal/agent-runtime/retrieval.ts
+async function fetchContextDocuments(agent, ragText) {
+  const documents = [];
+  for (const input of agent.context) {
+    if (!isContextIndex(input)) {
+      documents.push(input);
+      continue;
+    }
+    if (ragText === void 0 || ragText.length === 0) {
+      continue;
+    }
+    const results = await input.index.search({
+      query: ragText,
+      topK: input.topK,
+      threshold: input.threshold,
+      filter: input.filter
+    });
+    for (const result of results) {
+      const formatted = input.format?.(result);
+      if (formatted !== void 0) {
+        documents.push(formatted);
+      } else {
+        const metadata = formatMetadata(result.metadata);
+        const document = {
+          id: result.id,
+          text: typeof result.document === "string" ? result.document : JSON.stringify(result.document, null, 2)
+        };
+        if (metadata !== void 0) {
+          document.additionalProps = metadata;
+        }
+        documents.push(document);
+      }
     }
-  };
-  if (toolCall.callId !== void 0) {
-    content.callId = toolCall.callId;
-  }
-  if (toolCall.signature !== void 0) {
-    content.signature = toolCall.signature;
-  }
-  if (toolCall.additionalParams !== void 0) {
-    content.additionalParams = toolCall.additionalParams;
   }
-  return content;
+  return documents;
 }
-function matchingFinalToolCall(accumulated, finalChoice) {
-  const byId = finalChoice?.find(
-    (content) => content.type === "tool_call" && content.id === accumulated.id
+async function fetchToolDefinitions(agent, ragText) {
+  const state = getAgentToolState(agent);
+  const staticDefinitions = await Promise.all(
+    state.staticTools.map((tool) => tool.definition(ragText ?? ""))
   );
-  if (byId !== void 0 || accumulated.callId === void 0) {
-    return byId;
+  if (ragText === void 0 || ragText.length === 0 || state.toolIndexes.length === 0) {
+    return staticDefinitions;
   }
-  return finalChoice?.find(
-    (content) => content.type === "tool_call" && content.callId === accumulated.callId
-  );
-}
-function mergeFinalToolCall(accumulated, finalToolCall) {
-  const argumentsValue = isEmptyToolArguments(finalToolCall.function.arguments) ? accumulated.function.arguments : finalToolCall.function.arguments;
-  return {
-    ...accumulated,
-    ...finalToolCall,
-    function: {
-      ...accumulated.function,
-      ...finalToolCall.function,
-      arguments: argumentsValue
+  const definitions = [...staticDefinitions];
+  const names = new Set(staticDefinitions.map((definition) => definition.name));
+  for (const index of state.toolIndexes) {
+    const results = await index.search({
+      query: ragText,
+      topK: index.topK,
+      threshold: index.threshold,
+      filter: index.filter
+    });
+    for (const result of results) {
+      const toolName = result.document.toolName;
+      if (names.has(toolName)) {
+        continue;
+      }
+      const tool = index.tools.find((candidate) => candidate.name === toolName);
+      if (tool === void 0) {
+        continue;
+      }
+      names.add(toolName);
+      definitions.push(await tool.definition(ragText));
     }
-  };
-}
-function reasoningDeltaEvent(event) {
-  const mapped = { type: "reasoning_delta", delta: event.delta };
-  if (event.id !== void 0) mapped.id = event.id;
-  if (event.contentType !== void 0) mapped.contentType = event.contentType;
-  if (event.signature !== void 0) mapped.signature = event.signature;
-  return mapped;
-}
-function isEmptyToolArguments(value) {
-  if (value === void 0 || value === null) {
-    return true;
-  }
-  if (typeof value === "string") {
-    return value.trim().length === 0;
-  }
-  if (Array.isArray(value)) {
-    return value.length === 0;
-  }
-  if (typeof value === "object") {
-    return Object.values(value).every((item) => item === void 0);
   }
-  return false;
+  return definitions;
 }
-function parseToolArguments(toolCallId, text) {
-  if (text.trim().length === 0) {
-    return {};
-  }
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new Error(
-      `Completion returned tool call "${toolCallId}" with malformed JSON arguments; this indicates invalid provider output or incomplete stream assembly.`
-    );
+function formatMetadata(metadata) {
+  if (metadata === void 0) {
+    return void 0;
   }
+  return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [key, String(value)]));
 }
 
-// src/internal/prompt-runtime/stream-events.ts
-function addTurn(turn, event) {
-  if (event.type === "text_delta") {
-    return { type: "text_delta", turn, delta: event.delta };
-  }
-  if (event.type === "reasoning_delta") {
-    const mapped = { type: "reasoning_delta", turn, delta: event.delta };
-    if (event.id !== void 0) mapped.id = event.id;
-    if (event.contentType !== void 0) mapped.contentType = event.contentType;
-    if (event.signature !== void 0) mapped.signature = event.signature;
-    return mapped;
-  }
-  if (event.type === "source") {
-    return { type: "source", turn, source: event.source };
-  }
-  if (event.type === "provider_tool_call") {
-    return { type: "provider_tool_call", turn, toolCall: event.toolCall };
+// src/internal/agent-runtime/run-validation.ts
+function assertNonnegativeSafeInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError(`${name} must be a nonnegative safe integer.`);
   }
-  return { type: "tool_call", turn, toolCall: event.toolCall };
-}
-function addTurnToToolCallDelta(turn, event) {
-  const mapped = {
-    type: "tool_call_delta",
-    turn,
-    id: event.id
-  };
-  if (event.callId !== void 0) mapped.callId = event.callId;
-  if (event.name !== void 0) mapped.name = event.name;
-  if (event.argumentsDelta !== void 0) mapped.argumentsDelta = event.argumentsDelta;
-  if (event.argumentsMode !== void 0) mapped.argumentsMode = event.argumentsMode;
-  if (event.signature !== void 0) mapped.signature = event.signature;
-  return mapped;
+  return value;
 }
-function isGenerationDeltaEvent(type) {
-  return type === "text_delta" || type === "reasoning_delta" || type === "tool_call_delta" || type === "tool_call" || type === "source" || type === "provider_tool_call";
+function assertPositiveSafeInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new TypeError(`${name} must be a positive safe integer.`);
+  }
+  return value;
 }
 
-// src/internal/prompt-runtime/tool-execution.ts
-var MCP_TOOL_METADATA_KEY = /* @__PURE__ */ Symbol.for("anvia.mcp.tool.metadata");
-var ToolCallExecutor = class {
-  constructor(agent, activeHook, approvals, runContext, concurrency, requestMiddlewares, includeToolCallDeltas, cancel) {
-    this.agent = agent;
-    this.activeHook = activeHook;
-    this.approvals = approvals;
-    this.runContext = runContext;
-    this.concurrency = concurrency;
-    this.requestMiddlewares = requestMiddlewares;
-    this.includeToolCallDeltas = includeToolCallDeltas;
-    this.cancel = cancel;
+// src/internal/agent-runtime/stream-accumulator.ts
+var CompletionStreamAccumulator = class {
+  orderedParts = [];
+  textParts = /* @__PURE__ */ new Map();
+  reasoningByKey = /* @__PURE__ */ new Map();
+  reasoningKeyById = /* @__PURE__ */ new Map();
+  toolCalls = /* @__PURE__ */ new Map();
+  sources = /* @__PURE__ */ new Map();
+  providerToolCalls = /* @__PURE__ */ new Map();
+  finalResponse;
+  messageId;
+  nextTextKey = 0;
+  nextReasoningKey = 0;
+  accept(event) {
+    if (event.type === "text_delta") {
+      this.appendText(event.delta);
+      return { type: "text_delta", delta: event.delta };
+    }
+    if (event.type === "reasoning_delta") {
+      const reasoning = this.reasoningStateForEvent(event);
+      this.appendReasoning(reasoning, event);
+      return reasoningDeltaEvent(event);
+    }
+    if (event.type === "tool_call_delta") {
+      const toolCall = this.toolCallStateForId(event.id);
+      if (event.callId !== void 0 && event.callId.length > 0) toolCall.callId = event.callId;
+      if (event.name !== void 0 && event.name.length > 0) toolCall.name = event.name;
+      if (event.signature !== void 0) toolCall.signature = event.signature;
+      if (event.argumentsDelta !== void 0) {
+        if (event.argumentsMode === "replace") {
+          toolCall.argumentsText = event.argumentsDelta;
+        } else {
+          toolCall.argumentsText += event.argumentsDelta;
+        }
+      }
+      return void 0;
+    }
+    if (event.type === "tool_call") {
+      this.upsertToolCall(event.toolCall);
+      return { type: "tool_call", toolCall: event.toolCall };
+    }
+    if (event.type === "source") {
+      this.sources.set(sourceKey(event.source), event.source);
+      return { type: "source", source: event.source };
+    }
+    if (event.type === "provider_tool_call") {
+      this.providerToolCalls.set(event.toolCall.id, event.toolCall);
+      return { type: "provider_tool_call", toolCall: event.toolCall };
+    }
+    if (event.type === "message_id") {
+      this.messageId = event.id;
+      return void 0;
+    }
+    if (event.type === "final") {
+      this.finalResponse = event.response;
+      return void 0;
+    }
+    return void 0;
   }
-  agent;
-  activeHook;
-  approvals;
-  runContext;
-  concurrency;
-  requestMiddlewares;
-  includeToolCallDeltas;
-  cancel;
-  async execute(toolCalls, onResult, onStreamEvent, observation) {
-    for (const toolCall of toolCalls) {
-      if (toolCall.function.name.length === 0) {
-        throw new Error(
-          `Completion returned tool call "${toolCall.id}" with an empty function name; this indicates invalid provider output or provider mapping.`
+  response() {
+    const accumulatedResponse = this.buildAccumulatedResponse();
+    if (this.finalResponse !== void 0) {
+      if (accumulatedResponse.choice.length === 0) {
+        return this.withAccumulatedArtifacts(this.finalResponse, accumulatedResponse);
+      }
+      return this.mergeFinalResponse(accumulatedResponse, this.finalResponse);
+    }
+    return accumulatedResponse;
+  }
+  buildAccumulatedResponse() {
+    const choice = [];
+    for (const part of this.orderedParts) {
+      if (part.type === "text") {
+        const text = this.textParts.get(part.key) ?? "";
+        if (text.length > 0) {
+          choice.push({ type: "text", text });
+        }
+        continue;
+      }
+      if (part.type === "reasoning") {
+        const reasoning = this.reasoningByKey.get(part.key);
+        if (reasoning !== void 0) {
+          choice.push(reasoningContent(reasoning));
+        }
+        continue;
+      }
+      const toolCall = this.toolCalls.get(part.key);
+      if (toolCall !== void 0) {
+        choice.push(
+          toolCallContent(toolCall, matchingFinalToolCall(toolCall, this.finalResponse?.choice))
         );
       }
     }
-    return mapWithConcurrency(toolCalls, this.concurrency, async (toolCall) => {
-      const args = JSON.stringify(toolCall.function.arguments ?? {});
-      const internalCallId = globalThis.crypto.randomUUID();
-      const hookArgs = {
-        toolName: toolCall.function.name,
-        internalCallId,
-        args
-      };
-      if (toolCall.callId !== void 0) {
-        hookArgs.toolCallId = toolCall.callId;
-      }
-      const tool = this.agent.getTool(toolCall.function.name);
-      const toolDefinition = observation?.toolDefinitions?.find(
-        (definition) => definition.name === toolCall.function.name
-      );
-      const toolMetadata = toolTraceMetadata(tool);
-      const toolStartArgs = {
-        turn: observation?.turn ?? 0,
-        toolCall,
-        toolName: toolCall.function.name,
-        internalCallId,
-        args
+    const response = {
+      choice,
+      usage: Usage.empty(),
+      rawResponse: void 0
+    };
+    if (this.messageId !== void 0) {
+      response.messageId = this.messageId;
+    }
+    const sources = [...this.sources.values()];
+    if (sources.length > 0) {
+      response.sources = sources;
+    }
+    const providerToolCalls = [...this.providerToolCalls.values()];
+    if (providerToolCalls.length > 0) {
+      response.providerToolCalls = providerToolCalls;
+    }
+    return response;
+  }
+  upsertToolCall(toolCall) {
+    if (!this.toolCalls.has(toolCall.id)) {
+      this.orderedParts.push({ type: "tool_call", key: toolCall.id });
+    }
+    const partial = {
+      id: toolCall.id,
+      name: toolCall.function.name,
+      argumentsText: JSON.stringify(toolCall.function.arguments ?? {})
+    };
+    if (toolCall.callId !== void 0) {
+      partial.callId = toolCall.callId;
+    }
+    if (toolCall.signature !== void 0) {
+      partial.signature = toolCall.signature;
+    }
+    if (toolCall.additionalParams !== void 0) {
+      partial.additionalParams = toolCall.additionalParams;
+    }
+    this.toolCalls.set(toolCall.id, partial);
+  }
+  mergeFinalResponse(accumulatedResponse, finalResponse) {
+    if (finalResponse.choice.length === 0) {
+      const mergedResponse = {
+        ...accumulatedResponse,
+        usage: finalResponse.usage,
+        rawResponse: finalResponse.rawResponse
       };
-      if (toolCall.callId !== void 0) {
-        toolStartArgs.toolCallId = toolCall.callId;
-      }
-      if (toolDefinition !== void 0) {
-        toolStartArgs.toolDefinition = toolDefinition;
+      if (finalResponse.messageId !== void 0) {
+        mergedResponse.messageId = finalResponse.messageId;
       }
-      if (toolMetadata !== void 0) {
-        toolStartArgs.toolMetadata = toolMetadata;
+      return this.withAccumulatedArtifacts(mergedResponse, accumulatedResponse);
+    }
+    const finalById = /* @__PURE__ */ new Map();
+    const finalByCallId = /* @__PURE__ */ new Map();
+    for (const content of finalResponse.choice) {
+      if (content.type !== "tool_call") {
+        continue;
       }
-      const toolObservers = await observation?.runObservers.startTool(toolStartArgs);
-      let output;
-      let skipped = false;
-      let effectiveArgs = args;
-      const callAction = await this.activeHook?.onToolCall?.({
-        ...hookArgs,
-        tool: toolCallControl
-      });
-      if (callAction?.type === "terminate") {
-        await recordToolError(
-          toolObservers,
-          observation?.turn,
-          toolCall,
-          internalCallId,
-          effectiveArgs,
-          callAction.reason
-        );
-        throw this.cancel(callAction.reason);
+      finalById.set(content.id, content);
+      if (content.callId !== void 0) {
+        finalByCallId.set(content.callId, content);
       }
-      if (callAction?.type === "skip") {
-        output = callAction.reason;
-        skipped = true;
-      } else {
-        let approvalDecision;
-        try {
-          effectiveArgs = await this.runToolInputMiddlewares({
-            ...hookArgs,
-            turn: observation?.turn ?? 0,
-            originalArgs: args
-          });
-          hookArgs.args = effectiveArgs;
-          approvalDecision = callAction?.type === "approval_request" ? await this.requestApproval(tool, hookArgs, callAction) : await this.evaluateToolApproval(tool, hookArgs) ?? { approved: true };
-          if (!approvalDecision.approved) {
-            output = approvalDecision.result;
-            skipped = true;
-          } else {
-            output = await this.runApprovedToolCall(
-              toolCall,
-              hookArgs,
-              effectiveArgs,
-              args,
-              toolObservers,
-              observation,
-              onStreamEvent,
-              false
-            );
-            effectiveArgs = hookArgs.args;
-          }
-        } catch (error) {
-          await recordToolError(
-            toolObservers,
-            observation?.turn,
-            toolCall,
-            internalCallId,
-            effectiveArgs,
-            error
-          );
-          throw error;
-        }
+    }
+    const matchedFinalToolCalls = /* @__PURE__ */ new Set();
+    const choice = accumulatedResponse.choice.map((content) => {
+      if (content.type !== "tool_call") {
+        return content;
       }
-      let result = toolOutputToText(output);
-      let structuredResult = toolOutputToStructuredResult(output);
-      if (this.agent.shouldApplyToolMiddleware(toolCall.function.name)) {
-        const middlewareReplacement = await this.runToolResultMiddlewares({
-          ...hookArgs,
-          args: effectiveArgs,
-          result,
-          originalResult: result,
-          structuredResult,
-          originalStructuredResult: structuredResult,
-          turn: observation?.turn ?? 0
-        });
-        if (middlewareReplacement !== void 0) {
-          output = middlewareReplacement;
-          result = toolOutputToText(middlewareReplacement);
-          structuredResult = toolOutputToStructuredResult(middlewareReplacement);
-        }
+      const finalToolCall = finalById.get(content.id) ?? (content.callId === void 0 ? void 0 : finalByCallId.get(content.callId));
+      if (finalToolCall === void 0) {
+        return content;
       }
-      const resultAction = await this.activeHook?.onToolResult?.({
-        ...hookArgs,
-        args: effectiveArgs,
-        result,
-        structuredResult,
-        run: runControl
-      });
-      await toolObservers?.end({
-        turn: observation?.turn ?? 0,
-        toolCall,
-        toolName: toolCall.function.name,
-        internalCallId,
-        args: effectiveArgs,
-        result,
-        structuredResult,
-        skipped,
-        toolCallId: toolCall.callId
-      });
-      if (resultAction?.type === "terminate") {
-        throw this.cancel(resultAction.reason);
+      matchedFinalToolCalls.add(finalToolCall);
+      return mergeFinalToolCall(content, finalToolCall);
+    });
+    for (const content of finalResponse.choice) {
+      if (content.type !== "tool_call") {
+        continue;
       }
-      const resultPayload = {
-        type: "tool_result",
-        toolName: toolCall.function.name,
-        internalCallId,
-        args: effectiveArgs,
-        result,
-        structuredResult
-      };
-      if (toolCall.callId !== void 0) {
-        resultPayload.toolCallId = toolCall.callId;
+      if (!matchedFinalToolCalls.has(content)) {
+        choice.push(content);
       }
-      onResult?.(resultPayload);
-      return ToolContent.toolResult(toolCall.id, output, {
-        callId: toolCall.callId,
-        toolName: toolCall.function.name
-      });
-    });
+    }
+    return this.withAccumulatedArtifacts({ ...finalResponse, choice }, accumulatedResponse);
   }
-  async runApprovedToolCall(toolCall, hookArgs, effectiveArgs, originalArgs, toolObservers, observation, onStreamEvent, applyInputMiddleware = true) {
-    const middlewareArgs = applyInputMiddleware ? await this.runToolInputMiddlewares({
-      ...hookArgs,
-      args: effectiveArgs,
-      turn: observation?.turn ?? 0,
-      originalArgs
-    }) : effectiveArgs;
-    hookArgs.args = middlewareArgs;
-    try {
-      const toolContext = {
-        emitStreamEvent: async (event) => {
-          const streamEventArgs = {
-            turn: observation?.turn ?? 0,
-            toolCall,
-            toolName: toolCall.function.name,
-            internalCallId: hookArgs.internalCallId,
-            args: middlewareArgs,
-            event
-          };
-          if (toolCall.callId !== void 0) {
-            streamEventArgs.toolCallId = toolCall.callId;
-          }
-          await toolObservers?.streamEvent(streamEventArgs);
-          const payload = agentToolEventPayload(toolCall, hookArgs.internalCallId, event);
-          if (payload !== void 0) {
-            onStreamEvent?.(payload);
-          }
-        }
-      };
-      toolContext.includeToolCallDeltas = this.includeToolCallDeltas;
-      return await this.agent.callTool(toolCall.function.name, middlewareArgs, toolContext);
-    } catch (error) {
-      const errorAction = await this.activeHook?.onToolError?.({
-        ...hookArgs,
-        args: middlewareArgs,
-        error,
-        run: runControl
-      });
-      await toolObservers?.error(
-        toolErrorArgs(
-          observation?.turn ?? 0,
-          toolCall,
-          hookArgs.internalCallId,
-          middlewareArgs,
-          error
-        )
-      );
-      if (errorAction?.type === "terminate") {
-        throw this.cancel(errorAction.reason);
-      }
-      return error instanceof Error ? error.toString() : String(error);
+  appendText(delta) {
+    const lastPart = this.orderedParts.at(-1);
+    const key = lastPart?.type === "text" ? lastPart.key : this.createTextKey();
+    if (lastPart?.type !== "text") {
+      this.orderedParts.push({ type: "text", key });
     }
+    this.textParts.set(key, `${this.textParts.get(key) ?? ""}${delta}`);
   }
-  async runToolResultMiddlewares(args) {
-    let result = args.result;
-    let structuredResult = args.structuredResult;
-    let replaced = false;
-    for (const middleware of this.activeMiddlewares()) {
-      const outputReplacement = await middleware.onToolOutput?.({
-        ...args,
-        result,
-        structuredResult
-      });
-      if (outputReplacement !== void 0) {
-        const normalized = normalizeToolOutputMiddlewareResult(outputReplacement);
-        if (normalized.result !== void 0) {
-          result = normalized.result;
-          structuredResult = void 0;
-        }
-        if (normalized.structuredResult !== void 0) {
-          structuredResult = normalized.structuredResult;
-          result = toolResultContentToText(normalized.structuredResult);
+  reasoningStateForEvent(event) {
+    if (event.id !== void 0) {
+      const existingKey = this.reasoningKeyById.get(event.id);
+      if (existingKey !== void 0) {
+        const existing = this.reasoningByKey.get(existingKey);
+        if (existing !== void 0) {
+          return existing;
         }
-        replaced = true;
       }
+      const key2 = this.createReasoningKey();
+      const reasoning2 = { id: event.id, text: "" };
+      this.reasoningKeyById.set(event.id, key2);
+      this.reasoningByKey.set(key2, reasoning2);
+      this.orderedParts.push({ type: "reasoning", key: key2 });
+      return reasoning2;
     }
-    return replaced ? structuredResult ?? result : void 0;
-  }
-  async runToolInputMiddlewares(args) {
-    let current = args.args;
-    for (const middleware of this.activeMiddlewares()) {
-      const replacement = await middleware.onToolInput?.({
-        ...args,
-        args: current
-      });
-      if (replacement?.args !== void 0) {
-        current = typeof replacement.args === "string" ? replacement.args : JSON.stringify(replacement.args);
+    const lastPart = this.orderedParts.at(-1);
+    if (lastPart?.type === "reasoning") {
+      const lastReasoning = this.reasoningByKey.get(lastPart.key);
+      if (lastReasoning !== void 0 && lastReasoning.id === void 0) {
+        return lastReasoning;
       }
     }
-    return current;
-  }
-  activeMiddlewares() {
-    return [...this.agent.middlewares, ...this.requestMiddlewares];
+    const key = this.createReasoningKey();
+    const reasoning = { text: "" };
+    this.reasoningByKey.set(key, reasoning);
+    this.orderedParts.push({ type: "reasoning", key });
+    return reasoning;
   }
-  async evaluateToolApproval(tool, hookArgs) {
-    if (tool?.approval === void 0) {
-      return void 0;
-    }
-    const policy = tool.approval;
-    const context = approvalContext(tool, hookArgs, this.agent, this.runContext);
-    const required = await policy.when(context);
-    if (!required) {
-      return { approved: true };
-    }
-    const reason = await resolveApprovalText(policy.reason, context);
-    const rejectMessage = await resolveApprovalText(policy.rejectMessage, context);
-    const options = {};
-    if (reason !== void 0) {
-      options.reason = reason;
+  toolCallStateForId(id) {
+    const existing = this.toolCalls.get(id);
+    if (existing !== void 0) {
+      return existing;
     }
-    if (rejectMessage !== void 0) {
-      options.rejectMessage = rejectMessage;
+    const toolCall = {
+      id,
+      name: "",
+      argumentsText: ""
+    };
+    this.toolCalls.set(id, toolCall);
+    this.orderedParts.push({ type: "tool_call", key: id });
+    return toolCall;
+  }
+  withMessageIdFallback(response, accumulatedResponse) {
+    if (response.messageId !== void 0 || accumulatedResponse.messageId === void 0) {
+      return response;
     }
-    return this.requestApproval(tool, hookArgs, options);
+    return { ...response, messageId: accumulatedResponse.messageId };
   }
-  async requestApproval(tool, hookArgs, options) {
-    const request = approvalContext(
-      tool,
-      hookArgs,
-      this.agent,
-      this.runContext
+  withAccumulatedArtifacts(response, accumulatedResponse) {
+    const withMessageId = this.withMessageIdFallback(response, accumulatedResponse);
+    const sources = mergeSources(accumulatedResponse.sources, response.sources);
+    const providerToolCalls = mergeProviderToolCalls(
+      accumulatedResponse.providerToolCalls,
+      response.providerToolCalls
     );
-    if (options.reason !== void 0) {
-      request.reason = options.reason;
+    return {
+      ...withMessageId,
+      ...sources.length === 0 ? {} : { sources },
+      ...providerToolCalls.length === 0 ? {} : { providerToolCalls }
+    };
+  }
+  createTextKey() {
+    this.nextTextKey += 1;
+    return `text_${this.nextTextKey.toString()}`;
+  }
+  createReasoningKey() {
+    this.nextReasoningKey += 1;
+    return `reasoning_${this.nextReasoningKey.toString()}`;
+  }
+  appendReasoning(reasoning, event) {
+    const contentType = event.contentType ?? "text";
+    if (contentType === "text" || contentType === "summary") {
+      reasoning.text += event.delta;
     }
-    if (options.rejectMessage !== void 0) {
-      request.rejectMessage = options.rejectMessage;
+    if (event.contentType === void 0 && event.signature === void 0) {
+      return;
+    }
+    reasoning.content ??= [];
+    const last = reasoning.content.at(-1);
+    if (contentType === "text") {
+      if (last?.type === "text") {
+        last.text += event.delta;
+        if (event.signature !== void 0) {
+          last.signature = event.signature;
+        }
+      } else {
+        reasoning.content.push(
+          event.signature === void 0 ? { type: "text", text: event.delta } : { type: "text", text: event.delta, signature: event.signature }
+        );
+      }
+      return;
     }
-    if (this.approvals === void 0) {
-      throw new ToolApprovalRequiredError(request);
+    if (contentType === "summary") {
+      if (last?.type === "summary") {
+        last.text += event.delta;
+      } else {
+        reasoning.content.push({ type: "summary", text: event.delta });
+      }
+      return;
     }
-    const decision = normalizeApprovalDecision(await this.approvals.handler(request));
-    if (decision.approved) {
-      return { approved: true };
+    if (contentType === "encrypted") {
+      reasoning.content.push({ type: "encrypted", data: event.delta });
+      return;
     }
-    return {
-      approved: false,
-      result: decision.rejectMessage ?? decision.reason ?? request.rejectMessage ?? "Tool approval was rejected."
-    };
+    reasoning.content.push({ type: "redacted", data: event.delta });
   }
 };
-function approvalContext(tool, hookArgs, agent, run) {
-  const rawParsedArgs = parseToolArgs(hookArgs.args);
-  const parsedArgs = tool?.parseApprovalArgs?.(rawParsedArgs) ?? rawParsedArgs;
-  const approvalRun = {
-    agentId: agent.id,
-    runId: run.runId
-  };
-  if (run.sessionId !== void 0) {
-    approvalRun.sessionId = run.sessionId;
-  }
-  if (run.metadata !== void 0) {
-    approvalRun.metadata = run.metadata;
-  }
-  const context = {
-    toolName: hookArgs.toolName,
-    args: parsedArgs,
-    rawArgs: hookArgs.args,
-    internalCallId: hookArgs.internalCallId,
-    run: approvalRun
-  };
-  if (hookArgs.toolCallId !== void 0) {
-    context.toolCallId = hookArgs.toolCallId;
-  }
-  return context;
+function sourceKey(source) {
+  return `${source.url}\0${source.startIndex ?? ""}\0${source.endIndex ?? ""}`;
 }
-function normalizeApprovalDecision(decision) {
-  if (typeof decision === "boolean") {
-    return { approved: decision };
+function mergeSources(accumulated, final) {
+  const sources = /* @__PURE__ */ new Map();
+  for (const source of [...accumulated ?? [], ...final ?? []]) {
+    sources.set(sourceKey(source), source);
   }
-  return decision;
-}
-async function resolveApprovalText(value, context) {
-  return typeof value === "function" ? value(context) : value;
+  return [...sources.values()];
 }
-function normalizeToolOutputMiddlewareResult(result) {
-  if (typeof result === "string") {
-    return { result };
+function mergeProviderToolCalls(accumulated, final) {
+  const toolCalls = /* @__PURE__ */ new Map();
+  for (const toolCall of [...accumulated ?? [], ...final ?? []]) {
+    toolCalls.set(toolCall.id, toolCall);
   }
-  return result ?? {};
+  return [...toolCalls.values()];
 }
-function toolTraceMetadata(tool) {
-  if (tool === void 0) {
-    return void 0;
-  }
-  const metadata = tool[MCP_TOOL_METADATA_KEY];
-  const mcpMetadata = typeof metadata === "object" && metadata !== null ? metadata : void 0;
-  const result = {
-    approvalRequired: tool.approval !== void 0
-  };
-  if (typeof mcpMetadata?.serverName === "string" && mcpMetadata.serverName.length > 0) {
-    result.mcpServerName = mcpMetadata.serverName;
-  }
-  return result;
+function reasoningContent(reasoning) {
+  const content = reasoning.content === void 0 ? { type: "reasoning", text: reasoning.text } : { type: "reasoning", text: reasoning.text, content: reasoning.content };
+  return reasoning.id === void 0 ? content : { ...content, id: reasoning.id };
 }
-function toolErrorArgs(turn, toolCall, internalCallId, args, error) {
-  const observerArgs = {
-    turn,
-    toolCall,
-    toolName: toolCall.function.name,
-    internalCallId,
-    args,
-    error
+function toolCallContent(toolCall, finalToolCall) {
+  const argumentsValue = finalToolCall !== void 0 && !isEmptyToolArguments(finalToolCall.function.arguments) ? finalToolCall.function.arguments : parseToolArguments(toolCall.id, toolCall.argumentsText);
+  const content = {
+    type: "tool_call",
+    id: toolCall.id,
+    function: {
+      name: toolCall.name,
+      arguments: argumentsValue
+    }
   };
   if (toolCall.callId !== void 0) {
-    observerArgs.toolCallId = toolCall.callId;
+    content.callId = toolCall.callId;
   }
-  return observerArgs;
+  if (toolCall.signature !== void 0) {
+    content.signature = toolCall.signature;
+  }
+  if (toolCall.additionalParams !== void 0) {
+    content.additionalParams = toolCall.additionalParams;
+  }
+  return content;
 }
-async function recordToolError(toolObservers, turn, toolCall, internalCallId, args, error) {
-  await toolObservers?.error({
-    turn: turn ?? 0,
-    toolCall,
-    toolName: toolCall.function.name,
-    internalCallId,
-    args,
-    error,
-    toolCallId: toolCall.callId
-  });
+function matchingFinalToolCall(accumulated, finalChoice) {
+  const byId = finalChoice?.find(
+    (content) => content.type === "tool_call" && content.id === accumulated.id
+  );
+  if (byId !== void 0 || accumulated.callId === void 0) {
+    return byId;
+  }
+  return finalChoice?.find(
+    (content) => content.type === "tool_call" && content.callId === accumulated.callId
+  );
 }
-function toolOutputToText(output) {
-  return typeof output === "string" ? output : toolResultContentToText(output);
+function mergeFinalToolCall(accumulated, finalToolCall) {
+  const argumentsValue = isEmptyToolArguments(finalToolCall.function.arguments) ? accumulated.function.arguments : finalToolCall.function.arguments;
+  return {
+    ...accumulated,
+    ...finalToolCall,
+    function: {
+      ...accumulated.function,
+      ...finalToolCall.function,
+      arguments: argumentsValue
+    }
+  };
 }
-function toolOutputToStructuredResult(output) {
-  return typeof output === "string" ? void 0 : output;
+function reasoningDeltaEvent(event) {
+  const mapped = { type: "reasoning_delta", delta: event.delta };
+  if (event.id !== void 0) mapped.id = event.id;
+  if (event.contentType !== void 0) mapped.contentType = event.contentType;
+  if (event.signature !== void 0) mapped.signature = event.signature;
+  return mapped;
 }
-function agentToolEventPayload(toolCall, internalCallId, event) {
-  if (typeof event.agentId !== "string" || event.agentId.length === 0) {
-    return void 0;
+function isEmptyToolArguments(value) {
+  if (value === void 0 || value === null) {
+    return true;
   }
-  const payload = {
-    type: "agent_tool_event",
-    toolName: toolCall.function.name,
-    internalCallId,
-    agentId: event.agentId,
-    event: event.event
-  };
-  if (toolCall.callId !== void 0) {
-    payload.toolCallId = toolCall.callId;
+  if (typeof value === "string") {
+    return value.trim().length === 0;
   }
-  if (event.agentName !== void 0) {
-    payload.agentName = event.agentName;
+  if (Array.isArray(value)) {
+    return value.length === 0;
   }
-  return payload;
+  if (typeof value === "object") {
+    return Object.values(value).every((item) => item === void 0);
+  }
+  return false;
 }
-
-// src/internal/rag-text.ts
-function extractRagText(message) {
-  if (message.role === "user") {
-    return message.content.flatMap((item) => item.type === "text" ? [item.text] : []).join("\n");
+function parseToolArguments(toolCallId, text) {
+  if (text.trim().length === 0) {
+    return {};
   }
-  if (message.role === "tool") {
-    return message.content.flatMap((item) => item.content.flatMap((part) => part.type === "text" ? [part.text] : [])).join("\n");
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(
+      `Completion returned tool call "${toolCallId}" with malformed JSON arguments; this indicates invalid provider output or incomplete stream assembly.`
+    );
   }
-  return void 0;
 }
 
-// src/observability/group.ts
-async function startAgentRunObservers(registrations, args, failOnObserverError) {
-  const runObservers = [];
-  for (const registration of registrations) {
-    try {
-      const runObserver = await registration.observer.startRun(args);
-      if (runObserver !== void 0) {
-        runObservers.push(runObserver);
-      }
-    } catch (error) {
-      if (failOnObserverError || registration.failOnObserverError === true) {
-        throw error;
-      }
-    }
-  }
-  return new ActiveAgentRunObservers(runObservers, failOnObserverError);
-}
-var ActiveAgentRunObservers = class {
-  constructor(runObservers, failOnObserverError) {
-    this.runObservers = runObservers;
-    this.failOnObserverError = failOnObserverError;
-    this.trace = runObservers.find((observer) => observer.trace !== void 0)?.trace;
-  }
-  runObservers;
-  failOnObserverError;
-  trace;
-  async startGeneration(args) {
-    const generationObservers = [];
-    for (const runObserver of this.runObservers) {
-      if (runObserver.startGeneration === void 0) {
-        continue;
-      }
-      try {
-        const generationObserver = await runObserver.startGeneration(args);
-        if (generationObserver !== void 0) {
-          generationObservers.push(generationObserver);
-        }
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-    return new ActiveGenerationObservers(generationObservers, this.failOnObserverError);
-  }
-  async startTool(args) {
-    const toolObservers = [];
-    for (const runObserver of this.runObservers) {
-      if (runObserver.startTool === void 0) {
-        continue;
-      }
-      try {
-        const toolObserver = await runObserver.startTool(args);
-        if (toolObserver !== void 0) {
-          toolObservers.push(toolObserver);
-        }
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
-    return new ActiveToolObservers(toolObservers, this.failOnObserverError);
-  }
-  async end(args) {
-    for (const runObserver of this.runObservers) {
-      try {
-        await runObserver.end(args);
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
+// src/internal/agent-runtime/stream-events.ts
+function addTurn(turn, event) {
+  if (event.type === "text_delta") {
+    return { type: "text_delta", turn, delta: event.delta };
   }
-  async error(args) {
-    for (const runObserver of this.runObservers) {
-      if (runObserver.error === void 0) {
-        continue;
-      }
-      try {
-        await runObserver.error(args);
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
+  if (event.type === "reasoning_delta") {
+    const mapped = { type: "reasoning_delta", turn, delta: event.delta };
+    if (event.id !== void 0) mapped.id = event.id;
+    if (event.contentType !== void 0) mapped.contentType = event.contentType;
+    if (event.signature !== void 0) mapped.signature = event.signature;
+    return mapped;
   }
-  async event(args) {
-    for (const runObserver of this.runObservers) {
-      if (runObserver.event === void 0) {
-        continue;
-      }
-      try {
-        await runObserver.event(args);
-      } catch (error) {
-        this.handleError(error);
-      }
-    }
+  if (event.type === "source") {
+    return { type: "source", turn, source: event.source };
   }
-  handleError(error) {
-    if (this.failOnObserverError) {
-      throw error;
-    }
+  if (event.type === "provider_tool_call") {
+    return { type: "provider_tool_call", turn, toolCall: event.toolCall };
   }
-};
-var ActiveGenerationObservers = class {
-  constructor(generationObservers, failOnObserverError) {
-    this.generationObservers = generationObservers;
-    this.failOnObserverError = failOnObserverError;
+  return { type: "tool_call", turn, toolCall: event.toolCall };
+}
+function addTurnToToolCallDelta(turn, event) {
+  const mapped = {
+    type: "tool_call_delta",
+    turn,
+    id: event.id
+  };
+  if (event.callId !== void 0) mapped.callId = event.callId;
+  if (event.name !== void 0) mapped.name = event.name;
+  if (event.argumentsDelta !== void 0) mapped.argumentsDelta = event.argumentsDelta;
+  if (event.argumentsMode !== void 0) mapped.argumentsMode = event.argumentsMode;
+  if (event.signature !== void 0) mapped.signature = event.signature;
+  return mapped;
+}
+function isGenerationDeltaEvent(type) {
+  return type === "text_delta" || type === "reasoning_delta" || type === "tool_call_delta" || type === "tool_call" || type === "source" || type === "provider_tool_call";
+}
+
+// src/internal/agent-runtime/tool-execution.ts
+var MCP_TOOL_METADATA_KEY = /* @__PURE__ */ Symbol.for("anvia.mcp.tool.metadata");
+var ToolCallExecutor = class {
+  constructor(agent, activeHook, approvalHandler, lifecycle, runContext, concurrency, requestMiddlewares, includeToolCallDeltas, cancel) {
+    this.agent = agent;
+    this.activeHook = activeHook;
+    this.approvalHandler = approvalHandler;
+    this.lifecycle = lifecycle;
+    this.runContext = runContext;
+    this.concurrency = concurrency;
+    this.requestMiddlewares = requestMiddlewares;
+    this.includeToolCallDeltas = includeToolCallDeltas;
+    this.cancel = cancel;
   }
-  generationObservers;
-  failOnObserverError;
-  async end(args) {
-    for (const observer of this.generationObservers) {
-      try {
-        await observer.end(args);
-      } catch (error) {
-        this.handleError(error);
+  agent;
+  activeHook;
+  approvalHandler;
+  lifecycle;
+  runContext;
+  concurrency;
+  requestMiddlewares;
+  includeToolCallDeltas;
+  cancel;
+  async execute(toolCalls, onResult, onStreamEvent, observation) {
+    for (const toolCall of toolCalls) {
+      if (toolCall.function.name.length === 0) {
+        throw new Error(
+          `Completion returned tool call "${toolCall.id}" with an empty function name; this indicates invalid provider output or provider mapping.`
+        );
       }
     }
-  }
-  async error(args) {
-    for (const observer of this.generationObservers) {
-      if (observer.error === void 0) {
-        continue;
+    return mapWithConcurrency(toolCalls, this.concurrency, async (toolCall) => {
+      const args = JSON.stringify(toolCall.function.arguments ?? {});
+      const internalCallId = globalThis.crypto.randomUUID();
+      const hookArgs = {
+        toolName: toolCall.function.name,
+        internalCallId,
+        args
+      };
+      if (toolCall.callId !== void 0) {
+        hookArgs.toolCallId = toolCall.callId;
       }
+      const tool = this.agent.getTool(toolCall.function.name);
+      const toolDefinition = observation?.toolDefinitions?.find(
+        (definition) => definition.name === toolCall.function.name
+      );
+      const toolMetadata = toolTraceMetadata(tool);
+      const toolStartArgs = {
+        turn: observation?.turn ?? 0,
+        toolCall,
+        toolName: toolCall.function.name,
+        internalCallId,
+        args,
+        ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId },
+        ...toolDefinition === void 0 ? {} : { toolDefinition },
+        ...toolMetadata === void 0 ? {} : { toolMetadata }
+      };
+      const toolObservers = await observation?.runObservers.startTool(toolStartArgs);
+      const toolObservation = new ToolObserverScope(toolObservers);
+      let output;
+      let skipped = false;
+      let toolExecutionFailed = false;
+      let effectiveArgs = args;
       try {
-        await observer.error(args);
+        const callAction = await this.activeHook?.onToolCall?.({
+          ...hookArgs,
+          tool: toolCallControl
+        });
+        if (callAction?.type === "terminate") {
+          throw this.cancel(callAction.reason);
+        }
+        if (callAction?.type === "skip") {
+          output = callAction.reason;
+          skipped = true;
+        } else {
+          try {
+            effectiveArgs = await this.runToolInputMiddlewares({
+              ...hookArgs,
+              turn: observation?.turn ?? 0,
+              originalArgs: args
+            });
+            hookArgs.args = effectiveArgs;
+            let prepared;
+            try {
+              prepared = this.prepareToolCall(tool, toolCall.function.name, effectiveArgs);
+            } catch (error) {
+              const outcome = await this.handleToolError(
+                toolCall,
+                hookArgs,
+                effectiveArgs,
+                error,
+                toolObservation,
+                observation
+              );
+              output = outcome.output;
+              toolExecutionFailed = outcome.failed;
+            }
+            if (prepared !== void 0) {
+              const approvalContext = createApprovalContext(
+                prepared.input,
+                hookArgs,
+                this.agent,
+                this.runContext
+              );
+              const approvalDecision = callAction?.type === "approval_request" ? await this.requestApproval(approvalContext, callAction, observation) : await this.evaluateToolApproval(tool, approvalContext, observation) ?? {
+                approved: true
+              };
+              if (!approvalDecision.approved) {
+                output = approvalDecision.result;
+                skipped = true;
+              } else {
+                const step = observation?.turn ?? 0;
+                const lifecycleEvent = {
+                  runId: this.runContext.runId,
+                  step,
+                  toolName: toolCall.function.name,
+                  input: lifecycleSnapshot(prepared.input),
+                  ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId }
+                };
+                await this.lifecycle?.onToolStart?.(lifecycleEvent);
+                const startedAt = Date.now();
+                const outcome = await this.runApprovedToolCall(
+                  prepared,
+                  toolCall,
+                  hookArgs,
+                  effectiveArgs,
+                  toolObservation,
+                  observation,
+                  onStreamEvent
+                );
+                output = outcome.output;
+                toolExecutionFailed = outcome.failed;
+                const durationMs = Date.now() - startedAt;
+                await this.lifecycle?.onToolFinish?.(
+                  outcome.failed ? {
+                    ...lifecycleEvent,
+                    durationMs,
+                    success: false,
+                    error: lifecycleSnapshot(outcome.error)
+                  } : {
+                    ...lifecycleEvent,
+                    durationMs,
+                    success: true,
+                    output: lifecycleSnapshot(output)
+                  }
+                );
+              }
+            }
+          } catch (error) {
+            await toolObservation.error(
+              toolErrorArgs(observation?.turn ?? 0, toolCall, internalCallId, effectiveArgs, error)
+            );
+            throw error;
+          }
+        }
+        if (output === void 0) {
+          throw new Error(`Tool "${toolCall.function.name}" did not produce an execution result.`);
+        }
+        let result = toolOutputToText(output);
+        let structuredResult = toolOutputToStructuredResult(output);
+        if (!isSkillTool(tool)) {
+          const middlewareReplacement = await this.runToolResultMiddlewares({
+            ...hookArgs,
+            args: effectiveArgs,
+            result,
+            originalResult: result,
+            structuredResult,
+            originalStructuredResult: structuredResult,
+            turn: observation?.turn ?? 0
+          });
+          if (middlewareReplacement !== void 0) {
+            output = middlewareReplacement;
+            result = toolOutputToText(middlewareReplacement);
+            structuredResult = toolOutputToStructuredResult(middlewareReplacement);
+          }
+        }
+        const resultAction = await this.activeHook?.onToolResult?.({
+          ...hookArgs,
+          args: effectiveArgs,
+          result,
+          structuredResult,
+          run: runControl
+        });
+        if (!toolExecutionFailed) {
+          await toolObservation.end({
+            turn: observation?.turn ?? 0,
+            toolCall,
+            toolName: toolCall.function.name,
+            internalCallId,
+            args: effectiveArgs,
+            result,
+            structuredResult,
+            skipped,
+            toolCallId: toolCall.callId
+          });
+        }
+        if (resultAction?.type === "terminate") {
+          throw this.cancel(resultAction.reason);
+        }
+        const resultPayload = {
+          type: "tool_result",
+          toolName: toolCall.function.name,
+          internalCallId,
+          args: effectiveArgs,
+          result,
+          structuredResult
+        };
+        if (toolCall.callId !== void 0) {
+          resultPayload.toolCallId = toolCall.callId;
+        }
+        onResult?.(resultPayload);
+        return ToolContent.toolResult(toolCall.id, output, {
+          callId: toolCall.callId,
+          toolName: toolCall.function.name
+        });
       } catch (error) {
-        this.handleError(error);
+        await toolObservation.error(
+          toolErrorArgs(observation?.turn ?? 0, toolCall, internalCallId, effectiveArgs, error)
+        );
+        throw error;
       }
-    }
+    });
   }
-  async update(args) {
-    for (const observer of this.generationObservers) {
-      if (observer.update === void 0) {
-        continue;
-      }
-      try {
-        await observer.update(args);
-      } catch (error) {
-        this.handleError(error);
-      }
+  async runApprovedToolCall(prepared, toolCall, hookArgs, effectiveArgs, toolObservation, observation, onStreamEvent) {
+    try {
+      const toolContext = {
+        emitStreamEvent: async (event) => {
+          const streamEventArgs = {
+            turn: observation?.turn ?? 0,
+            toolCall,
+            toolName: toolCall.function.name,
+            internalCallId: hookArgs.internalCallId,
+            args: effectiveArgs,
+            event,
+            ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId }
+          };
+          await toolObservation.streamEvent(streamEventArgs);
+          const payload = agentToolEventPayload(toolCall, hookArgs.internalCallId, event);
+          if (payload !== void 0) {
+            onStreamEvent?.(payload);
+          }
+        }
+      };
+      toolContext.includeToolCallDeltas = this.includeToolCallDeltas;
+      return {
+        output: await prepared.call(toolContext),
+        failed: false
+      };
+    } catch (error) {
+      return this.handleToolError(
+        toolCall,
+        hookArgs,
+        effectiveArgs,
+        error,
+        toolObservation,
+        observation
+      );
     }
   }
-  handleError(error) {
-    if (this.failOnObserverError) {
-      throw error;
+  prepareToolCall(tool, toolName, args) {
+    if (tool !== void 0) {
+      return prepareToolCall(tool, args);
     }
+    const input = parseToolArgs(args);
+    return {
+      input,
+      call: (context) => this.agent.callTool(toolName, args, context)
+    };
   }
-};
-var ActiveToolObservers = class {
-  constructor(toolObservers, failOnObserverError) {
-    this.toolObservers = toolObservers;
-    this.failOnObserverError = failOnObserverError;
-  }
-  toolObservers;
-  failOnObserverError;
-  async streamEvent(args) {
-    for (const observer of this.toolObservers) {
-      if (observer.streamEvent === void 0) {
-        continue;
-      }
-      try {
-        await observer.streamEvent(args);
-      } catch (error) {
-        this.handleError(error);
-      }
+  async handleToolError(toolCall, hookArgs, args, error, toolObservation, observation) {
+    const errorAction = await this.activeHook?.onToolError?.({
+      ...hookArgs,
+      args,
+      error,
+      run: runControl
+    });
+    await toolObservation.error(
+      toolErrorArgs(observation?.turn ?? 0, toolCall, hookArgs.internalCallId, args, error)
+    );
+    if (errorAction?.type === "terminate") {
+      throw this.cancel(errorAction.reason);
     }
+    return {
+      output: error instanceof Error ? error.toString() : String(error),
+      failed: true,
+      error
+    };
   }
-  async end(args) {
-    for (const observer of this.toolObservers) {
-      try {
-        await observer.end(args);
-      } catch (error) {
-        this.handleError(error);
+  async runToolResultMiddlewares(args) {
+    let result = args.result;
+    let structuredResult = args.structuredResult;
+    let replaced = false;
+    for (const middleware of this.activeMiddlewares()) {
+      const outputReplacement = await middleware.onToolOutput?.({
+        ...args,
+        result,
+        structuredResult
+      });
+      if (outputReplacement !== void 0) {
+        const normalized = normalizeToolOutputMiddlewareResult(outputReplacement);
+        if (normalized.result !== void 0) {
+          result = normalized.result;
+          structuredResult = void 0;
+        }
+        if (normalized.structuredResult !== void 0) {
+          structuredResult = normalized.structuredResult;
+          result = toolResultContentToText(normalized.structuredResult);
+        }
+        replaced = true;
       }
     }
+    return replaced ? structuredResult ?? result : void 0;
   }
-  async error(args) {
-    for (const observer of this.toolObservers) {
-      if (observer.error === void 0) {
-        continue;
-      }
-      try {
-        await observer.error(args);
-      } catch (error) {
-        this.handleError(error);
+  async runToolInputMiddlewares(args) {
+    let current = args.args;
+    for (const middleware of this.activeMiddlewares()) {
+      const replacement = await middleware.onToolInput?.({
+        ...args,
+        args: current
+      });
+      if (replacement?.args !== void 0) {
+        current = typeof replacement.args === "string" ? replacement.args : JSON.stringify(replacement.args);
       }
     }
+    return current;
   }
-  handleError(error) {
-    if (this.failOnObserverError) {
+  activeMiddlewares() {
+    return [...this.agent.middlewares, ...this.requestMiddlewares];
+  }
+  async evaluateToolApproval(tool, context, observation) {
+    const requirement = tool?.requiresApproval;
+    if (requirement === void 0) return void 0;
+    const resolved = typeof requirement === "function" ? await requirement(context.args, context) : requirement;
+    assertToolApprovalRequirement(resolved, { allowFunction: false });
+    if (resolved === false) return { approved: true };
+    const reason = resolved === true ? void 0 : resolved.reason;
+    return this.requestApproval(context, reason === void 0 ? {} : { reason }, observation);
+  }
+  async requestApproval(context, options, observation) {
+    const request = {
+      ...context,
+      id: globalThis.crypto.randomUUID()
+    };
+    if (options.reason !== void 0) {
+      request.reason = options.reason;
+    }
+    if (options.rejectMessage !== void 0) {
+      request.rejectMessage = options.rejectMessage;
+    }
+    await observation?.runObservers.event({
+      name: "tool.approval_requested",
+      attributes: approvalEventAttributes(request, observation.turn)
+    });
+    let decision;
+    try {
+      decision = await this.approvalHandler(request);
+    } catch (error) {
+      await observation?.runObservers.event({
+        name: "tool.approval_failed",
+        level: "ERROR",
+        attributes: {
+          ...approvalEventAttributes(request, observation.turn),
+          errorName: error instanceof Error ? error.name : typeof error
+        }
+      });
       throw error;
     }
+    await observation?.runObservers.event({
+      name: "tool.approval_resolved",
+      attributes: {
+        ...approvalEventAttributes(request, observation.turn),
+        approved: decision.approved,
+        ...decision.reason === void 0 ? {} : { decisionReason: decision.reason }
+      }
+    });
+    if (decision.approved) {
+      return { approved: true };
+    }
+    return {
+      approved: false,
+      result: decision.reason ?? request.rejectMessage ?? "Tool approval was rejected."
+    };
   }
 };
-
-// src/request/retry.ts
-var DEFAULT_MAX_ATTEMPTS = 3;
-var DEFAULT_INITIAL_DELAY_MS = 100;
-var DEFAULT_MAX_DELAY_MS = 1e3;
-var MAX_TIMER_DELAY_MS = 2147483647;
-var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 409, 425, 429]);
-var RETRYABLE_NUMERIC_ERROR_CODES = /* @__PURE__ */ new Set([4, 8, 14]);
-var RETRYABLE_ERROR_NAMES = /* @__PURE__ */ new Set([
-  "APIConnectionError",
-  "APIConnectionTimeoutError",
-  "TimeoutError"
-]);
-var RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set([
-  "DEADLINE_EXCEEDED",
-  "EAI_AGAIN",
-  "ECONNREFUSED",
-  "ECONNRESET",
-  "EHOSTUNREACH",
-  "ENETDOWN",
-  "ENETUNREACH",
-  "EPIPE",
-  "ETIMEDOUT",
-  "RESOURCE_EXHAUSTED",
-  "UNAVAILABLE",
-  "UND_ERR_CONNECT_TIMEOUT",
-  "UND_ERR_HEADERS_TIMEOUT",
-  "UND_ERR_SOCKET"
-]);
-function resolveCompletionRetryOptions(options) {
-  const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
-  const initialDelayMs = options.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS;
-  const maxDelayMs = options.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
-  if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {
-    throw new RangeError("Completion retry maxAttempts must be a positive integer.");
-  }
-  assertDelay(initialDelayMs, "initialDelayMs");
-  assertDelay(maxDelayMs, "maxDelayMs");
-  if (maxDelayMs < initialDelayMs) {
-    throw new RangeError(
-      "Completion retry maxDelayMs must be greater than or equal to initialDelayMs."
-    );
+function createApprovalContext(input, hookArgs, agent, run) {
+  const approvalRun = {
+    agentId: agent.id,
+    runId: run.runId
+  };
+  if (run.sessionId !== void 0) {
+    approvalRun.sessionId = run.sessionId;
   }
-  if (options.shouldRetry !== void 0 && typeof options.shouldRetry !== "function") {
-    throw new TypeError("Completion retry shouldRetry must be a function.");
+  if (run.metadata !== void 0) {
+    approvalRun.metadata = run.metadata;
   }
-  return {
-    maxAttempts,
-    initialDelayMs,
-    maxDelayMs,
-    shouldRetry: options.shouldRetry ?? defaultShouldRetry
+  const context = {
+    toolName: hookArgs.toolName,
+    args: lifecycleSnapshot(input),
+    rawArgs: hookArgs.args,
+    internalCallId: hookArgs.internalCallId,
+    run: approvalRun
   };
+  if (hookArgs.toolCallId !== void 0) {
+    context.toolCallId = hookArgs.toolCallId;
+  }
+  return context;
 }
-function completionRetryDelayMs(options, failedAttempt) {
-  const exponentialDelay = options.initialDelayMs * 2 ** (failedAttempt - 1);
-  const cappedDelay = Math.min(options.maxDelayMs, exponentialDelay);
-  return Math.random() * cappedDelay;
-}
-function completionRetryErrorAttributes(error) {
-  const errors = errorChain(error);
-  const errorName = errors.map((candidate) => stringProperty(candidate, "name")).find((value) => value !== void 0);
-  const statusCode = firstStatusCode(errors);
-  const errorCode = errors.map((candidate) => errorCodeProperty(candidate)).find((value) => value !== void 0);
+function approvalEventAttributes(request, turn) {
   return {
-    errorName,
-    statusCode,
-    errorCode
+    turn,
+    approvalId: request.id,
+    toolName: request.toolName,
+    toolCallId: request.toolCallId,
+    internalCallId: request.internalCallId,
+    reason: request.reason
   };
 }
-async function waitForCompletionRetry(delayMs) {
-  if (delayMs === 0) {
-    return;
+function normalizeToolOutputMiddlewareResult(result) {
+  if (typeof result === "string") {
+    return { result };
   }
-  await new Promise((resolve) => setTimeout(resolve, delayMs));
+  return result ?? {};
 }
-function defaultShouldRetry(context) {
-  const errors = errorChain(context.error);
-  if (errors.some((error) => stringProperty(error, "name") === "AbortError")) {
-    return false;
+function toolTraceMetadata(tool) {
+  if (tool === void 0) {
+    return void 0;
   }
-  const statusCode = firstStatusCode(errors);
-  if (statusCode !== void 0) {
-    return RETRYABLE_STATUS_CODES.has(statusCode) || statusCode >= 500 && statusCode <= 599;
+  const metadata = tool[MCP_TOOL_METADATA_KEY];
+  const mcpMetadata = typeof metadata === "object" && metadata !== null ? metadata : void 0;
+  const result = {
+    approvalRequired: toolMayRequireApproval(tool.requiresApproval)
+  };
+  if (typeof mcpMetadata?.serverName === "string" && mcpMetadata.serverName.length > 0) {
+    result.mcpServerName = mcpMetadata.serverName;
   }
-  return errors.some((error) => {
-    const name = stringProperty(error, "name");
-    if (name !== void 0 && RETRYABLE_ERROR_NAMES.has(name)) {
-      return true;
-    }
-    const code = stringProperty(error, "code")?.toUpperCase();
-    if (code !== void 0 && RETRYABLE_ERROR_CODES.has(code)) {
-      return true;
-    }
-    const numericCode = numberProperty(error, "code");
-    return numericCode !== void 0 && RETRYABLE_NUMERIC_ERROR_CODES.has(numericCode);
-  });
+  return result;
 }
-function firstStatusCode(errors) {
-  for (const error of errors) {
-    const status = numberProperty(error, "status") ?? numberProperty(error, "statusCode");
-    if (status !== void 0) {
-      return status;
-    }
-    const code = numberProperty(error, "code");
-    if (code !== void 0 && code >= 100 && code <= 599) {
-      return code;
-    }
-  }
-  return void 0;
+function toolErrorArgs(turn, toolCall, internalCallId, args, error) {
+  const observerArgs = {
+    turn,
+    toolCall,
+    toolName: toolCall.function.name,
+    internalCallId,
+    args,
+    error,
+    ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId }
+  };
+  return observerArgs;
 }
-function errorChain(error) {
-  const errors = [];
-  const seen = /* @__PURE__ */ new Set();
-  let current = error;
-  while (isObject(current) && !seen.has(current)) {
-    seen.add(current);
-    errors.push(current);
-    current = property(current, "cause");
-  }
-  return errors;
-}
-function assertDelay(value, name) {
-  if (!Number.isFinite(value) || value < 0 || value > MAX_TIMER_DELAY_MS) {
-    throw new RangeError(
-      `Completion retry ${name} must be between 0 and ${MAX_TIMER_DELAY_MS} milliseconds.`
-    );
+var ToolObserverScope = class {
+  constructor(observers) {
+    this.observers = observers;
   }
+  observers;
+  terminal = false;
+  streamEvent(args) {
+    return this.observers?.streamEvent(args);
+  }
+  async end(args) {
+    if (this.terminal) return;
+    this.terminal = true;
+    await this.observers?.end(args);
+  }
+  async error(args) {
+    if (this.terminal) return;
+    this.terminal = true;
+    await this.observers?.error(args);
+  }
+};
+function toolOutputToText(output) {
+  return typeof output === "string" ? output : toolResultContentToText(output);
 }
-function numberProperty(value, name) {
-  const candidate = property(value, name);
-  return typeof candidate === "number" && Number.isFinite(candidate) ? candidate : void 0;
-}
-function stringProperty(value, name) {
-  const candidate = property(value, name);
-  return typeof candidate === "string" && candidate.length > 0 ? candidate : void 0;
-}
-function errorCodeProperty(value) {
-  return stringProperty(value, "code") ?? numberProperty(value, "code");
+function toolOutputToStructuredResult(output) {
+  return typeof output === "string" ? void 0 : output;
 }
-function property(value, name) {
-  try {
-    return value[name];
-  } catch {
+function agentToolEventPayload(toolCall, internalCallId, event) {
+  if (typeof event.agentId !== "string" || event.agentId.length === 0) {
     return void 0;
   }
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null;
+  const payload = {
+    type: "agent_tool_event",
+    toolName: toolCall.function.name,
+    internalCallId,
+    agentId: event.agentId,
+    event: event.event
+  };
+  if (toolCall.callId !== void 0) {
+    payload.toolCallId = toolCall.callId;
+  }
+  if (event.agentName !== void 0) {
+    payload.agentName = event.agentName;
+  }
+  return payload;
 }
 
-// src/request/prompt-request.ts
-var PromptRequest = class _PromptRequest {
-  constructor(agent, promptMessage, initialHistory = [], memoryContext = void 0) {
+// src/internal/agent-runtime/agent-run.ts
+function deferredSignal() {
+  let resolve = () => {
+  };
+  const promise = new Promise((done) => {
+    resolve = done;
+  });
+  return { promise, resolve };
+}
+async function settleFailureCleanup(operations) {
+  for (const operation of operations) {
+    try {
+      await operation();
+    } catch {
+    }
+  }
+}
+var AgentRun = class _AgentRun {
+  constructor(agent, promptMessage, initialHistory = [], options = {}) {
     this.agent = agent;
     this.promptMessage = promptMessage;
-    this.memoryContext = memoryContext;
     this.chatHistory = initialHistory;
-    this.maxTurnCount = agent.defaultMaxTurns ?? 0;
-    this.activeHook = agent.hook;
-    this.approvalOptions = agent.approvals;
-    this.guardrailPolicies = [...agent.guardrails];
-    this.memoryRecorder = new PromptRequestMemory(agent, memoryContext, initialHistory);
+    this.maxTurnCount = assertNonnegativeSafeInteger(
+      options.maxTurns ?? agent.defaultMaxTurns ?? 0,
+      "maxTurns"
+    );
+    const internalOptions = getInternalAgentRunOptions(options);
+    this.activeHook = internalOptions?.hook;
+    this.requestedRunId = normalizeRequestedRunId(internalOptions?.runId);
+    this.activeLifecycle = composeAgentLifecycle(agent.lifecycle, options.lifecycle);
+    this.guardrailPolicies = options.guardrails === void 0 ? [...agent.guardrails] : appendGuardrailPolicies([...agent.guardrails], options.guardrails);
+    const configuredConcurrency = assertPositiveSafeInteger(
+      options.toolConcurrency ?? 1,
+      "toolConcurrency"
+    );
+    this.concurrency = this.activeHook !== void 0 || agent.tools.some((tool) => toolMayRequireApproval(tool.requiresApproval)) ? 1 : configuredConcurrency;
+    this.traceOptions = options.trace;
+    this.completionRetryOptions = options.retries === void 0 ? void 0 : resolveRetryOptions(options.retries);
+    this.requestMiddlewares = [...options.middlewares ?? []];
+    this.memoryContext = options.memoryContext;
+    this.memoryRecorder = new AgentRunMemory(agent, options.memoryContext, initialHistory);
   }
   agent;
   promptMessage;
-  memoryContext;
   chatHistory;
   maxTurnCount;
   activeHook;
-  approvalOptions;
+  activeLifecycle;
   guardrailPolicies;
   guardrailDecisions = [];
-  concurrency = 1;
+  concurrency;
   traceOptions;
   completionRetryOptions;
-  requestMiddlewares = [];
+  requestMiddlewares;
   steeringMessages = [];
   runState = "idle";
   memoryRecorder;
-  static fromAgent(agent, prompt, options = {}) {
-    const normalized = normalizePromptInput(prompt);
-    return new _PromptRequest(agent, normalized.prompt, normalized.history, options.memoryContext);
-  }
-  maxTurns(maxTurns) {
-    this.maxTurnCount = maxTurns;
-    return this;
-  }
-  withCompletionRetries(options = {}) {
-    this.completionRetryOptions = resolveCompletionRetryOptions(options);
-    return this;
-  }
-  withHook(hook) {
-    this.activeHook = hook;
-    return this;
-  }
-  approvals(options) {
-    this.approvalOptions = options;
-    return this;
+  memoryContext;
+  pendingApproval;
+  approvalSignal = deferredSignal();
+  activeRunId;
+  requestedRunId;
+  currentUsage = Usage.empty();
+  currentMessages = [];
+  cancellationError;
+  activeGeneration;
+  static fromAgent(agent, input, options = {}) {
+    const normalized = normalizeAgentInput(input);
+    return new _AgentRun(agent, normalized.prompt, normalized.history, options);
   }
-  guardrails(policies) {
-    this.guardrailPolicies = appendGuardrailPolicies(this.guardrailPolicies, policies);
-    return this;
+  steer(input) {
+    if (this.isTerminal() || this.cancellationError !== void 0) {
+      return false;
+    }
+    this.steeringMessages.push(...normalizeSteeringInput(input));
+    return true;
   }
-  withToolConcurrency(concurrency) {
-    this.concurrency = Math.max(1, concurrency);
-    return this;
+  waitForApproval() {
+    return this.pendingApproval === void 0 ? this.approvalSignal.promise : Promise.resolve();
   }
-  withMiddleware(middleware) {
-    this.requestMiddlewares.push(middleware);
-    return this;
+  approvalResult() {
+    const snapshot = this.approvalSnapshot();
+    return { status: "approval_required", ...snapshot };
   }
-  withMiddlewares(middlewares) {
-    this.requestMiddlewares.push(...middlewares);
-    return this;
+  approvalEvent() {
+    const snapshot = this.approvalSnapshot();
+    return { type: "approval_required", ...snapshot };
   }
-  withTrace(trace) {
-    this.traceOptions = trace;
-    return this;
+  resolveApproval(decision) {
+    const pending = this.pendingApproval;
+    if (pending === void 0) {
+      throw new TypeError("Agent run has no pending tool approval.");
+    }
+    this.pendingApproval = void 0;
+    this.approvalSignal = deferredSignal();
+    pending.resolve(decision);
   }
-  steer(input) {
-    if (this.isTerminal()) {
-      return false;
+  cancel(reason) {
+    if (this.isTerminal() || this.cancellationError !== void 0) {
+      return;
+    }
+    const messages = this.currentMessages.length === 0 ? [this.promptMessage] : [...this.currentMessages];
+    const error = new AgentRunCancelledError([...this.chatHistory, ...messages], reason);
+    this.cancellationError = error;
+    const pending = this.pendingApproval;
+    if (pending !== void 0) {
+      this.pendingApproval = void 0;
+      this.approvalSignal = deferredSignal();
+      pending.reject(error);
     }
-    this.steeringMessages.push(...normalizeSteeringInput(input));
-    return true;
   }
-  async send() {
+  async generate() {
     this.startRun();
-    const runId = globalThis.crypto.randomUUID();
+    const runId = this.requestedRunId ?? globalThis.crypto.randomUUID();
+    this.activeRunId = runId;
     let usage = Usage.empty();
     let currentTurns = 0;
     let lastPrompt = this.promptMessage;
     let newMessages = [this.promptMessage];
-    const runObservers = await this.startRunObservers();
+    let runObservers;
     try {
+      const memoryPreparation = await this.memoryRecorder.prepareHistory(runId, newMessages.length);
+      this.chatHistory = memoryPreparation.history;
+      usage = Usage.add(usage, memoryPreparation.usage);
+      runObservers = await this.startRunObservers(runId);
+      await this.recordMemoryCompaction(memoryPreparation, runObservers);
+      await this.activeLifecycle?.onStart?.({
+        runId,
+        input: lifecycleSnapshot(this.promptMessage),
+        history: lifecycleSnapshot(this.chatHistory),
+        maxTurns: this.maxTurnCount
+      });
       const inputResult = await runInputGuardrails(this.guardrailPolicies, {
         prompt: this.promptMessage,
         history: this.chatHistory,
@@ -1717,51 +1979,54 @@ var PromptRequest = class _PromptRequest {
       if (inputResult.blocked) {
         const output = inputResult.message ?? "The request was blocked by a guardrail.";
         const result = {
+          status: "completed",
+          runId,
           output,
-          usage: Usage.empty(),
+          usage,
           messages: [this.promptMessage, Message.assistant(output)],
+          trace: runObservers.trace,
           guardrails: [...this.guardrailDecisions]
         };
+        await this.runLifecycleFinish(result);
         await runObservers.end(result);
         this.runState = "completed";
         return result;
       }
       newMessages = [this.promptMessage];
-      const memoryPreparation = await this.memoryRecorder.prepareRun(runId, newMessages);
-      this.chatHistory = memoryPreparation.history;
-      usage = Usage.add(usage, memoryPreparation.usage);
-      await this.recordMemoryCompaction(memoryPreparation, runObservers);
+      await this.memoryRecorder.commitAcceptedInput(runId, newMessages);
       const pendingTurnMessages = this.memoryRecorder.pendingTurnMessages(newMessages);
       await this.runRunStartHook(newMessages);
       while (currentTurns <= this.maxTurnCount + 1) {
         const prompt = newMessages.at(-1);
         if (prompt === void 0) {
-          throw new Error("PromptRequest requires at least one message");
+          throw new Error("AgentRun requires at least one message");
         }
         lastPrompt = prompt;
         currentTurns += 1;
         const historyForRequest = [...this.chatHistory, ...newMessages.slice(0, -1)];
         await this.runTurnStartHook(currentTurns, prompt, historyForRequest, newMessages);
         await this.runCompletionCallHook(prompt, historyForRequest, newMessages);
-        const ragText = extractRagText(prompt);
-        const dynamicContext = await fetchDynamicContext(this.agent, ragText);
-        const toolDefs = await fetchToolDefinitions(this.agent, ragText);
-        let request = new CompletionRequestBuilder(this.agent.model, prompt).instructions(this.agent.instructions).messages(historyForRequest).documents([...this.agent.staticContext, ...dynamicContext]).tools([...toolDefs, ...this.agent.providerTools]).temperature(this.agent.temperature).maxTokens(this.agent.maxTokens).additionalParams(this.agent.additionalParams).toolChoice(this.agent.toolChoice).outputSchema(this.agent.outputSchema).build();
-        request = await this.runCompletionRequestMiddlewares(
-          request,
-          currentTurns
-        );
+        const request = await this.createTurnRequest(prompt, historyForRequest, currentTurns);
         let response;
         try {
           response = await this.runCompletion(request, currentTurns, runObservers);
         } catch (error) {
-          await this.runCompletionErrorHook(prompt, error, newMessages);
+          await settleFailureCleanup([
+            () => this.runCompletionErrorHook(prompt, error, newMessages)
+          ]);
           throw error;
         }
         response = await this.runCompletionResponseMiddlewares(request, response, currentTurns);
         usage = Usage.add(usage, response.usage);
+        this.updateApprovalProgress(runId, usage, newMessages);
         await this.runCompletionResponseHook(prompt, response, newMessages);
         await this.runTurnEndHook(currentTurns, response, newMessages);
+        await this.activeLifecycle?.onStepFinish?.({
+          runId,
+          step: currentTurns,
+          response: lifecycleSnapshot(response),
+          usage: lifecycleSnapshot(usage)
+        });
         const toolCalls = response.choice.filter(
           (item) => item.type === "tool_call"
         );
@@ -1797,6 +2062,8 @@ var PromptRequest = class _PromptRequest {
             pendingTurnMessages
           );
           const result = {
+            status: "completed",
+            runId,
             output: guardedOutput.output,
             usage,
             messages: [...newMessages],
@@ -1805,22 +2072,18 @@ var PromptRequest = class _PromptRequest {
             ...generationArtifacts(newMessages)
           };
           await this.runRunEndHook(result, newMessages);
-          await runObservers.end(result);
           await this.memoryRecorder.commitCompletedRun(
             runId,
             currentTurns,
             newMessages,
             pendingTurnMessages
           );
+          await this.runLifecycleFinish(result);
+          await runObservers.end(result);
           this.runState = "completed";
           return result;
         }
-        await this.memoryRecorder.commitMessages(
-          runId,
-          currentTurns,
-          [assistantMessage],
-          pendingTurnMessages
-        );
+        this.updateApprovalProgress(runId, usage, newMessages);
         const toolResults = await this.executeToolCalls(
           runId,
           toolCalls,
@@ -1838,7 +2101,7 @@ var PromptRequest = class _PromptRequest {
         await this.memoryRecorder.commitMessages(
           runId,
           currentTurns,
-          [toolMessage],
+          [assistantMessage, toolMessage],
           pendingTurnMessages
         );
         await this.drainSteeringMessages(runId, currentTurns, newMessages, pendingTurnMessages);
@@ -1849,31 +2112,42 @@ var PromptRequest = class _PromptRequest {
       if (error instanceof MemoryCompactionError && error.usage !== void 0) {
         usage = Usage.add(usage, error.usage);
       }
-      const finalError = await this.runRunErrorHook(error, usage, newMessages);
-      this.runState = finalError instanceof PromptCancelledError ? "cancelled" : "errored";
-      await runObservers.error({ error: finalError, usage, messages: [...newMessages] });
-      await this.memoryRecorder.recordError(runId, finalError, newMessages);
-      throw finalError;
+      const reportedError = await this.reportRunFailure(
+        error,
+        runId,
+        usage,
+        newMessages,
+        runObservers
+      );
+      this.runState = reportedError instanceof AgentRunCancelledError ? "cancelled" : "errored";
+      throw reportedError;
     }
   }
-  async *stream(options = {}) {
+  async *events(includeToolCallDeltas = true) {
     if (!this.agent.model.capabilities.streaming || !isStreamingCompletionModel(this.agent.model)) {
       throw new Error("This completion model does not support streaming");
     }
     this.startRun();
-    const includeToolCallDeltas = options.includeToolCallDeltas !== false;
-    const runId = globalThis.crypto.randomUUID();
-    const emit = async (event) => {
-      await this.recordAgentEvent(runId, event);
-      return event;
-    };
+    const runId = this.requestedRunId ?? globalThis.crypto.randomUUID();
+    this.activeRunId = runId;
     let usage = Usage.empty();
     let currentTurns = 0;
     let lastPrompt = this.promptMessage;
     let newMessages = [this.promptMessage];
-    const runObservers = await this.startRunObservers();
     const bufferOutputDeltas = hasEnforcedOutputGuardrails(this.guardrailPolicies);
+    let runObservers;
     try {
+      const memoryPreparation = await this.memoryRecorder.prepareHistory(runId, newMessages.length);
+      this.chatHistory = memoryPreparation.history;
+      usage = Usage.add(usage, memoryPreparation.usage);
+      runObservers = await this.startRunObservers(runId);
+      await this.recordMemoryCompaction(memoryPreparation, runObservers);
+      await this.activeLifecycle?.onStart?.({
+        runId,
+        input: lifecycleSnapshot(this.promptMessage),
+        history: lifecycleSnapshot(this.chatHistory),
+        maxTurns: this.maxTurnCount
+      });
       const inputResult = await runInputGuardrails(this.guardrailPolicies, {
         prompt: this.promptMessage,
         history: this.chatHistory,
@@ -1882,60 +2156,55 @@ var PromptRequest = class _PromptRequest {
       });
       for (const decision of inputResult.decisions) {
         await this.recordGuardrailDecision(decision, runObservers);
-        yield await emit({ type: "guardrail_decision", decision });
+        yield { type: "guardrail_decision", decision };
       }
       this.promptMessage = inputResult.prompt;
       if (inputResult.blocked) {
         const output = inputResult.message ?? "The request was blocked by a guardrail.";
         const result = {
+          status: "completed",
+          runId,
           output,
-          usage: Usage.empty(),
+          usage,
           messages: [this.promptMessage, Message.assistant(output)],
+          trace: runObservers.trace,
           guardrails: [...this.guardrailDecisions]
         };
+        await this.runLifecycleFinish(result);
         await runObservers.end(result);
         this.runState = "completed";
-        yield await emit({
+        yield {
           type: "final",
           runId,
           output: result.output,
           usage: result.usage,
           messages: result.messages,
+          trace: result.trace,
           guardrails: result.guardrails
-        });
+        };
         return;
       }
       newMessages = [this.promptMessage];
-      const memoryPreparation = await this.memoryRecorder.prepareRun(runId, newMessages);
-      this.chatHistory = memoryPreparation.history;
-      usage = Usage.add(usage, memoryPreparation.usage);
-      await this.recordMemoryCompaction(memoryPreparation, runObservers);
+      await this.memoryRecorder.commitAcceptedInput(runId, newMessages);
       const pendingTurnMessages = this.memoryRecorder.pendingTurnMessages(newMessages);
       await this.runRunStartHook(newMessages);
       while (currentTurns <= this.maxTurnCount + 1) {
         const prompt = newMessages.at(-1);
         if (prompt === void 0) {
-          throw new Error("PromptRequest requires at least one message");
+          throw new Error("AgentRun requires at least one message");
         }
         lastPrompt = prompt;
         currentTurns += 1;
         const historyForRequest = [...this.chatHistory, ...newMessages.slice(0, -1)];
-        yield await emit({
+        yield {
           type: "turn_start",
           turn: currentTurns,
           prompt,
           history: historyForRequest
-        });
+        };
         await this.runTurnStartHook(currentTurns, prompt, historyForRequest, newMessages);
         await this.runCompletionCallHook(prompt, historyForRequest, newMessages);
-        const ragText = extractRagText(prompt);
-        const dynamicContext = await fetchDynamicContext(this.agent, ragText);
-        const toolDefs = await fetchToolDefinitions(this.agent, ragText);
-        let request = new CompletionRequestBuilder(this.agent.model, prompt).instructions(this.agent.instructions).messages(historyForRequest).documents([...this.agent.staticContext, ...dynamicContext]).tools([...toolDefs, ...this.agent.providerTools]).temperature(this.agent.temperature).maxTokens(this.agent.maxTokens).additionalParams(this.agent.additionalParams).toolChoice(this.agent.toolChoice).outputSchema(this.agent.outputSchema).build();
-        request = await this.runCompletionRequestMiddlewares(
-          request,
-          currentTurns
-        );
+        const request = await this.createTurnRequest(prompt, historyForRequest, currentTurns);
         assertCompletionRequestSupported(this.agent.model, request, { streaming: true });
         const providerRequest = this.providerTraceRequest(request, { stream: true });
         const generationStartArgs = this.generationStartArgs(
@@ -1944,101 +2213,89 @@ var PromptRequest = class _PromptRequest {
           providerRequest
         );
         const generationObservers = await runObservers.startGeneration(generationStartArgs);
+        this.activeGeneration = { turn: currentTurns, observers: generationObservers };
         const generationStartedAt = Date.now();
-        yield await emit({
+        yield {
           type: "generation_start",
           turn: currentTurns,
           request,
           modelInfo: generationStartArgs.modelInfo
-        });
-        const accumulator = new CompletionStreamAccumulator();
-        let firstDeltaMs;
+        };
         const bufferResponseEvents = this.shouldBufferStreamResponseEvents();
-        const emittedToolCallIds = /* @__PURE__ */ new Set();
+        const completionState = {
+          response: void 0,
+          firstDeltaMs: void 0,
+          emittedToolCallIds: /* @__PURE__ */ new Set(),
+          providerErrorUsage: Usage.empty()
+        };
         let response;
         try {
-          for (let attempt = 1; ; attempt += 1) {
-            let hasProviderProgress = false;
-            try {
-              for await (const event of this.agent.model.streamCompletion(request)) {
-                if (event.type === "error") {
-                  if (event.usage !== void 0) {
-                    usage = Usage.add(usage, event.usage);
-                  }
-                  throw event.error;
-                }
-                hasProviderProgress = true;
-                if (firstDeltaMs === void 0 && isGenerationDeltaEvent(event.type)) {
-                  firstDeltaMs = Date.now() - generationStartedAt;
-                }
-                const mapped = accumulator.accept(event);
-                if (includeToolCallDeltas && event.type === "tool_call_delta") {
-                  yield await emit(addTurnToToolCallDelta(currentTurns, event));
-                }
-                if (mapped !== void 0) {
-                  await generationObservers.update?.({ turn: currentTurns, delta: mapped });
-                  if (mapped.type === "tool_call") {
-                    emittedToolCallIds.add(mapped.toolCall.id);
-                  }
-                  const shouldBuffer = bufferResponseEvents || bufferOutputDeltas && (mapped.type === "text_delta" || mapped.type === "reasoning_delta");
-                  if (!shouldBuffer) {
-                    yield await emit(addTurn(currentTurns, mapped));
-                  }
-                }
-              }
-              response = accumulator.response();
-              break;
-            } catch (error) {
-              const retryOptions = hasProviderProgress ? void 0 : this.retryOptionsForFailure(error, attempt, currentTurns, true);
-              if (retryOptions === void 0) {
-                throw error;
-              }
-              await this.scheduleCompletionRetry(
-                error,
-                attempt,
-                currentTurns,
-                true,
-                retryOptions,
-                runObservers
-              );
+          try {
+            for await (const event of this.streamCompletion({
+              request,
+              turn: currentTurns,
+              includeToolCallDeltas,
+              bufferResponseEvents,
+              bufferOutputDeltas,
+              generationStartedAt,
+              generationObservers,
+              runObservers,
+              state: completionState
+            })) {
+              yield event;
             }
+          } finally {
+            usage = Usage.add(usage, completionState.providerErrorUsage);
           }
+          if (completionState.response === void 0) {
+            throw new Error("Streaming completion ended without a response.");
+          }
+          response = completionState.response;
         } catch (error) {
-          await generationObservers.error({ turn: currentTurns, error });
-          await this.runCompletionErrorHook(prompt, error, newMessages);
+          await settleFailureCleanup([
+            () => this.closeActiveGeneration(error),
+            () => this.runCompletionErrorHook(prompt, error, newMessages)
+          ]);
           throw error;
         }
+        const { firstDeltaMs, emittedToolCallIds } = completionState;
         const generationEndArgs = {
           turn: currentTurns,
-          response
+          response,
+          ...firstDeltaMs === void 0 ? {} : { firstDeltaMs }
         };
-        if (firstDeltaMs !== void 0) {
-          generationEndArgs.firstDeltaMs = firstDeltaMs;
-        }
+        this.activeGeneration = void 0;
         await generationObservers.end(generationEndArgs);
         response = await this.runCompletionResponseMiddlewares(request, response, currentTurns);
         usage = Usage.add(usage, response.usage);
+        this.updateApprovalProgress(runId, usage, newMessages);
         await this.runCompletionResponseHook(prompt, response, newMessages);
         await this.runTurnEndHook(currentTurns, response, newMessages);
+        await this.activeLifecycle?.onStepFinish?.({
+          runId,
+          step: currentTurns,
+          response: lifecycleSnapshot(response),
+          usage: lifecycleSnapshot(usage)
+        });
         const toolCalls = response.choice.filter(
           (item) => item.type === "tool_call"
         );
-        let assistantMessage = this.generatedAssistantMessage(response, request);
+        const assistantMessage = this.generatedAssistantMessage(response, request);
         newMessages.push(assistantMessage);
         if (toolCalls.length === 0) {
           let emittedTurnEnd = false;
           if (!bufferOutputDeltas) {
             if (bufferResponseEvents) {
               for (const event of responseStreamEvents(currentTurns, response)) {
-                yield await emit(event);
+                yield event;
               }
             }
-            yield await emit({
+            yield {
               type: "turn_end",
               turn: currentTurns,
               response,
               firstDeltaMs
-            });
+            };
             emittedTurnEnd = true;
           }
           if (this.steeringMessages.length > 0) {
@@ -2053,128 +2310,58 @@ var PromptRequest = class _PromptRequest {
             await this.memoryRecorder.commitCompletedTurn(runId, currentTurns, pendingTurnMessages);
             continue;
           }
-          const guardedOutput = await this.runOutputGuardrailsForResponse(
+          for await (const event of this.completeStreamingRun({
             runId,
-            usage,
+            turn: currentTurns,
+            request,
             response,
-            newMessages,
-            runObservers
-          );
-          for (const decision of guardedOutput.decisions) {
-            yield await emit({ type: "guardrail_decision", decision });
-          }
-          response = guardedOutput.response;
-          assistantMessage = this.generatedAssistantMessage(response, request);
-          newMessages[newMessages.length - 1] = assistantMessage;
-          await this.memoryRecorder.commitMessages(
-            runId,
-            currentTurns,
-            [assistantMessage],
-            pendingTurnMessages
-          );
-          if (!emittedTurnEnd && (bufferResponseEvents || bufferOutputDeltas)) {
-            for (const event of responseStreamEvents(
-              currentTurns,
-              response,
-              bufferResponseEvents
-            )) {
-              yield await emit(event);
-            }
-          }
-          if (!emittedTurnEnd) {
-            yield await emit({
-              type: "turn_end",
-              turn: currentTurns,
-              response,
-              firstDeltaMs
-            });
-          }
-          const result = {
-            output: guardedOutput.output,
+            firstDeltaMs,
             usage,
-            messages: [...newMessages],
-            trace: runObservers.trace,
-            guardrails: [...this.guardrailDecisions],
-            ...generationArtifacts(newMessages)
-          };
-          await this.runRunEndHook(result, newMessages);
-          await runObservers.end(result);
-          await this.memoryRecorder.commitCompletedRun(
-            runId,
-            currentTurns,
             newMessages,
-            pendingTurnMessages
-          );
-          this.runState = "completed";
-          yield await emit({
-            type: "final",
-            runId,
-            output: result.output,
-            usage: result.usage,
-            contextUsage: result.contextUsage,
-            messages: result.messages,
-            trace: result.trace,
-            guardrails: result.guardrails,
-            sources: result.sources,
-            providerToolCalls: result.providerToolCalls
-          });
+            pendingTurnMessages,
+            runObservers,
+            bufferResponseEvents,
+            bufferOutputDeltas,
+            emittedTurnEnd
+          })) {
+            yield event;
+          }
           return;
         }
         if (bufferResponseEvents) {
           for (const event of responseStreamEvents(currentTurns, response)) {
-            yield await emit(event);
+            yield event;
           }
         } else {
           for (const toolCall of toolCalls) {
             if (!emittedToolCallIds.has(toolCall.id)) {
-              yield await emit({ type: "tool_call", turn: currentTurns, toolCall });
+              yield { type: "tool_call", turn: currentTurns, toolCall };
             }
           }
         }
-        await this.memoryRecorder.commitMessages(
-          runId,
-          currentTurns,
-          [assistantMessage],
-          pendingTurnMessages
-        );
-        yield await emit({
+        this.updateApprovalProgress(runId, usage, newMessages);
+        yield {
           type: "turn_end",
           turn: currentTurns,
           response,
           firstDeltaMs
+        };
+        const toolExecution = this.executeStreamingToolCalls(runId, toolCalls, newMessages, {
+          turn: currentTurns,
+          runObservers,
+          toolDefinitions: request.tools,
+          includeToolCallDeltas
         });
-        const toolResultEvents = createAsyncQueue();
-        const toolResultsPromise = this.executeToolCalls(
-          runId,
-          toolCalls,
-          newMessages,
-          (result) => {
-            toolResultEvents.enqueue(result);
-          },
-          (event) => {
-            toolResultEvents.enqueue(event);
-          },
-          {
-            turn: currentTurns,
-            runObservers,
-            toolDefinitions: request.tools,
-            includeToolCallDeltas
-          }
-        );
-        toolResultsPromise.then(
-          () => toolResultEvents.close(),
-          (error) => toolResultEvents.throw(error)
-        );
-        for await (const result of toolResultEvents) {
-          yield await emit({ turn: currentTurns, ...result });
+        for await (const result of toolExecution.events) {
+          yield { turn: currentTurns, ...result };
         }
-        const toolResults = await toolResultsPromise;
+        const toolResults = await toolExecution.results;
         const toolMessage = Message.tool(toolResults);
         newMessages.push(toolMessage);
         await this.memoryRecorder.commitMessages(
           runId,
           currentTurns,
-          [toolMessage],
+          [assistantMessage, toolMessage],
           pendingTurnMessages
         );
         await this.drainSteeringMessages(runId, currentTurns, newMessages, pendingTurnMessages);
@@ -2185,22 +2372,27 @@ var PromptRequest = class _PromptRequest {
       if (error instanceof MemoryCompactionError && error.usage !== void 0) {
         usage = Usage.add(usage, error.usage);
       }
-      const finalError = await this.runRunErrorHook(error, usage, newMessages);
-      this.runState = finalError instanceof PromptCancelledError ? "cancelled" : "errored";
+      const reportedError = await this.reportRunFailure(
+        error,
+        runId,
+        usage,
+        newMessages,
+        runObservers
+      );
+      this.runState = reportedError instanceof AgentRunCancelledError ? "cancelled" : "errored";
       const finalUsage = usage;
-      await runObservers.error({
-        error: finalError,
-        usage: finalUsage,
-        messages: [...newMessages]
-      });
-      await this.memoryRecorder.recordError(runId, finalError, newMessages);
-      yield await emit({ type: "error", error: finalError, usage: finalUsage });
-      throw finalError;
+      yield { type: "error", error: reportedError, usage: finalUsage };
+      throw reportedError;
+    } finally {
+      if (this.runState === "running") {
+        const cancellation = this.cancellationError ?? new AgentRunCancelledError([...this.chatHistory, ...newMessages], "Agent stream closed.");
+        this.cancellationError = cancellation;
+        await settleFailureCleanup([() => this.closeActiveGeneration(cancellation)]);
+        await this.reportRunFailure(cancellation, runId, usage, newMessages, runObservers);
+        this.runState = "cancelled";
+      }
     }
   }
-  readableStream(options = {}) {
-    return toReadableStream(this.stream(options));
-  }
   async runCompletion(request, turn, runObservers) {
     assertCompletionRequestSupported(this.agent.model, request);
     const providerRequest = this.providerTraceRequest(request);
@@ -2231,10 +2423,146 @@ var PromptRequest = class _PromptRequest {
         return response;
       }
     } catch (error) {
-      await generationObservers.error({ turn, error });
+      await settleFailureCleanup([() => generationObservers.error({ turn, error })]);
       throw error;
     }
   }
+  async createTurnRequest(prompt, history, turn) {
+    const ragText = extractRagText(prompt);
+    const documents = await fetchContextDocuments(this.agent, ragText);
+    const toolDefinitions = await fetchToolDefinitions(this.agent, ragText);
+    const request = createCompletionRequest([...history, prompt], {
+      model: this.agent.model,
+      instructions: this.agent.instructions,
+      documents,
+      tools: [...toolDefinitions, ...getAgentToolState(this.agent).providerTools],
+      temperature: this.agent.temperature,
+      maxTokens: this.agent.maxTokens,
+      additionalParams: this.agent.additionalParams,
+      toolChoice: this.agent.toolChoice,
+      outputSchema: this.agent.outputSchema
+    });
+    return await this.runCompletionRequestMiddlewares(request, turn);
+  }
+  async *streamCompletion(args) {
+    const model = this.agent.model;
+    if (!isStreamingCompletionModel(model)) {
+      throw new TypeError("Streaming completion requires a streaming-capable model.");
+    }
+    const accumulator = new CompletionStreamAccumulator();
+    for (let attempt = 1; ; attempt += 1) {
+      let hasProviderProgress = false;
+      try {
+        for await (const event of model.streamCompletion(args.request)) {
+          if (event.type === "error") {
+            if (event.usage !== void 0) {
+              args.state.providerErrorUsage = Usage.add(args.state.providerErrorUsage, event.usage);
+            }
+            throw event.error;
+          }
+          hasProviderProgress = true;
+          if (args.state.firstDeltaMs === void 0 && isGenerationDeltaEvent(event.type)) {
+            args.state.firstDeltaMs = Date.now() - args.generationStartedAt;
+          }
+          const mapped = accumulator.accept(event);
+          if (args.includeToolCallDeltas && event.type === "tool_call_delta") {
+            yield addTurnToToolCallDelta(args.turn, event);
+          }
+          if (mapped !== void 0) {
+            await args.generationObservers.update?.({ turn: args.turn, delta: mapped });
+            if (mapped.type === "tool_call") {
+              args.state.emittedToolCallIds.add(mapped.toolCall.id);
+            }
+            const shouldBuffer = args.bufferResponseEvents || args.bufferOutputDeltas && (mapped.type === "text_delta" || mapped.type === "reasoning_delta");
+            if (!shouldBuffer) {
+              yield addTurn(args.turn, mapped);
+            }
+          }
+        }
+        args.state.response = accumulator.response();
+        return;
+      } catch (error) {
+        const retryOptions = hasProviderProgress ? void 0 : this.retryOptionsForFailure(error, attempt, args.turn, true);
+        if (retryOptions === void 0) {
+          throw error;
+        }
+        await this.scheduleCompletionRetry(
+          error,
+          attempt,
+          args.turn,
+          true,
+          retryOptions,
+          args.runObservers
+        );
+      }
+    }
+  }
+  async *completeStreamingRun(args) {
+    const guardedOutput = await this.runOutputGuardrailsForResponse(
+      args.runId,
+      args.usage,
+      args.response,
+      args.newMessages,
+      args.runObservers
+    );
+    for (const decision of guardedOutput.decisions) {
+      yield { type: "guardrail_decision", decision };
+    }
+    const response = guardedOutput.response;
+    const assistantMessage = this.generatedAssistantMessage(response, args.request);
+    args.newMessages[args.newMessages.length - 1] = assistantMessage;
+    await this.memoryRecorder.commitMessages(
+      args.runId,
+      args.turn,
+      [assistantMessage],
+      args.pendingTurnMessages
+    );
+    if (!args.emittedTurnEnd && (args.bufferResponseEvents || args.bufferOutputDeltas)) {
+      for (const event of responseStreamEvents(args.turn, response, args.bufferResponseEvents)) {
+        yield event;
+      }
+    }
+    if (!args.emittedTurnEnd) {
+      yield {
+        type: "turn_end",
+        turn: args.turn,
+        response,
+        firstDeltaMs: args.firstDeltaMs
+      };
+    }
+    const result = {
+      status: "completed",
+      runId: args.runId,
+      output: guardedOutput.output,
+      usage: args.usage,
+      messages: [...args.newMessages],
+      trace: args.runObservers.trace,
+      guardrails: [...this.guardrailDecisions],
+      ...generationArtifacts(args.newMessages)
+    };
+    await this.runRunEndHook(result, args.newMessages);
+    await this.memoryRecorder.commitCompletedRun(
+      args.runId,
+      args.turn,
+      args.newMessages,
+      args.pendingTurnMessages
+    );
+    await this.runLifecycleFinish(result);
+    await args.runObservers.end(result);
+    this.runState = "completed";
+    yield {
+      type: "final",
+      runId: args.runId,
+      output: result.output,
+      usage: result.usage,
+      contextUsage: result.contextUsage,
+      messages: result.messages,
+      trace: result.trace,
+      guardrails: result.guardrails,
+      sources: result.sources,
+      providerToolCalls: result.providerToolCalls
+    };
+  }
   generatedAssistantMessage(response, request) {
     const metadata = {
       anvia: {
@@ -2263,19 +2591,16 @@ var PromptRequest = class _PromptRequest {
     }
   }
   generationStartArgs(turn, request, providerRequest) {
-    const args = {
+    return {
       turn,
       request,
       modelInfo: {
         provider: this.agent.model.provider,
         defaultModel: this.agent.model.defaultModel,
         capabilities: this.agent.model.capabilities
-      }
+      },
+      ...providerRequest === void 0 ? {} : { providerRequest }
     };
-    if (providerRequest !== void 0) {
-      args.providerRequest = providerRequest;
-    }
-    return args;
   }
   retryOptionsForFailure(error, attempt, turn, streaming) {
     const options = this.completionRetryOptions;
@@ -2292,7 +2617,7 @@ var PromptRequest = class _PromptRequest {
     return shouldRetry ? options : void 0;
   }
   async scheduleCompletionRetry(error, attempt, turn, streaming, options, runObservers) {
-    const delayMs = completionRetryDelayMs(options, attempt);
+    const delayMs = retryDelayMs(options, attempt);
     await runObservers.event({
       name: "completion.retry",
       level: "WARNING",
@@ -2303,16 +2628,17 @@ var PromptRequest = class _PromptRequest {
         maxAttempts: options.maxAttempts,
         delayMs,
         streaming,
-        ...completionRetryErrorAttributes(error)
+        ...retryErrorAttributes(error)
       }
     });
-    await waitForCompletionRetry(delayMs);
+    await waitForRetry(delayMs);
   }
   async executeToolCalls(runId, toolCalls, newMessages, onResult, onStreamEvent, observation) {
     const executor = new ToolCallExecutor(
       this.agent,
       this.activeHook,
-      this.approvalOptions,
+      (request) => this.suspendForApproval(request),
+      this.activeLifecycle,
       {
         runId,
         sessionId: this.memoryContext?.sessionId,
@@ -2325,6 +2651,109 @@ var PromptRequest = class _PromptRequest {
     );
     return executor.execute(toolCalls, onResult, onStreamEvent, observation);
   }
+  executeStreamingToolCalls(runId, toolCalls, newMessages, observation) {
+    const events = createAsyncQueue();
+    const results = this.executeToolCalls(
+      runId,
+      toolCalls,
+      newMessages,
+      (result) => events.enqueue(result),
+      (event) => events.enqueue(event),
+      observation
+    );
+    results.then(
+      () => events.close(),
+      (error) => events.throw(error)
+    );
+    return { events, results };
+  }
+  suspendForApproval(request) {
+    if (this.cancellationError !== void 0) {
+      return Promise.reject(this.cancellationError);
+    }
+    if (this.pendingApproval !== void 0) {
+      throw new Error("Agent run already has a pending tool approval.");
+    }
+    return new Promise((resolve, reject) => {
+      this.pendingApproval = { request, resolve, reject };
+      this.approvalSignal.resolve();
+    });
+  }
+  async closeActiveGeneration(error) {
+    const active = this.activeGeneration;
+    if (active === void 0) {
+      return;
+    }
+    this.activeGeneration = void 0;
+    await active.observers.error({ turn: active.turn, error });
+  }
+  approvalSnapshot() {
+    const pending = this.pendingApproval;
+    const runId = this.activeRunId;
+    if (pending === void 0 || runId === void 0) {
+      throw new TypeError("Agent run has no pending tool approval.");
+    }
+    const approval = {
+      id: pending.request.id,
+      toolName: pending.request.toolName,
+      input: lifecycleSnapshot(pending.request.args),
+      ...pending.request.toolCallId === void 0 ? {} : { toolCallId: pending.request.toolCallId },
+      ...pending.request.reason === void 0 ? {} : { reason: pending.request.reason }
+    };
+    registerAgentApprovalRequestDetails(approval, pending.request);
+    return {
+      runId,
+      approval,
+      usage: lifecycleSnapshot(this.currentUsage),
+      messages: lifecycleSnapshot(this.currentMessages)
+    };
+  }
+  updateApprovalProgress(runId, usage, messages) {
+    this.activeRunId = runId;
+    this.currentUsage = usage;
+    this.currentMessages = [...messages];
+  }
+  async runLifecycleFinish(result) {
+    await this.activeLifecycle?.onFinish?.({
+      runId: result.runId,
+      output: result.output,
+      usage: lifecycleSnapshot(result.usage),
+      messages: lifecycleSnapshot(result.messages)
+    });
+  }
+  async runLifecycleError(error, runId, usage, messages) {
+    try {
+      await this.activeLifecycle?.onError?.({
+        runId,
+        error: lifecycleSnapshot(error),
+        usage: lifecycleSnapshot(usage),
+        messages: lifecycleSnapshot([...this.chatHistory, ...messages])
+      });
+      return void 0;
+    } catch (lifecycleError) {
+      return lifecycleError;
+    }
+  }
+  async reportRunFailure(error, runId, usage, messages, runObservers) {
+    const reportedError = await this.resolveReportedRunError(error, runId, usage, messages);
+    await settleFailureCleanup([
+      () => runObservers?.error({
+        error: reportedError,
+        usage,
+        messages: [...messages]
+      }),
+      () => this.memoryRecorder.recordError(runId, reportedError, messages)
+    ]);
+    return reportedError;
+  }
+  async resolveReportedRunError(error, runId, usage, messages) {
+    try {
+      await this.runRunErrorHook(error, usage, messages);
+    } catch {
+    }
+    await this.runLifecycleError(error, runId, usage, messages);
+    return error;
+  }
   async runOutputGuardrailsForResponse(runId, usage, response, messages, runObservers) {
     const originalOutput = textFromAssistantContent(response.choice);
     const result = await runOutputGuardrails(this.guardrailPolicies, {
@@ -2388,11 +2817,12 @@ var PromptRequest = class _PromptRequest {
     }
     return context;
   }
-  async startRunObservers() {
+  async startRunObservers(runId) {
     const failOnObserverError = this.traceOptions?.failOnObserverError === true || this.agent.observers.some((registration) => registration.failOnObserverError === true);
     return startAgentRunObservers(
       this.agent.observers,
       {
+        runId,
         agentName: this.agent.name,
         agentDescription: this.agent.description,
         instructions: this.agent.instructions,
@@ -2405,37 +2835,6 @@ var PromptRequest = class _PromptRequest {
       failOnObserverError
     );
   }
-  async recordAgentEvent(runId, event) {
-    const registration = this.agent.eventStore;
-    if (registration === void 0) {
-      return;
-    }
-    if (registration.options.include === "agent_tool_events" && event.type !== "agent_tool_event") {
-      return;
-    }
-    const turn = "turn" in event ? event.turn : void 0;
-    const agentId = event.type === "agent_tool_event" ? event.agentId : this.agent.id;
-    const agentName = event.type === "agent_tool_event" ? event.agentName : this.agent.name;
-    const input = {
-      runId,
-      agentId,
-      event
-    };
-    if (agentName !== void 0) {
-      input.agentName = agentName;
-    }
-    if (turn !== void 0) {
-      input.turn = turn;
-    }
-    if (event.type === "agent_tool_event") {
-      input.toolName = event.toolName;
-      input.internalCallId = event.internalCallId;
-      if (event.toolCallId !== void 0) {
-        input.toolCallId = event.toolCallId;
-      }
-    }
-    await registration.store.append(input);
-  }
   async runCompletionCallHook(prompt, history, newMessages) {
     const action = await this.activeHook?.onCompletionCall?.({
       prompt,
@@ -2476,9 +2875,8 @@ var PromptRequest = class _PromptRequest {
       run: runControl
     });
     if (action?.type === "terminate") {
-      return this.cancelled(newMessages, action.reason);
+      this.cancelled(newMessages, action.reason);
     }
-    return error;
   }
   async runTurnStartHook(turn, prompt, history, newMessages) {
     const action = await this.activeHook?.onTurnStart?.({
@@ -2571,18 +2969,18 @@ var PromptRequest = class _PromptRequest {
       return;
     }
     if (this.runState === "running") {
-      throw new Error("PromptRequest is already running.");
+      throw new Error("Agent stream is already running.");
     }
-    throw new Error("PromptRequest has already been used.");
+    throw new Error("Agent stream has already been consumed.");
   }
   isTerminal() {
     return this.runState === "completed" || this.runState === "errored" || this.runState === "cancelled";
   }
   cancelled(newMessages, reason) {
-    return new PromptCancelledError([...this.chatHistory, ...newMessages], reason);
+    return new AgentRunCancelledError([...this.chatHistory, ...newMessages], reason);
   }
 };
-function normalizePromptInput(prompt) {
+function normalizeAgentInput(prompt) {
   if (typeof prompt === "string") {
     return { prompt: Message.user(prompt), history: [] };
   }
@@ -2590,11 +2988,11 @@ function normalizePromptInput(prompt) {
     return { prompt, history: [] };
   }
   if (prompt.length === 0) {
-    throw new TypeError("Prompt transcript must contain at least one message.");
+    throw new TypeError("Agent input transcript must contain at least one message.");
   }
   const activePrompt = prompt.at(-1);
   if (activePrompt === void 0) {
-    throw new TypeError("Prompt transcript must contain at least one message.");
+    throw new TypeError("Agent input transcript must contain at least one message.");
   }
   return {
     prompt: activePrompt,
@@ -2607,6 +3005,15 @@ function normalizeSteeringInput(input) {
   }
   return Array.isArray(input) ? [...input] : [input];
 }
+function normalizeRequestedRunId(runId) {
+  if (runId === void 0) {
+    return void 0;
+  }
+  if (typeof runId !== "string" || runId.trim().length === 0) {
+    throw new TypeError("runId must be a non-empty string.");
+  }
+  return runId;
+}
 function responseStreamEvents(turn, response, includeProviderArtifacts = true) {
   const events = [];
   for (const item of response.choice) {
@@ -2722,11 +3129,620 @@ function guardrailDecisionAttributes(decision) {
   return attributes;
 }
 
+// src/agent/ids.ts
+function normalizeAgentId(id) {
+  if (typeof id !== "string") {
+    throw new TypeError("Agent id must be a string.");
+  }
+  const normalized = id.trim();
+  if (normalized.length === 0) {
+    throw new TypeError("Agent id must be a non-empty string.");
+  }
+  return normalized;
+}
+
+// src/agent/agent.ts
+var DEFAULT_MAX_TURNS = 20;
+var Agent = class {
+  id;
+  name;
+  description;
+  model;
+  instructions;
+  context;
+  temperature;
+  maxTokens;
+  additionalParams;
+  tools;
+  toolChoice;
+  defaultMaxTurns;
+  lifecycle;
+  outputSchema;
+  observers;
+  guardrails;
+  middlewares;
+  memory;
+  constructor(options) {
+    const resolved = resolveAgentOptions(options);
+    this.id = normalizeAgentId(resolved.id);
+    this.name = resolved.name;
+    this.description = resolved.description;
+    this.model = resolved.model;
+    this.instructions = resolved.instructions;
+    const context = (resolved.context ?? []).map(snapshotContextInput);
+    assertValidContextIndexes(context);
+    this.context = Object.freeze(context);
+    this.temperature = resolved.temperature;
+    this.maxTokens = resolved.maxTokens;
+    this.additionalParams = cloneFrozenPlainData(resolved.additionalParams);
+    const staticTools = dedupeTools(resolved.tools ?? []);
+    const toolIndexes = (resolved.toolIndexes ?? []).map(snapshotToolIndex);
+    assertUniqueIndexedToolNames(toolIndexes);
+    const toolsByName = new Map(staticTools.map((tool) => [tool.name, tool]));
+    for (const index of toolIndexes) {
+      for (const tool of index.tools) {
+        if (!toolsByName.has(tool.name)) {
+          toolsByName.set(tool.name, tool);
+        }
+      }
+    }
+    this.tools = Object.freeze([...toolsByName.values()]);
+    const publicToolState = Object.freeze({
+      staticTools: Object.freeze(staticTools),
+      providerTools: Object.freeze((resolved.providerTools ?? []).map(snapshotProviderTool)),
+      toolIndexes: Object.freeze(toolIndexes)
+    });
+    registerAgentToolState(this, publicToolState, toolsByName);
+    this.toolChoice = cloneFrozenPlainData(resolved.toolChoice);
+    this.defaultMaxTurns = assertNonnegativeSafeInteger(
+      resolved.defaultMaxTurns ?? DEFAULT_MAX_TURNS,
+      "maxTurns"
+    );
+    this.lifecycle = resolved.lifecycle;
+    this.outputSchema = cloneFrozenPlainData(resolved.outputSchema);
+    this.observers = Object.freeze(
+      (resolved.observers ?? []).map((registration) => Object.freeze({ ...registration }))
+    );
+    this.guardrails = Object.freeze((resolved.guardrails ?? []).map(snapshotGuardrailPolicy));
+    this.middlewares = Object.freeze([...resolved.middlewares ?? []]);
+    this.memory = snapshotMemoryRegistration(resolved.memory);
+  }
+  generate(input, options = {}) {
+    return createGenerateExecution(this, AgentRun.fromAgent(this, input, options)).next();
+  }
+  stream(input, options = {}) {
+    return createStreamExecution(
+      this,
+      AgentRun.fromAgent(this, input, options),
+      options.includeToolCallDeltas !== false
+    );
+  }
+  resume(pending, decision) {
+    assertAgentApprovalDecision(decision);
+    const continuation = approvalContinuations.get(pending);
+    if (continuation === void 0 || continuation.agent !== this) {
+      throw new TypeError("Approval continuation does not belong to this agent.");
+    }
+    approvalContinuations.delete(pending);
+    continuation.run.resolveApproval(decision);
+    return continuation.mode === "generate" ? continuation.execution.next() : continuation.execution.segment();
+  }
+  session(sessionId, options = {}) {
+    if (this.memory === void 0) {
+      throw new Error(`Agent "${this.id}" has no memory store configured.`);
+    }
+    const normalized = sessionId.trim();
+    if (normalized.length === 0) {
+      throw new TypeError("Session id must be a non-empty string.");
+    }
+    const context = {
+      sessionId: normalized
+    };
+    if (options.userId !== void 0) {
+      context.userId = options.userId;
+    }
+    if (options.metadata !== void 0) {
+      context.metadata = cloneFrozenPlainData(options.metadata);
+    }
+    return new AgentSession(this, context);
+  }
+  asTool(options) {
+    const description = options.description ?? this.description ?? `Prompt the ${options.name} agent.`;
+    return createTool({
+      name: options.name,
+      description,
+      inputSchema: z.object({
+        prompt: z.string().describe("The prompt to send to the agent.")
+      }),
+      outputSchema: z.string(),
+      execute: async ({ prompt }, context) => {
+        if (options.stream === true && context.emitStreamEvent !== void 0 && this.model.capabilities.streaming && isStreamingCompletionModel(this.model)) {
+          let output = "";
+          const childStream = this.stream(prompt, {
+            maxTurns: options.maxTurns,
+            includeToolCallDeltas: context.includeToolCallDeltas !== false
+          });
+          for await (const event of childStream) {
+            if (event.type === "approval_required") {
+              await cancelAgentApproval(
+                event,
+                `Agent tool "${options.name}" cannot suspend for tool approval.`
+              );
+              throw new Error(
+                `Agent tool "${options.name}" cannot suspend for tool approval. Run the agent directly to handle approvals.`
+              );
+            }
+            const streamEvent = {
+              agentId: this.id,
+              event
+            };
+            if (this.name !== void 0) {
+              streamEvent.agentName = this.name;
+            }
+            await context.emitStreamEvent(streamEvent);
+            if (event.type === "final") {
+              output = event.output;
+            }
+          }
+          return output;
+        }
+        const response = await this.generate(prompt, { maxTurns: options.maxTurns });
+        if (response.status === "approval_required") {
+          await cancelAgentApproval(
+            response,
+            `Agent tool "${options.name}" cannot suspend for tool approval.`
+          );
+          throw new Error(
+            `Agent tool "${options.name}" cannot suspend for tool approval. Run the agent directly to handle approvals.`
+          );
+        }
+        return response.output;
+      }
+    });
+  }
+  getTool(toolName) {
+    return getRegisteredAgentTool(this, toolName);
+  }
+  async callTool(toolName, args, context) {
+    const tool = this.getTool(toolName);
+    if (tool === void 0) {
+      throw new ToolNotFoundError(toolName);
+    }
+    return prepareToolCall(tool, args).call(context ?? {});
+  }
+};
+var resolvedAgentOptions = /* @__PURE__ */ Symbol("resolvedAgentOptions");
+function createResolvedAgent(options) {
+  return new Agent({
+    ...options,
+    [resolvedAgentOptions]: true
+  });
+}
+function getResolvedAgentOptions(agent) {
+  const toolState = getAgentToolState(agent);
+  return {
+    id: agent.id,
+    name: agent.name,
+    description: agent.description,
+    model: agent.model,
+    instructions: agent.instructions,
+    context: [...agent.context],
+    temperature: agent.temperature,
+    maxTokens: agent.maxTokens,
+    additionalParams: agent.additionalParams,
+    tools: [...toolState.staticTools],
+    providerTools: [...toolState.providerTools],
+    toolIndexes: [...toolState.toolIndexes],
+    toolChoice: agent.toolChoice,
+    defaultMaxTurns: agent.defaultMaxTurns,
+    lifecycle: agent.lifecycle,
+    outputSchema: agent.outputSchema,
+    observers: [...agent.observers],
+    guardrails: [...agent.guardrails],
+    middlewares: [...agent.middlewares],
+    memory: agent.memory
+  };
+}
+function resolveAgentOptions(options) {
+  if (isInternalAgentOptions(options)) {
+    return options;
+  }
+  const toolsByName = /* @__PURE__ */ new Map();
+  const providerTools = [];
+  const toolIndexes = [];
+  for (const tool of options.tools ?? []) {
+    if (isProviderTool(tool)) {
+      providerTools.push(tool);
+    } else if (isToolIndex(tool)) {
+      toolIndexes.push(tool);
+    } else if (tool.kind === "tool-index") {
+      throw new TypeError(
+        "Invalid tool index: search, searchIds, asTool, tools, and a numeric topK are required."
+      );
+    } else {
+      toolsByName.set(tool.name, tool);
+    }
+  }
+  for (const server of options.mcpServers ?? []) {
+    for (const tool of server.tools) {
+      toolsByName.set(tool.name, tool);
+    }
+  }
+  if (options.skills !== void 0) {
+    for (const tool of options.skills.tools) {
+      toolsByName.set(tool.name, tool);
+    }
+  }
+  const memory = resolveAgentMemory(options);
+  const instructions = [options.instructions, options.skills?.instructions].filter((part) => part !== void 0 && part.length > 0).join("\n\n");
+  return {
+    id: options.id,
+    name: options.name,
+    description: options.description,
+    model: options.model,
+    instructions: instructions.length === 0 ? void 0 : instructions,
+    context: [...options.context ?? []],
+    temperature: options.temperature,
+    maxTokens: options.maxTokens,
+    additionalParams: options.additionalParams,
+    tools: [...toolsByName.values()],
+    providerTools,
+    toolIndexes,
+    toolChoice: options.toolChoice,
+    defaultMaxTurns: options.maxTurns,
+    lifecycle: options.lifecycle,
+    outputSchema: options.outputSchema === void 0 ? void 0 : toProviderJsonSchema(options.outputSchema),
+    observers: (options.observers ?? []).map(
+      (input) => "observer" in input ? { observer: input.observer, failOnObserverError: input.failOnObserverError } : { observer: input }
+    ),
+    guardrails: options.guardrails === void 0 ? [] : appendGuardrailPolicies([], options.guardrails),
+    middlewares: [...options.middlewares ?? []],
+    memory
+  };
+}
+function assertUniqueIndexedToolNames(indexes) {
+  const owners = /* @__PURE__ */ new Map();
+  for (const [indexPosition, index] of indexes.entries()) {
+    if (!isToolIndex(index)) {
+      throw new TypeError(
+        "Invalid tool index: search, searchIds, asTool, tools, and a numeric topK are required."
+      );
+    }
+    assertPositiveSearchLimit(index.topK);
+    assertFiniteSearchThreshold(index.threshold);
+    for (const tool of index.tools) {
+      const existingPosition = owners.get(tool.name);
+      if (existingPosition !== void 0) {
+        if (existingPosition === indexPosition) {
+          throw new TypeError(
+            `Tool "${tool.name}" is registered more than once by tool index ${indexPosition + 1}. Tool names must be unique within each index.`
+          );
+        }
+        throw new TypeError(
+          `Tool "${tool.name}" is registered by multiple tool indexes (${existingPosition + 1} and ${indexPosition + 1}). Tool names must be unique across indexes.`
+        );
+      }
+      owners.set(tool.name, indexPosition);
+    }
+  }
+}
+function assertValidContextIndexes(inputs) {
+  for (const input of inputs) {
+    if (!isContextIndex(input)) continue;
+    assertPositiveSearchLimit(input.topK);
+    assertFiniteSearchThreshold(input.threshold);
+  }
+}
+function isInternalAgentOptions(options) {
+  return options[resolvedAgentOptions] === true;
+}
+function resolveAgentMemory(options) {
+  if (options.memory === void 0) {
+    return void 0;
+  }
+  const { store, ...memoryOptions } = options.memory;
+  const resolvedOptions = resolveMemoryOptions(memoryOptions);
+  if (resolvedOptions.compaction !== void 0 && store.compaction === void 0) {
+    throw new TypeError(
+      "Memory compaction requires a store with the optional compaction capability."
+    );
+  }
+  return { store, options: resolvedOptions };
+}
+var approvalContinuations = /* @__PURE__ */ new WeakMap();
+function assertAgentApprovalDecision(decision) {
+  if (typeof decision !== "object" || decision === null || typeof decision.approved !== "boolean") {
+    throw new TypeError("Approval decision must include an approved boolean.");
+  }
+  if (decision.reason !== void 0 && typeof decision.reason !== "string") {
+    throw new TypeError("Approval decision reason must be a string.");
+  }
+}
+function createGenerateExecution(agent, run) {
+  const completion = run.generate();
+  const execution = {
+    async next() {
+      const outcome = await Promise.race([
+        completion.then((result) => ({ type: "completed", result })),
+        run.waitForApproval().then(() => ({ type: "approval" }))
+      ]);
+      if (outcome.type === "completed") {
+        return outcome.result;
+      }
+      const pending = run.approvalResult();
+      approvalContinuations.set(pending, { agent, run, mode: "generate", execution });
+      return pending;
+    },
+    async cancel(reason) {
+      run.cancel(reason);
+      await completion.catch(() => void 0);
+    }
+  };
+  return execution;
+}
+var StreamExecution = class {
+  constructor(agent, run, includeToolCallDeltas) {
+    this.agent = agent;
+    this.run = run;
+    this.iterator = run.events(includeToolCallDeltas)[Symbol.asyncIterator]();
+  }
+  agent;
+  run;
+  iterator;
+  nextEvent;
+  phase = "active";
+  segment() {
+    if (this.phase === "approval") {
+      this.phase = "active";
+    }
+    return new DefaultAgentStream(this);
+  }
+  steer(input) {
+    return this.run.steer(input);
+  }
+  async *events() {
+    while (true) {
+      this.nextEvent ??= this.iterator.next();
+      let outcome;
+      try {
+        outcome = await Promise.race([
+          this.nextEvent.then((event) => ({ type: "event", event })),
+          this.run.waitForApproval().then(() => ({ type: "approval" }))
+        ]);
+      } catch (error) {
+        this.phase = "terminal";
+        throw error;
+      }
+      if (outcome.type === "approval") {
+        this.phase = "approval";
+        const pending = this.run.approvalEvent();
+        approvalContinuations.set(pending, {
+          agent: this.agent,
+          run: this.run,
+          mode: "stream",
+          execution: this
+        });
+        yield pending;
+        return;
+      }
+      this.nextEvent = void 0;
+      if (outcome.event.done) {
+        this.phase = "terminal";
+        return;
+      }
+      yield outcome.event.value;
+    }
+  }
+  shouldCancelActiveSegment() {
+    return this.phase === "active";
+  }
+  async cancel(reason) {
+    if (this.phase === "terminal" || this.phase === "cancelled") {
+      return;
+    }
+    this.phase = "cancelled";
+    this.run.cancel(reason);
+    try {
+      await this.iterator.return?.();
+    } catch {
+    }
+  }
+};
+function createStreamExecution(agent, run, includeToolCallDeltas) {
+  return new StreamExecution(agent, run, includeToolCallDeltas).segment();
+}
+var DefaultAgentStream = class {
+  constructor(execution) {
+    this.execution = execution;
+  }
+  execution;
+  consuming = false;
+  completed = false;
+  steer(input) {
+    return this.execution.steer(input);
+  }
+  [Symbol.asyncIterator]() {
+    return this.consume()[Symbol.asyncIterator]();
+  }
+  async *consume() {
+    if (this.completed) {
+      throw new Error("Agent stream has already been consumed.");
+    }
+    if (this.consuming) {
+      throw new Error("Agent stream is already running.");
+    }
+    this.consuming = true;
+    try {
+      for await (const event of this.execution.events()) {
+        yield event;
+      }
+    } finally {
+      if (this.execution.shouldCancelActiveSegment()) {
+        await this.execution.cancel("Agent stream consumer closed the stream.");
+      }
+      this.consuming = false;
+      this.completed = true;
+    }
+  }
+};
+async function cancelAgentApproval(pending, reason) {
+  const continuation = approvalContinuations.get(pending);
+  if (continuation === void 0) {
+    return;
+  }
+  approvalContinuations.delete(pending);
+  await continuation.execution.cancel(reason);
+}
+var AgentSession = class {
+  constructor(agent, context) {
+    this.agent = agent;
+    this.context = context;
+  }
+  agent;
+  context;
+  generate(input, options = {}) {
+    if (Array.isArray(input)) {
+      throw new TypeError("AgentSession.generate does not accept Message[] transcripts.");
+    }
+    const run = AgentRun.fromAgent(this.agent, input, {
+      ...options,
+      memoryContext: this.context
+    });
+    return createGenerateExecution(this.agent, run).next();
+  }
+  stream(input, options = {}) {
+    if (Array.isArray(input)) {
+      throw new TypeError("AgentSession.stream does not accept Message[] transcripts.");
+    }
+    return createStreamExecution(
+      this.agent,
+      AgentRun.fromAgent(this.agent, input, { ...options, memoryContext: this.context }),
+      options.includeToolCallDeltas !== false
+    );
+  }
+  async messages() {
+    const memory = this.agent.memory;
+    if (memory === void 0) {
+      throw new Error(`Agent "${this.agent.id}" has no memory store configured.`);
+    }
+    return memory.store.load(this.context);
+  }
+  async contextUsage() {
+    const messages = await this.messages();
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+      const message = messages[index];
+      if (message === void 0) {
+        continue;
+      }
+      const generation = getAssistantGenerationMetadata(message);
+      if (generation !== void 0) {
+        return generation.contextUsage;
+      }
+    }
+    return void 0;
+  }
+  async clear() {
+    const memory = this.agent.memory;
+    if (memory === void 0) {
+      throw new Error(`Agent "${this.agent.id}" has no memory store configured.`);
+    }
+    await memory.store.clear(this.context);
+  }
+};
+function snapshotContextInput(input) {
+  if (!isContextIndex(input)) {
+    return Object.freeze({
+      id: input.id,
+      text: input.text,
+      ...input.additionalProps === void 0 ? {} : { additionalProps: cloneFrozenPlainData(input.additionalProps) }
+    });
+  }
+  const format = input.format;
+  return Object.freeze({
+    kind: "context-index",
+    index: input.index,
+    topK: input.topK,
+    ...input.threshold === void 0 ? {} : { threshold: input.threshold },
+    ...input.filter === void 0 ? {} : { filter: cloneFrozenPlainData(input.filter) },
+    ...format === void 0 ? {} : { format: (result) => format.call(input, result) }
+  });
+}
+function snapshotProviderTool(tool) {
+  return Object.freeze({
+    ...tool,
+    ...tool.configuration === void 0 ? {} : { configuration: cloneFrozenPlainData(tool.configuration) }
+  });
+}
+function snapshotToolIndex(index) {
+  const inspect = index.inspect;
+  return Object.freeze({
+    kind: "tool-index",
+    tools: Object.freeze([...index.tools]),
+    topK: index.topK,
+    ...index.threshold === void 0 ? {} : { threshold: index.threshold },
+    ...index.filter === void 0 ? {} : { filter: cloneFrozenPlainData(index.filter) },
+    search: (request) => index.search(request),
+    searchIds: (request) => index.searchIds(request),
+    asTool: (options) => index.asTool(options),
+    ...inspect === void 0 ? {} : { inspect: (request) => inspect.call(index, request) }
+  });
+}
+function snapshotGuardrailPolicy(policy) {
+  return Object.freeze({
+    ...policy,
+    input: Object.freeze([...policy.input]),
+    output: Object.freeze([...policy.output])
+  });
+}
+function snapshotMemoryRegistration(memory) {
+  if (memory === void 0) {
+    return void 0;
+  }
+  const compaction = memory.options.compaction === void 0 ? void 0 : Object.freeze({ ...memory.options.compaction });
+  return Object.freeze({
+    store: memory.store,
+    options: Object.freeze({
+      ...memory.options,
+      ...compaction === void 0 ? {} : { compaction }
+    })
+  });
+}
+function cloneFrozenPlainData(value) {
+  if (Array.isArray(value)) {
+    return Object.freeze(value.map(cloneFrozenPlainData));
+  }
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    return value;
+  }
+  const clone = Object.fromEntries(
+    Object.entries(value).map(([key, item]) => [key, cloneFrozenPlainData(item)])
+  );
+  return Object.freeze(clone);
+}
+function dedupeTools(tools) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    byName.set(tool.name, tool);
+  }
+  return [...byName.values()];
+}
+
 export {
   MaxTurnsError,
-  PromptCancelledError,
-  ToolApprovalRequiredError,
-  extractRagText,
-  PromptRequest
+  AgentRunCancelledError,
+  getAgentToolState,
+  createHook,
+  getAgentApprovalRequestDetails,
+  createContextIndex,
+  isContextIndex,
+  withInternalAgentRunOptions,
+  Agent,
+  createResolvedAgent,
+  getResolvedAgentOptions,
+  cancelAgentApproval
 };
-//# sourceMappingURL=chunk-BALBBVI3.js.map
+//# sourceMappingURL=chunk-IL3ZSNJI.js.map