@anvia/core 0.3.1 → 0.4.1

package/dist/{chunk-GSFQZYS7.js → chunk-TVIADATY.js}

@@ -1,20 +1,16 @@
 import {
-  resolveMemoryOptions
-} from "./chunk-XXT2UCAR.js";
+  toReadableStream
+} from "./chunk-XUUY2L2D.js";
 import {
   isSkillTool
 } from "./chunk-YK4WAAS4.js";
 import {
   ToolSet,
   toolResultContentToText
-} from "./chunk-I2HOMD3R.js";
+} from "./chunk-CY7SB5FG.js";
 import {
-  createTool,
-  toProviderJsonSchema
-} from "./chunk-65QV627O.js";
-import {
-  toReadableStream
-} from "./chunk-XUUY2L2D.js";
+  createTool
+} from "./chunk-OIA4CN5V.js";
 import {
   CompletionRequestBuilder,
   Message,
@@ -23,10 +19,157 @@ import {
   assertCompletionRequestSupported,
   textFromAssistantContent
 } from "./chunk-6GJDBBDC.js";
+import {
+  mapWithConcurrency
+} from "./chunk-OIMLU4SF.js";
+
+// src/agent/errors.ts
+var MaxTurnsError = class extends Error {
+  constructor(maxTurns, chatHistory, prompt) {
+    super(`Reached max turn limit: ${maxTurns}`);
+    this.maxTurns = maxTurns;
+    this.chatHistory = chatHistory;
+    this.prompt = prompt;
+    this.name = "MaxTurnsError";
+  }
+  maxTurns;
+  chatHistory;
+  prompt;
+};
+var PromptCancelledError = class extends Error {
+  constructor(chatHistory, reason) {
+    super(`Prompt cancelled: ${reason}`);
+    this.chatHistory = chatHistory;
+    this.reason = reason;
+    this.name = "PromptCancelledError";
+  }
+  chatHistory;
+  reason;
+};
+
+// src/agent/hooks.ts
+function createHook(hook) {
+  return hook;
+}
+function cancelPrompt(reason) {
+  return { type: "terminate", reason };
+}
+function skipTool(reason) {
+  return { type: "skip", reason };
+}
+function requestToolApproval(options = {}) {
+  return {
+    type: "approval_request",
+    ...options.reason === void 0 ? {} : { reason: options.reason },
+    ...options.rejectMessage === void 0 ? {} : { rejectMessage: options.rejectMessage }
+  };
+}
+var runControl = {
+  continue() {
+    return { type: "continue" };
+  },
+  cancel(reason) {
+    return cancelPrompt(reason);
+  }
+};
+var toolCallControl = {
+  run() {
+    return { type: "continue" };
+  },
+  skip(reason) {
+    return skipTool(reason);
+  },
+  cancel(reason) {
+    return { type: "terminate", reason };
+  },
+  requestApproval(options) {
+    return requestToolApproval(options);
+  }
+};
 
 // 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 = [];
@@ -195,69 +338,157 @@ var ActiveToolObservers = class {
   }
 };
 
-// src/agent/errors.ts
-var MaxTurnsError = class extends Error {
-  constructor(maxTurns, chatHistory, prompt) {
-    super(`Reached max turn limit: ${maxTurns}`);
-    this.maxTurns = maxTurns;
-    this.chatHistory = chatHistory;
-    this.prompt = prompt;
-    this.name = "MaxTurnsError";
+// src/agent/request-memory.ts
+var PromptRequestMemory = class {
+  constructor(agent, memoryContext, initialHistory) {
+    this.agent = agent;
+    this.memoryContext = memoryContext;
+    this.initialHistory = initialHistory;
   }
-  maxTurns;
-  chatHistory;
-  prompt;
-};
-var PromptCancelledError = class extends Error {
-  constructor(chatHistory, reason) {
-    super(`Prompt cancelled: ${reason}`);
-    this.chatHistory = chatHistory;
-    this.reason = reason;
-    this.name = "PromptCancelledError";
+  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;
   }
-  chatHistory;
-  reason;
 };
 
-// src/agent/hooks.ts
-function createHook(hook) {
-  return hook;
-}
-function cancelPrompt(reason) {
-  return { type: "terminate", reason };
-}
-function skipTool(reason) {
-  return { type: "skip", reason };
-}
-function requestToolApproval(options = {}) {
-  return {
-    type: "approval_request",
-    ...options.reason === void 0 ? {} : { reason: options.reason },
-    ...options.rejectMessage === void 0 ? {} : { rejectMessage: options.rejectMessage }
-  };
+// 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;
 }
-var runControl = {
-  continue() {
-    return { type: "continue" };
-  },
-  cancel(reason) {
-    return cancelPrompt(reason);
+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);
+    }
   }
-};
-var toolCallControl = {
-  run() {
-    return { type: "continue" };
-  },
-  skip(reason) {
-    return skipTool(reason);
-  },
-  cancel(reason) {
-    return { type: "terminate", reason };
-  },
-  requestApproval(options) {
-    return requestToolApproval(options);
+  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) {
@@ -282,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 {
@@ -488,68 +702,273 @@ var CompletionStreamAccumulator = class _CompletionStreamAccumulator {
           event.signature === void 0 ? { type: "text", text: event.delta } : { type: "text", text: event.delta, signature: event.signature }
         );
       }
-      return;
-    }
-    if (contentType === "summary") {
-      if (last?.type === "summary") {
-        last.text += event.delta;
-      } else {
-        reasoning.content.push({ type: "summary", text: event.delta });
+      return;
+    }
+    if (contentType === "summary") {
+      if (last?.type === "summary") {
+        last.text += event.delta;
+      } else {
+        reasoning.content.push({ type: "summary", text: event.delta });
+      }
+      return;
+    }
+    if (contentType === "encrypted") {
+      reasoning.content.push({ type: "encrypted", data: event.delta });
+      return;
+    }
+    reasoning.content.push({ type: "redacted", data: event.delta });
+  }
+};
+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;
+}
+
+// src/agent/tool-execution.ts
+var MCP_TOOL_METADATA_KEY = /* @__PURE__ */ Symbol.for("anvia.mcp.tool.metadata");
+var ToolCallExecutor = class {
+  constructor(agent, activeHook, concurrency, requestToolMiddlewares, cancel) {
+    this.agent = agent;
+    this.activeHook = activeHook;
+    this.concurrency = concurrency;
+    this.requestToolMiddlewares = requestToolMiddlewares;
+    this.cancel = cancel;
+  }
+  agent;
+  activeHook;
+  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;
-    }
-    if (contentType === "encrypted") {
-      reasoning.content.push({ type: "encrypted", data: event.delta });
-      return;
     }
-    reasoning.content.push({ type: "redacted", data: event.delta });
+    return replaced ? result : void 0;
   }
 };
-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;
+function toolTraceMetadata(tool) {
+  if (tool === void 0) {
+    return void 0;
   }
-  if (typeof value === "object") {
-    return Object.values(value).every((item) => item === 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 false;
+  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 MCP_TOOL_METADATA_KEY = /* @__PURE__ */ Symbol.for("anvia.mcp.tool.metadata");
 var PromptRequest = class _PromptRequest {
   constructor(agent, promptMessage, initialHistory = [], memoryContext = void 0) {
     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.memoryRecorder = new PromptRequestMemory(agent, memoryContext, initialHistory);
   }
   agent;
   promptMessage;
-  initialHistory;
-  memoryContext;
   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);
@@ -581,8 +1000,8 @@ var PromptRequest = class _PromptRequest {
   async send() {
     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;
@@ -598,15 +1017,15 @@ var PromptRequest = class _PromptRequest {
         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 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.commitMemoryMessages(
+        await this.memoryRecorder.commitMessages(
           runId,
           currentTurns,
           [assistantMessage],
@@ -616,7 +1035,7 @@ var PromptRequest = class _PromptRequest {
           (item) => item.type === "tool_call"
         );
         if (toolCalls.length === 0) {
-          await this.commitCompletedMemoryRun(
+          await this.memoryRecorder.commitCompletedRun(
             runId,
             currentTurns,
             newMessages,
@@ -644,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;
     }
   }
@@ -660,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;
@@ -687,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 });
@@ -732,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],
@@ -747,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,
@@ -790,13 +1214,18 @@ var PromptRequest = class _PromptRequest {
         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);
+        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);
       yield await emit({ type: "error", error });
       throw error;
     }
@@ -834,166 +1263,16 @@ var PromptRequest = class _PromptRequest {
         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 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;
+  }
+  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);
@@ -1035,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,
@@ -1121,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") {
@@ -1218,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 };
@@ -1320,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;
@@ -1481,198 +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;
-}
-
-// src/agent/builder.ts
-var AgentBuilder = class {
-  constructor(agentId, completionModel) {
-    this.completionModel = completionModel;
-    this.agentId = normalizeAgentId2(agentId);
-  }
-  completionModel;
-  agentId;
-  agentName;
-  agentDescription;
-  instructionBlocks = [];
-  contextDocs = [];
-  temp;
-  maxTokenCount;
-  params;
-  choice;
-  turns;
-  requestHook;
-  schema;
-  skillInstructionBlocks = [];
-  observerRegistrations = [];
-  dynamicContextRegistrations = [];
-  dynamicToolRegistrations = [];
-  middlewareRegistrations = [];
-  memoryRegistration;
-  eventStoreRegistration;
-  activeToolSet = new ToolSet();
-  name(name) {
-    this.agentName = name;
-    return this;
-  }
-  description(description) {
-    this.agentDescription = description;
-    return this;
-  }
-  instructions(instructions) {
-    if (instructions.length > 0) {
-      this.instructionBlocks.push(instructions);
-    }
-    return this;
-  }
-  context(text, id = `static_doc_${this.contextDocs.length}`) {
-    this.contextDocs.push({ id, text });
-    return this;
-  }
-  dynamicContext(index, options) {
-    this.dynamicContextRegistrations.push({ index, options });
-    return this;
-  }
-  dynamicTools(index, options) {
-    this.dynamicToolRegistrations.push({ index, options });
-    return this;
-  }
-  tool(tool) {
-    this.activeToolSet.addTool(tool);
-    return this;
-  }
-  tools(tools) {
-    this.activeToolSet.addTools(tools);
-    return this;
-  }
-  mcp(servers) {
-    for (const server of servers) {
-      this.activeToolSet.addTools(server.tools);
-    }
-    return this;
-  }
-  skills(skillSet) {
-    if (skillSet.instructions.length > 0) {
-      this.skillInstructionBlocks.push(skillSet.instructions);
-    }
-    this.activeToolSet.addTools(skillSet.tools);
-    return this;
-  }
-  useToolSet(toolSet) {
-    toolSet.addTools(this.activeToolSet);
-    this.activeToolSet = toolSet;
-    return this;
-  }
-  temperature(temperature) {
-    this.temp = temperature;
-    return this;
-  }
-  maxTokens(maxTokens) {
-    this.maxTokenCount = maxTokens;
-    return this;
-  }
-  additionalParams(params) {
-    this.params = params;
-    return this;
-  }
-  toolChoice(toolChoice) {
-    this.choice = toolChoice;
-    return this;
-  }
-  defaultMaxTurns(defaultMaxTurns) {
-    this.turns = defaultMaxTurns;
-    return this;
-  }
-  hook(hook) {
-    this.requestHook = hook;
-    return this;
-  }
-  toolMiddleware(middleware) {
-    this.middlewareRegistrations.push(middleware);
-    return this;
-  }
-  toolMiddlewares(middlewares) {
-    this.middlewareRegistrations.push(...middlewares);
-    return this;
-  }
-  observe(observer, options = {}) {
-    this.observerRegistrations.push({
-      observer,
-      failOnObserverError: options.failOnObserverError
-    });
-    return this;
-  }
-  memory(store, options = {}) {
-    this.memoryRegistration = {
-      store,
-      options: resolveMemoryOptions(options)
-    };
-    return this;
-  }
-  eventStore(store, options = {}) {
-    this.eventStoreRegistration = {
-      store,
-      options: {
-        include: options.include ?? "all"
-      }
-    };
-    return this;
-  }
-  outputSchema(schema) {
-    this.schema = toProviderJsonSchema(schema);
-    return this;
-  }
-  build() {
-    return new Agent({
-      id: this.agentId,
-      name: this.agentName,
-      description: this.agentDescription,
-      model: this.completionModel,
-      instructions: this.buildInstructions(),
-      staticContext: this.contextDocs,
-      temperature: this.temp,
-      maxTokens: this.maxTokenCount,
-      additionalParams: this.params,
-      toolSet: this.activeToolSet,
-      toolChoice: this.choice,
-      defaultMaxTurns: this.turns,
-      hook: this.requestHook,
-      outputSchema: this.schema,
-      observers: this.observerRegistrations,
-      dynamicContexts: this.dynamicContextRegistrations,
-      dynamicTools: this.dynamicToolRegistrations,
-      toolMiddlewares: this.middlewareRegistrations,
-      memory: this.memoryRegistration,
-      eventStore: this.eventStoreRegistration
-    });
-  }
-  buildInstructions() {
-    const parts = [...this.instructionBlocks, ...this.skillInstructionBlocks].filter(
-      (part) => part !== void 0 && part.length > 0
-    );
-    return parts.length === 0 ? void 0 : parts.join("\n\n");
-  }
-};
-function normalizeAgentId2(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,
@@ -1681,10 +1539,8 @@ export {
   requestToolApproval,
   runControl,
   toolCallControl,
-  PromptRequest,
   DEFAULT_MAX_TURNS,
   Agent,
-  AgentSession,
-  AgentBuilder
+  AgentSession
 };
-//# sourceMappingURL=chunk-GSFQZYS7.js.map
+//# sourceMappingURL=chunk-TVIADATY.js.map