@anvia/core 0.4.0 → 0.4.2

package/dist/{chunk-TP32W7XT.js → chunk-N7NMSGZI.js}

@@ -7,10 +7,10 @@ import {
 import {
   ToolSet,
   toolResultContentToText
-} from "./chunk-I2HOMD3R.js";
+} from "./chunk-35GF7P43.js";
 import {
   createTool
-} from "./chunk-65QV627O.js";
+} from "./chunk-P425B6GR.js";
 import {
   CompletionRequestBuilder,
   Message,
@@ -19,6 +19,9 @@ import {
   assertCompletionRequestSupported,
   textFromAssistantContent
 } from "./chunk-6GJDBBDC.js";
+import {
+  mapWithConcurrency
+} from "./chunk-OIMLU4SF.js";
 
 // src/agent/errors.ts
 var MaxTurnsError = class extends Error {
@@ -87,6 +90,86 @@ var toolCallControl = {
 // src/agent/agent.ts
 import { z } from "zod";
 
+// 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/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 });
+      }
+    }
+  }
+  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 });
+          });
+        }
+      };
+    }
+  };
+}
+
 // src/observability/group.ts
 async function startAgentRunObservers(registrations, args, failOnObserverError) {
   const runObservers = [];
@@ -255,6 +338,158 @@ var ActiveToolObservers = class {
   }
 };
 
+// src/agent/request-memory.ts
+var PromptRequestMemory = 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 prepareRun(runId, newMessages) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryContext === void 0) {
+      return this.initialHistory;
+    }
+    const memoryHistory = await memory.store.load(this.memoryContext);
+    const chatHistory = [...memoryHistory, ...this.initialHistory];
+    if (memory.options.savePolicy === "message") {
+      await memory.store.append({
+        context: this.memoryContext,
+        runId,
+        turn: 1,
+        messages: newMessages
+      });
+    }
+    return chatHistory;
+  }
+  async commitMessages(runId, turn, messages, pendingTurnMessages) {
+    const memory = this.memory();
+    if (memory === void 0 || this.memoryContext === void 0 || messages.length === 0) {
+      return;
+    }
+    if (memory.options.savePolicy === "message") {
+      await memory.store.append({
+        context: this.memoryContext,
+        runId,
+        turn,
+        messages
+      });
+    } 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;
+    }
+    await memory.store.append({
+      context: this.memoryContext,
+      runId,
+      turn,
+      messages: [...pendingTurnMessages]
+    });
+    pendingTurnMessages.length = 0;
+  }
+  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]
+    });
+  }
+  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]
+    });
+  }
+  memory() {
+    return this.memoryContext === void 0 ? void 0 : this.agent.memory;
+  }
+};
+
+// src/agent/retrieval.ts
+async function fetchDynamicContext(agent, ragText) {
+  if (ragText === void 0 || ragText.length === 0 || agent.dynamicContexts.length === 0) {
+    return [];
+  }
+  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);
+        documents.push({
+          id: result.id,
+          text: typeof result.document === "string" ? result.document : JSON.stringify(result.document, null, 2),
+          ...metadata === void 0 ? {} : { additionalProps: metadata }
+        });
+      }
+    }
+  }
+  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;
+  }
+  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)) {
+        continue;
+      }
+      names.add(result.document.toolName);
+      definitions.push(result.document.definition);
+    }
+  }
+  return definitions;
+}
+function formatMetadata(metadata) {
+  if (metadata === void 0) {
+    return void 0;
+  }
+  return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [key, String(value)]));
+}
+
 // src/agent/utils.ts
 function isStreamingCompletionModel(model) {
   return "streamCompletion" in model && typeof model.streamCompletion === "function";
@@ -278,23 +513,6 @@ function parseJsonValue(text) {
     return text;
   }
 }
-async function mapWithConcurrency(items, concurrency, mapper) {
-  const results = [];
-  let next = 0;
-  async function worker() {
-    while (next < items.length) {
-      const index = next;
-      next += 1;
-      const item = items[index];
-      if (item !== void 0) {
-        results[index] = await mapper(item);
-      }
-    }
-  }
-  const workerCount = Math.min(concurrency, items.length);
-  await Promise.all(Array.from({ length: workerCount }, () => worker()));
-  return results;
-}
 
 // src/agent/stream-accumulator.ts
 var CompletionStreamAccumulator = class _CompletionStreamAccumulator {
@@ -524,95 +742,300 @@ function isEmptyToolArguments(value) {
   return false;
 }
 
-// src/agent/request.ts
+// src/agent/tool-execution.ts
 var MCP_TOOL_METADATA_KEY = /* @__PURE__ */ Symbol.for("anvia.mcp.tool.metadata");
-var PromptRequest = class _PromptRequest {
-  constructor(agent, promptMessage, initialHistory = [], memoryContext = void 0) {
+var ToolCallExecutor = class {
+  constructor(agent, activeHook, concurrency, requestToolMiddlewares, cancel) {
     this.agent = agent;
-    this.promptMessage = promptMessage;
-    this.initialHistory = initialHistory;
-    this.memoryContext = memoryContext;
-    this.chatHistory = initialHistory;
-    this.maxTurnCount = agent.defaultMaxTurns ?? 0;
-    this.activeHook = agent.hook;
+    this.activeHook = activeHook;
+    this.concurrency = concurrency;
+    this.requestToolMiddlewares = requestToolMiddlewares;
+    this.cancel = cancel;
   }
   agent;
-  promptMessage;
-  initialHistory;
-  memoryContext;
-  chatHistory;
-  maxTurnCount;
   activeHook;
-  concurrency = 1;
-  traceOptions;
-  requestToolMiddlewares = [];
-  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;
-  }
-  requestHook(hook) {
-    this.activeHook = hook;
-    return this;
-  }
-  withToolConcurrency(concurrency) {
-    this.concurrency = Math.max(1, concurrency);
-    return this;
-  }
-  withToolMiddleware(middleware) {
-    this.requestToolMiddlewares.push(middleware);
-    return this;
-  }
-  withToolMiddlewares(middlewares) {
-    this.requestToolMiddlewares.push(...middlewares);
-    return this;
-  }
-  withTrace(trace) {
-    this.traceOptions = trace;
-    return this;
-  }
-  async send() {
-    const runId = globalThis.crypto.randomUUID();
-    const newMessages = [this.promptMessage];
-    await this.prepareMemoryRun(runId, newMessages);
-    const pendingTurnMessages = this.memoryPolicy() === "turn" ? [...newMessages] : [];
-    let usage = Usage.empty();
-    let currentTurns = 0;
-    let lastPrompt = this.promptMessage;
-    const runObservers = await this.startRunObservers();
-    try {
-      while (currentTurns <= this.maxTurnCount + 1) {
-        const prompt = newMessages.at(-1);
-        if (prompt === void 0) {
-          throw new Error("PromptRequest requires at least one message");
-        }
-        lastPrompt = prompt;
-        currentTurns += 1;
-        const historyForRequest = [...this.chatHistory, ...newMessages.slice(0, -1)];
-        await this.runCompletionCallHook(prompt, historyForRequest, newMessages);
-        const ragText = extractRagText(prompt);
-        const dynamicContext = await this.fetchDynamicContext(ragText);
-        const toolDefs = await this.fetchToolDefinitions(ragText);
-        const request = new CompletionRequestBuilder(this.agent.model, prompt).instructions(this.agent.instructions).messages(historyForRequest).documents([...this.agent.staticContext, ...dynamicContext]).tools(toolDefs).temperature(this.agent.temperature).maxTokens(this.agent.maxTokens).additionalParams(this.agent.additionalParams).toolChoice(this.agent.toolChoice).outputSchema(this.agent.outputSchema).build();
-        const response = await this.runCompletion(request, currentTurns, runObservers);
-        usage = Usage.add(usage, response.usage);
-        await this.runCompletionResponseHook(prompt, response, newMessages);
-        const assistantMessage = Message.assistant(response.choice, response.messageId);
-        newMessages.push(assistantMessage);
-        await this.commitMemoryMessages(
-          runId,
-          currentTurns,
-          [assistantMessage],
-          pendingTurnMessages
-        );
-        const toolCalls = response.choice.filter(
+  concurrency;
+  requestToolMiddlewares;
+  cancel;
+  async execute(toolCalls, onResult, onStreamEvent, observation) {
+    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 toolObservers = await observation?.runObservers.startTool({
+        turn: observation.turn,
+        toolCall,
+        toolName: toolCall.function.name,
+        internalCallId,
+        args,
+        toolCallId: toolCall.callId,
+        ...toolDefinition === void 0 ? {} : { toolDefinition },
+        ...toolMetadata === void 0 ? {} : { toolMetadata }
+      });
+      const callAction = await this.activeHook?.onToolCall?.({
+        ...hookArgs,
+        tool: toolCallControl
+      });
+      if (callAction?.type === "terminate") {
+        await recordToolError(
+          toolObservers,
+          observation?.turn,
+          toolCall,
+          internalCallId,
+          args,
+          callAction.reason
+        );
+        throw this.cancel(callAction.reason);
+      }
+      if (callAction?.type === "approval_request") {
+        const reason = `Tool approval was requested for ${toolCall.function.name}, but no approval handler is installed.`;
+        await recordToolError(
+          toolObservers,
+          observation?.turn,
+          toolCall,
+          internalCallId,
+          args,
+          reason
+        );
+        throw this.cancel(reason);
+      }
+      let output;
+      let skipped = false;
+      if (callAction?.type === "skip") {
+        output = callAction.reason;
+        skipped = true;
+      } else {
+        try {
+          output = await this.agent.callTool(toolCall.function.name, args, {
+            emitStreamEvent: async (event) => {
+              await toolObservers?.streamEvent({
+                turn: observation?.turn ?? 0,
+                toolCall,
+                toolName: toolCall.function.name,
+                internalCallId,
+                args,
+                ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId },
+                event
+              });
+              const payload = agentToolEventPayload(toolCall, internalCallId, event);
+              if (payload !== void 0) {
+                onStreamEvent?.(payload);
+              }
+            }
+          });
+        } catch (error) {
+          output = error instanceof Error ? error.toString() : String(error);
+        }
+      }
+      let result = toolOutputToText(output);
+      let structuredResult = toolOutputToStructuredResult(output);
+      if (this.agent.shouldApplyToolMiddleware(toolCall.function.name)) {
+        const middlewareReplacement = await this.runToolResultMiddlewares({
+          ...hookArgs,
+          result,
+          originalResult: result,
+          structuredResult,
+          originalStructuredResult: structuredResult,
+          turn: observation?.turn ?? 0
+        });
+        if (middlewareReplacement !== void 0) {
+          output = middlewareReplacement;
+          result = middlewareReplacement;
+          structuredResult = void 0;
+        }
+      }
+      const resultAction = await this.activeHook?.onToolResult?.({
+        ...hookArgs,
+        result,
+        structuredResult,
+        run: runControl
+      });
+      await toolObservers?.end({
+        turn: observation?.turn ?? 0,
+        toolCall,
+        toolName: toolCall.function.name,
+        internalCallId,
+        args,
+        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,
+        result,
+        structuredResult
+      };
+      if (toolCall.callId !== void 0) {
+        resultPayload.toolCallId = toolCall.callId;
+      }
+      onResult?.(resultPayload);
+      return ToolContent.toolResult(toolCall.id, output, toolCall.callId);
+    });
+  }
+  async runToolResultMiddlewares(args) {
+    let result = args.result;
+    let replaced = false;
+    for (const middleware of [...this.agent.toolMiddlewares, ...this.requestToolMiddlewares]) {
+      const replacement = await middleware.onResult?.({
+        ...args,
+        result
+      });
+      if (replacement !== void 0) {
+        result = replacement;
+        replaced = true;
+      }
+    }
+    return replaced ? result : void 0;
+  }
+};
+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;
+  return {
+    approvalRequired: tool.approval !== void 0,
+    ...typeof mcpMetadata?.serverName === "string" && mcpMetadata.serverName.length > 0 ? { mcpServerName: mcpMetadata.serverName } : {}
+  };
+}
+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 toolOutputToText(output) {
+  return typeof output === "string" ? output : toolResultContentToText(output);
+}
+function toolOutputToStructuredResult(output) {
+  return typeof output === "string" ? void 0 : output;
+}
+function agentToolEventPayload(toolCall, internalCallId, event) {
+  if (typeof event.agentId !== "string" || event.agentId.length === 0) {
+    return void 0;
+  }
+  return {
+    type: "agent_tool_event",
+    toolName: toolCall.function.name,
+    ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId },
+    internalCallId,
+    agentId: event.agentId,
+    ...event.agentName === void 0 ? {} : { agentName: event.agentName },
+    event: event.event
+  };
+}
+
+// src/agent/request.ts
+var PromptRequest = class _PromptRequest {
+  constructor(agent, promptMessage, initialHistory = [], memoryContext = void 0) {
+    this.agent = agent;
+    this.promptMessage = promptMessage;
+    this.chatHistory = initialHistory;
+    this.maxTurnCount = agent.defaultMaxTurns ?? 0;
+    this.activeHook = agent.hook;
+    this.memoryRecorder = new PromptRequestMemory(agent, memoryContext, initialHistory);
+  }
+  agent;
+  promptMessage;
+  chatHistory;
+  maxTurnCount;
+  activeHook;
+  concurrency = 1;
+  traceOptions;
+  requestToolMiddlewares = [];
+  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;
+  }
+  requestHook(hook) {
+    this.activeHook = hook;
+    return this;
+  }
+  withToolConcurrency(concurrency) {
+    this.concurrency = Math.max(1, concurrency);
+    return this;
+  }
+  withToolMiddleware(middleware) {
+    this.requestToolMiddlewares.push(middleware);
+    return this;
+  }
+  withToolMiddlewares(middlewares) {
+    this.requestToolMiddlewares.push(...middlewares);
+    return this;
+  }
+  withTrace(trace) {
+    this.traceOptions = trace;
+    return this;
+  }
+  async send() {
+    const runId = globalThis.crypto.randomUUID();
+    const newMessages = [this.promptMessage];
+    this.chatHistory = await this.memoryRecorder.prepareRun(runId, newMessages);
+    const pendingTurnMessages = this.memoryRecorder.pendingTurnMessages(newMessages);
+    let usage = Usage.empty();
+    let currentTurns = 0;
+    let lastPrompt = this.promptMessage;
+    const runObservers = await this.startRunObservers();
+    try {
+      while (currentTurns <= this.maxTurnCount + 1) {
+        const prompt = newMessages.at(-1);
+        if (prompt === void 0) {
+          throw new Error("PromptRequest requires at least one message");
+        }
+        lastPrompt = prompt;
+        currentTurns += 1;
+        const historyForRequest = [...this.chatHistory, ...newMessages.slice(0, -1)];
+        await this.runCompletionCallHook(prompt, historyForRequest, newMessages);
+        const ragText = extractRagText(prompt);
+        const dynamicContext = await fetchDynamicContext(this.agent, ragText);
+        const toolDefs = await fetchToolDefinitions(this.agent, ragText);
+        const request = new CompletionRequestBuilder(this.agent.model, prompt).instructions(this.agent.instructions).messages(historyForRequest).documents([...this.agent.staticContext, ...dynamicContext]).tools(toolDefs).temperature(this.agent.temperature).maxTokens(this.agent.maxTokens).additionalParams(this.agent.additionalParams).toolChoice(this.agent.toolChoice).outputSchema(this.agent.outputSchema).build();
+        const response = await this.runCompletion(request, currentTurns, runObservers);
+        usage = Usage.add(usage, response.usage);
+        await this.runCompletionResponseHook(prompt, response, newMessages);
+        const assistantMessage = Message.assistant(response.choice, response.messageId);
+        newMessages.push(assistantMessage);
+        await this.memoryRecorder.commitMessages(
+          runId,
+          currentTurns,
+          [assistantMessage],
+          pendingTurnMessages
+        );
+        const toolCalls = response.choice.filter(
           (item) => item.type === "tool_call"
         );
         if (toolCalls.length === 0) {
-          await this.commitCompletedMemoryRun(
+          await this.memoryRecorder.commitCompletedRun(
             runId,
             currentTurns,
             newMessages,
@@ -640,13 +1063,18 @@ var PromptRequest = class _PromptRequest {
         );
         const toolMessage = Message.tool(toolResults);
         newMessages.push(toolMessage);
-        await this.commitMemoryMessages(runId, currentTurns, [toolMessage], pendingTurnMessages);
-        await this.commitCompletedMemoryTurn(runId, currentTurns, pendingTurnMessages);
+        await this.memoryRecorder.commitMessages(
+          runId,
+          currentTurns,
+          [toolMessage],
+          pendingTurnMessages
+        );
+        await this.memoryRecorder.commitCompletedTurn(runId, currentTurns, pendingTurnMessages);
       }
       throw new MaxTurnsError(this.maxTurnCount, [...this.chatHistory, ...newMessages], lastPrompt);
     } catch (error) {
       await runObservers.error({ error, usage, messages: [...newMessages] });
-      await this.recordMemoryError(runId, error, newMessages);
+      await this.memoryRecorder.recordError(runId, error, newMessages);
       throw error;
     }
   }
@@ -656,8 +1084,8 @@ var PromptRequest = class _PromptRequest {
     }
     const runId = globalThis.crypto.randomUUID();
     const newMessages = [this.promptMessage];
-    await this.prepareMemoryRun(runId, newMessages);
-    const pendingTurnMessages = this.memoryPolicy() === "turn" ? [...newMessages] : [];
+    this.chatHistory = await this.memoryRecorder.prepareRun(runId, newMessages);
+    const pendingTurnMessages = this.memoryRecorder.pendingTurnMessages(newMessages);
     let usage = Usage.empty();
     let currentTurns = 0;
     let lastPrompt = this.promptMessage;
@@ -683,8 +1111,8 @@ var PromptRequest = class _PromptRequest {
         });
         await this.runCompletionCallHook(prompt, historyForRequest, newMessages);
         const ragText = extractRagText(prompt);
-        const dynamicContext = await this.fetchDynamicContext(ragText);
-        const toolDefs = await this.fetchToolDefinitions(ragText);
+        const dynamicContext = await fetchDynamicContext(this.agent, ragText);
+        const toolDefs = await fetchToolDefinitions(this.agent, ragText);
         const request = new CompletionRequestBuilder(this.agent.model, prompt).instructions(this.agent.instructions).messages(historyForRequest).documents([...this.agent.staticContext, ...dynamicContext]).tools(toolDefs).temperature(this.agent.temperature).maxTokens(this.agent.maxTokens).additionalParams(this.agent.additionalParams).toolChoice(this.agent.toolChoice).outputSchema(this.agent.outputSchema).build();
         assertCompletionRequestSupported(this.agent.model, request, { streaming: true });
         const providerRequest = this.providerTraceRequest(request, { stream: true });
@@ -728,7 +1156,7 @@ var PromptRequest = class _PromptRequest {
         await this.runCompletionResponseHook(prompt, response, newMessages);
         const assistantMessage = Message.assistant(response.choice, response.messageId);
         newMessages.push(assistantMessage);
-        await this.commitMemoryMessages(
+        await this.memoryRecorder.commitMessages(
           runId,
           currentTurns,
           [assistantMessage],
@@ -743,7 +1171,7 @@ var PromptRequest = class _PromptRequest {
         yield await emit({ type: "turn_end", turn: currentTurns, response });
         if (toolCalls.length === 0) {
           const output = textFromAssistantContent(response.choice);
-          await this.commitCompletedMemoryRun(
+          await this.memoryRecorder.commitCompletedRun(
             runId,
             currentTurns,
             newMessages,
@@ -782,214 +1210,69 @@ var PromptRequest = class _PromptRequest {
         );
         for await (const result of toolResultEvents) {
           yield await emit({ turn: currentTurns, ...result });
-        }
-        const toolResults = await toolResultsPromise;
-        const toolMessage = Message.tool(toolResults);
-        newMessages.push(toolMessage);
-        await this.commitMemoryMessages(runId, currentTurns, [toolMessage], pendingTurnMessages);
-        await this.commitCompletedMemoryTurn(runId, currentTurns, pendingTurnMessages);
-      }
-      throw new MaxTurnsError(this.maxTurnCount, [...this.chatHistory, ...newMessages], lastPrompt);
-    } catch (error) {
-      await runObservers.error({ error, usage, messages: [...newMessages] });
-      await this.recordMemoryError(runId, error, newMessages);
-      yield await emit({ type: "error", error });
-      throw error;
-    }
-  }
-  readableStream() {
-    return toReadableStream(this.stream());
-  }
-  async runCompletion(request, turn, runObservers) {
-    assertCompletionRequestSupported(this.agent.model, request);
-    const providerRequest = this.providerTraceRequest(request);
-    const generationObservers = await runObservers.startGeneration({
-      turn,
-      request,
-      ...providerRequest === void 0 ? {} : { providerRequest },
-      modelInfo: {
-        provider: this.agent.model.provider,
-        defaultModel: this.agent.model.defaultModel,
-        capabilities: this.agent.model.capabilities
-      }
-    });
-    try {
-      const response = await this.agent.model.completion(request);
-      await generationObservers.end({ turn, response });
-      return response;
-    } catch (error) {
-      await generationObservers.error({ turn, error });
-      throw error;
-    }
-  }
-  providerTraceRequest(request, options = {}) {
-    try {
-      return this.agent.model.traceRequest?.(request, options);
-    } catch (error) {
-      return {
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  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;
-    return {
-      approvalRequired: tool.approval !== void 0,
-      ...typeof mcpMetadata?.serverName === "string" && mcpMetadata.serverName.length > 0 ? { mcpServerName: mcpMetadata.serverName } : {}
-    };
-  }
-  async executeToolCalls(toolCalls, newMessages, onResult, onStreamEvent, observation) {
-    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 = this.toolTraceMetadata(tool);
-      const toolObservers = await observation?.runObservers.startTool({
-        turn: observation.turn,
-        toolCall,
-        toolName: toolCall.function.name,
-        internalCallId,
-        args,
-        toolCallId: toolCall.callId,
-        ...toolDefinition === void 0 ? {} : { toolDefinition },
-        ...toolMetadata === void 0 ? {} : { toolMetadata }
-      });
-      const callAction = await this.activeHook?.onToolCall?.({
-        ...hookArgs,
-        tool: toolCallControl
-      });
-      if (callAction?.type === "terminate") {
-        await this.recordToolError(
-          toolObservers,
-          observation?.turn,
-          toolCall,
-          internalCallId,
-          args,
-          callAction.reason
-        );
-        throw this.cancelled(newMessages, callAction.reason);
-      }
-      if (callAction?.type === "approval_request") {
-        const reason = `Tool approval was requested for ${toolCall.function.name}, but no approval handler is installed.`;
-        await this.recordToolError(
-          toolObservers,
-          observation?.turn,
-          toolCall,
-          internalCallId,
-          args,
-          reason
-        );
-        throw this.cancelled(newMessages, reason);
-      }
-      let output;
-      let skipped = false;
-      if (callAction?.type === "skip") {
-        output = callAction.reason;
-        skipped = true;
-      } else {
-        try {
-          output = await this.agent.callTool(toolCall.function.name, args, {
-            emitStreamEvent: async (event) => {
-              await toolObservers?.streamEvent({
-                turn: observation?.turn ?? 0,
-                toolCall,
-                toolName: toolCall.function.name,
-                internalCallId,
-                args,
-                ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId },
-                event
-              });
-              const payload = agentToolEventPayload(toolCall, internalCallId, event);
-              if (payload !== void 0) {
-                onStreamEvent?.(payload);
-              }
-            }
-          });
-        } catch (error) {
-          output = error instanceof Error ? error.toString() : String(error);
-        }
-      }
-      let result = toolOutputToText(output);
-      let structuredResult = toolOutputToStructuredResult(output);
-      if (this.agent.shouldApplyToolMiddleware(toolCall.function.name)) {
-        const middlewareReplacement = await this.runToolResultMiddlewares({
-          ...hookArgs,
-          result,
-          originalResult: result,
-          structuredResult,
-          originalStructuredResult: structuredResult,
-          turn: observation?.turn ?? 0
-        });
-        if (middlewareReplacement !== void 0) {
-          output = middlewareReplacement;
-          result = middlewareReplacement;
-          structuredResult = void 0;
-        }
-      }
-      const resultAction = await this.activeHook?.onToolResult?.({
-        ...hookArgs,
-        result,
-        structuredResult,
-        run: runControl
-      });
-      await toolObservers?.end({
-        turn: observation?.turn ?? 0,
-        toolCall,
-        toolName: toolCall.function.name,
-        internalCallId,
-        args,
-        result,
-        structuredResult,
-        skipped,
-        toolCallId: toolCall.callId
-      });
-      if (resultAction?.type === "terminate") {
-        throw this.cancelled(newMessages, resultAction.reason);
+        }
+        const toolResults = await toolResultsPromise;
+        const toolMessage = Message.tool(toolResults);
+        newMessages.push(toolMessage);
+        await this.memoryRecorder.commitMessages(
+          runId,
+          currentTurns,
+          [toolMessage],
+          pendingTurnMessages
+        );
+        await this.memoryRecorder.commitCompletedTurn(runId, currentTurns, pendingTurnMessages);
       }
-      const resultPayload = {
-        type: "tool_result",
-        toolName: toolCall.function.name,
-        internalCallId,
-        args,
-        result,
-        structuredResult
-      };
-      if (toolCall.callId !== void 0) {
-        resultPayload.toolCallId = toolCall.callId;
+      throw new MaxTurnsError(this.maxTurnCount, [...this.chatHistory, ...newMessages], lastPrompt);
+    } catch (error) {
+      await runObservers.error({ error, usage, messages: [...newMessages] });
+      await this.memoryRecorder.recordError(runId, error, newMessages);
+      yield await emit({ type: "error", error });
+      throw error;
+    }
+  }
+  readableStream() {
+    return toReadableStream(this.stream());
+  }
+  async runCompletion(request, turn, runObservers) {
+    assertCompletionRequestSupported(this.agent.model, request);
+    const providerRequest = this.providerTraceRequest(request);
+    const generationObservers = await runObservers.startGeneration({
+      turn,
+      request,
+      ...providerRequest === void 0 ? {} : { providerRequest },
+      modelInfo: {
+        provider: this.agent.model.provider,
+        defaultModel: this.agent.model.defaultModel,
+        capabilities: this.agent.model.capabilities
       }
-      onResult?.(resultPayload);
-      return ToolContent.toolResult(toolCall.id, output, toolCall.callId);
     });
+    try {
+      const response = await this.agent.model.completion(request);
+      await generationObservers.end({ turn, response });
+      return response;
+    } catch (error) {
+      await generationObservers.error({ turn, error });
+      throw error;
+    }
   }
-  async runToolResultMiddlewares(args) {
-    let result = args.result;
-    let replaced = false;
-    for (const middleware of [...this.agent.toolMiddlewares, ...this.requestToolMiddlewares]) {
-      const replacement = await middleware.onResult?.({
-        ...args,
-        result
-      });
-      if (replacement !== void 0) {
-        result = replacement;
-        replaced = true;
-      }
+  providerTraceRequest(request, options = {}) {
+    try {
+      return this.agent.model.traceRequest?.(request, options);
+    } catch (error) {
+      return {
+        error: error instanceof Error ? error.message : String(error)
+      };
     }
-    return replaced ? result : void 0;
+  }
+  async executeToolCalls(toolCalls, newMessages, onResult, onStreamEvent, observation) {
+    const executor = new ToolCallExecutor(
+      this.agent,
+      this.activeHook,
+      this.concurrency,
+      this.requestToolMiddlewares,
+      (reason) => this.cancelled(newMessages, reason)
+    );
+    return executor.execute(toolCalls, onResult, onStreamEvent, observation);
   }
   async startRunObservers() {
     const failOnObserverError = this.traceOptions?.failOnObserverError === true || this.agent.observers.some((registration) => registration.failOnObserverError === true);
@@ -1031,69 +1314,6 @@ var PromptRequest = class _PromptRequest {
       event
     });
   }
-  async fetchDynamicContext(ragText) {
-    if (ragText === void 0 || ragText.length === 0 || this.agent.dynamicContexts.length === 0) {
-      return [];
-    }
-    const documents = [];
-    for (const registration of this.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);
-          documents.push({
-            id: result.id,
-            text: typeof result.document === "string" ? result.document : JSON.stringify(result.document, null, 2),
-            ...metadata === void 0 ? {} : { additionalProps: metadata }
-          });
-        }
-      }
-    }
-    return documents;
-  }
-  async fetchToolDefinitions(ragText) {
-    const staticDefinitions = await this.agent.toolSet.getToolDefinitions(ragText);
-    if (ragText === void 0 || ragText.length === 0 || this.agent.dynamicTools.length === 0) {
-      return staticDefinitions;
-    }
-    const definitions = [...staticDefinitions];
-    const names = new Set(staticDefinitions.map((definition) => definition.name));
-    for (const registration of this.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)) {
-          continue;
-        }
-        names.add(result.document.toolName);
-        definitions.push(result.document.definition);
-      }
-    }
-    return definitions;
-  }
-  async recordToolError(toolObservers, turn, toolCall, internalCallId, args, error) {
-    await toolObservers?.error({
-      turn: turn ?? 0,
-      toolCall,
-      toolName: toolCall.function.name,
-      internalCallId,
-      args,
-      error,
-      toolCallId: toolCall.callId
-    });
-  }
   async runCompletionCallHook(prompt, history, newMessages) {
     const action = await this.activeHook?.onCompletionCall?.({
       prompt,
@@ -1117,83 +1337,6 @@ var PromptRequest = class _PromptRequest {
   cancelled(newMessages, reason) {
     return new PromptCancelledError([...this.chatHistory, ...newMessages], reason);
   }
-  memory() {
-    return this.memoryContext === void 0 ? void 0 : this.agent.memory;
-  }
-  memoryPolicy() {
-    return this.memory()?.options.savePolicy;
-  }
-  async prepareMemoryRun(runId, newMessages) {
-    const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0) {
-      this.chatHistory = this.initialHistory;
-      return;
-    }
-    const memoryHistory = await memory.store.load(this.memoryContext);
-    this.chatHistory = [...memoryHistory, ...this.initialHistory];
-    if (memory.options.savePolicy === "message") {
-      await memory.store.append({
-        context: this.memoryContext,
-        runId,
-        turn: 1,
-        messages: newMessages
-      });
-    }
-  }
-  async commitMemoryMessages(runId, turn, messages, pendingTurnMessages) {
-    const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0 || messages.length === 0) {
-      return;
-    }
-    if (memory.options.savePolicy === "message") {
-      await memory.store.append({
-        context: this.memoryContext,
-        runId,
-        turn,
-        messages
-      });
-    } else if (memory.options.savePolicy === "turn") {
-      pendingTurnMessages.push(...messages);
-    }
-  }
-  async commitCompletedMemoryTurn(runId, turn, pendingTurnMessages) {
-    const memory = this.memory();
-    if (memory === void 0 || this.memoryContext === void 0 || memory.options.savePolicy !== "turn" || pendingTurnMessages.length === 0) {
-      return;
-    }
-    await memory.store.append({
-      context: this.memoryContext,
-      runId,
-      turn,
-      messages: [...pendingTurnMessages]
-    });
-    pendingTurnMessages.length = 0;
-  }
-  async commitCompletedMemoryRun(runId, turn, newMessages, pendingTurnMessages) {
-    await this.commitCompletedMemoryTurn(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]
-    });
-  }
-  async recordMemoryError(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]
-    });
-  }
 };
 function normalizePromptInput(prompt) {
   if (typeof prompt === "string") {
@@ -1214,92 +1357,6 @@ function normalizePromptInput(prompt) {
     history: prompt.slice(0, -1)
   };
 }
-function toolOutputToText(output) {
-  return typeof output === "string" ? output : toolResultContentToText(output);
-}
-function toolOutputToStructuredResult(output) {
-  return typeof output === "string" ? void 0 : output;
-}
-function agentToolEventPayload(toolCall, internalCallId, event) {
-  if (typeof event.agentId !== "string" || event.agentId.length === 0) {
-    return void 0;
-  }
-  return {
-    type: "agent_tool_event",
-    toolName: toolCall.function.name,
-    ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId },
-    internalCallId,
-    agentId: event.agentId,
-    ...event.agentName === void 0 ? {} : { agentName: event.agentName },
-    event: event.event
-  };
-}
-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 });
-      }
-    }
-  }
-  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 });
-          });
-        }
-      };
-    }
-  };
-}
 function addTurn(turn, event) {
   if (event.type === "text_delta") {
     return { type: "text_delta", turn, delta: event.delta };
@@ -1316,12 +1373,6 @@ function addTurn(turn, event) {
 function isGenerationDeltaEvent(type) {
   return type === "text_delta" || type === "reasoning_delta" || type === "tool_call_delta" || type === "tool_call";
 }
-function formatMetadata(metadata) {
-  if (metadata === void 0) {
-    return void 0;
-  }
-  return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [key, String(value)]));
-}
 
 // src/agent/agent.ts
 var DEFAULT_MAX_TURNS = 20;
@@ -1477,18 +1528,9 @@ function dynamicToolSetFromIndex(index) {
   const maybeIndex = index;
   return maybeIndex.toolSet instanceof ToolSet ? maybeIndex.toolSet : void 0;
 }
-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;
-}
 
 export {
+  normalizeAgentId,
   MaxTurnsError,
   PromptCancelledError,
   createHook,
@@ -1501,4 +1543,4 @@ export {
   Agent,
   AgentSession
 };
-//# sourceMappingURL=chunk-TP32W7XT.js.map
+//# sourceMappingURL=chunk-N7NMSGZI.js.map