@anvia/core 0.6.3 → 0.7.0

package/dist/agent/index.d.ts

@@ -1,14 +1,15 @@
-import { k as ToolSearchDocument, l as ToolSet, A as AgentMiddleware, e as ToolMiddleware } from '../middleware-C0eXGwoh.js';
-export { C as CompletionRequestMiddlewareArgs, a as CompletionRequestMiddlewareResult, b as CompletionResponseMiddlewareArgs, c as CompletionResponseMiddlewareResult, T as ToolInputMiddlewareArgs, d as ToolInputMiddlewareResult, f as ToolOutputMiddlewareArgs, g as ToolOutputMiddlewareResult, h as ToolResultMiddlewareArgs, i as createMiddleware, j as createToolMiddleware } from '../middleware-C0eXGwoh.js';
-import { D as DynamicContextOptions, f as DynamicToolOptions, g as PromptHook, h as AgentEventStore, i as AgentEventStoreOptions, e as Agent } from '../agent-CFMdNB6O.js';
-export { A as AgentChildStreamEvent, j as AgentEventAppendInput, k as AgentEventRecord, l as AgentEventStoreInclude, a as AgentStreamEvent, C as CompletionCallHookArgs, m as CompletionErrorHookArgs, n as CompletionResponseHookArgs, H as HookAction, o as HookResult, P as PromptResponse, R as RunControl, p as RunEndHookArgs, q as RunErrorHookArgs, u as RunStartHookArgs, T as ToolApprovalRequestOptions, v as ToolCallControl, w as ToolCallHookAction, x as ToolCallHookArgs, y as ToolCallHookResult, z as ToolErrorHookArgs, B as ToolHookArgs, E as ToolResultHookArgs, F as TurnEndHookArgs, G as TurnStartHookArgs, c as cancelPrompt, b as createHook, r as requestToolApproval, d as runControl, s as skipTool, t as toolCallControl } from '../agent-CFMdNB6O.js';
+import { A as AnyTool, e as ToolApprovalsOptions, d as ToolApprovalRequest } from '../tool-BLypI31e.js';
+export { b as ToolApprovalDecision } from '../tool-BLypI31e.js';
+import { k as ToolSearchDocument, l as ToolSet, A as AgentMiddleware, e as ToolMiddleware } from '../middleware-CZocYAtZ.js';
+export { C as CompletionRequestMiddlewareArgs, a as CompletionRequestMiddlewareResult, b as CompletionResponseMiddlewareArgs, c as CompletionResponseMiddlewareResult, T as ToolInputMiddlewareArgs, d as ToolInputMiddlewareResult, f as ToolOutputMiddlewareArgs, g as ToolOutputMiddlewareResult, h as ToolResultMiddlewareArgs, i as createMiddleware, j as createToolMiddleware } from '../middleware-CZocYAtZ.js';
+import { D as DynamicContextOptions, f as DynamicToolOptions, g as PromptHook, h as AgentEventStore, i as AgentEventStoreOptions, e as Agent } from '../agent-BW19m79B.js';
+export { A as AgentChildStreamEvent, j as AgentEventAppendInput, k as AgentEventRecord, l as AgentEventStoreInclude, a as AgentStreamEvent, C as CompletionCallHookArgs, m as CompletionErrorHookArgs, n as CompletionResponseHookArgs, H as HookAction, o as HookResult, P as PromptResponse, R as RunControl, p as RunEndHookArgs, q as RunErrorHookArgs, u as RunStartHookArgs, T as ToolApprovalRequestOptions, v as ToolCallControl, w as ToolCallHookAction, x as ToolCallHookArgs, y as ToolCallHookResult, z as ToolErrorHookArgs, B as ToolHookArgs, E as ToolResultHookArgs, F as TurnEndHookArgs, G as TurnStartHookArgs, c as cancelPrompt, b as createHook, r as requestToolApproval, d as runControl, s as skipTool, t as toolCallControl } from '../agent-BW19m79B.js';
 import { Z as ZodSchema } from '../zod-schema-C7F4clpm.js';
 import { C as CompletionModel, e as JsonValue, n as ToolChoice, M as Message } from '../types-C8loR4il.js';
-import { a as McpServer } from '../types-BLyF-Tub.js';
+import { a as McpServer } from '../types-CIwm9p4w.js';
 import { MemoryStore, MemoryOptions } from '../memory/index.js';
 import { AgentObserver, ObserveOptions } from '../observability/index.js';
-import { a as SkillSet } from '../types-BfEFm6zu.js';
-import { A as AnyTool } from '../tool-Bwj_zoTx.js';
+import { a as SkillSet } from '../types-D-YTJdLj.js';
 import { VectorSearchIndex } from '../vector-store/index.js';
 import '../types-IB2e9u5M.js';
 import 'zod';
@@ -30,6 +31,7 @@ declare class AgentBuilder<M extends CompletionModel = CompletionModel> {
     private turns;
     private requestHook;
     private schema;
+    private approvalOptions;
     private skillInstructionBlocks;
     private observerRegistrations;
     private dynamicContextRegistrations;
@@ -67,6 +69,7 @@ declare class AgentBuilder<M extends CompletionModel = CompletionModel> {
      */
     toolMiddlewares(middlewares: ToolMiddleware[]): this;
     observe(observer: AgentObserver, options?: ObserveOptions): this;
+    approvals(options: ToolApprovalsOptions): this;
     memory(store: MemoryStore, options?: MemoryOptions): this;
     eventStore(store: AgentEventStore, options?: AgentEventStoreOptions): this;
     outputSchema(schema: ZodSchema): this;
@@ -85,5 +88,9 @@ declare class PromptCancelledError extends Error {
     readonly reason: string;
     constructor(chatHistory: Message[], reason: string);
 }
+declare class ToolApprovalRequiredError extends Error {
+    readonly request: ToolApprovalRequest;
+    constructor(request: ToolApprovalRequest);
+}
 
-export { AgentBuilder, AgentEventStore, AgentEventStoreOptions, AgentMiddleware, MaxTurnsError, PromptCancelledError, PromptHook, ToolMiddleware };
+export { AgentBuilder, AgentEventStore, AgentEventStoreOptions, AgentMiddleware, MaxTurnsError, PromptCancelledError, PromptHook, ToolApprovalRequest, ToolApprovalRequiredError, ToolApprovalsOptions, ToolMiddleware };

package/dist/agent/index.js

@@ -1,23 +1,24 @@
 import {
   AgentBuilder
-} from "../chunk-SYMAVW5T.js";
+} from "../chunk-NCZRYTA6.js";
 import {
   MaxTurnsError,
   PromptCancelledError,
+  ToolApprovalRequiredError,
   cancelPrompt,
   createHook,
   requestToolApproval,
   runControl,
   skipTool,
   toolCallControl
-} from "../chunk-GBBMMU5E.js";
+} from "../chunk-6OR42QTG.js";
 import "../chunk-XUUY2L2D.js";
 import "../chunk-XXT2UCAR.js";
 import "../chunk-YK4WAAS4.js";
 import {
   createMiddleware,
   createToolMiddleware
-} from "../chunk-5OGAUWM5.js";
+} from "../chunk-IA47SXLS.js";
 import "../chunk-66IJDP6L.js";
 import "../chunk-MMHG7WAM.js";
 import "../chunk-S5IGJ4RB.js";
@@ -29,6 +30,7 @@ export {
   AgentBuilder,
   MaxTurnsError,
   PromptCancelledError,
+  ToolApprovalRequiredError,
   cancelPrompt,
   createHook,
   createMiddleware,

package/dist/{agent-CFMdNB6O.d.ts → agent-BW19m79B.d.ts}

@@ -1,8 +1,8 @@
 import { M as Message, U as Usage, c as CompletionResponse, k as ToolResultContent, x as ReasoningContentType, f as ToolCall, C as CompletionModel, D as Document, e as JsonValue, n as ToolChoice, J as JsonObject } from './types-C8loR4il.js';
 import { MemoryContext, MemoryRegistration, SessionOptions } from './memory/index.js';
 import { AgentTraceInfo, AgentTraceOptions, AgentObserverRegistration } from './observability/index.js';
-import { A as AgentMiddleware, e as ToolMiddleware, l as ToolSet, k as ToolSearchDocument } from './middleware-C0eXGwoh.js';
-import { T as Tool, A as AnyTool, c as ToolCallContext, N as NormalizedToolOutput } from './tool-Bwj_zoTx.js';
+import { A as AgentMiddleware, e as ToolMiddleware, l as ToolSet, k as ToolSearchDocument } from './middleware-CZocYAtZ.js';
+import { e as ToolApprovalsOptions, T as Tool, A as AnyTool, f as ToolCallContext, N as NormalizedToolOutput } from './tool-BLypI31e.js';
 import { VectorFilter, VectorSearchResult, VectorSearchIndex } from './vector-store/index.js';
 
 type HookAction = {
@@ -186,9 +186,11 @@ type AgentStreamEvent<RawResponse = unknown> = AgentChildStreamEvent<RawResponse
 declare class PromptRequest<M extends CompletionModel = CompletionModel> {
     private readonly agent;
     private readonly promptMessage;
+    private readonly memoryContext;
     private chatHistory;
     private maxTurnCount;
     private activeHook;
+    private approvalOptions;
     private concurrency;
     private traceOptions;
     private requestMiddlewares;
@@ -201,6 +203,7 @@ declare class PromptRequest<M extends CompletionModel = CompletionModel> {
     }): PromptRequest<M>;
     maxTurns(maxTurns: number): this;
     withHook(hook: PromptHook): this;
+    approvals(options: ToolApprovalsOptions): this;
     /**
      * @deprecated Use `withHook` instead.
      */
@@ -259,6 +262,7 @@ type AgentOptions<M extends CompletionModel = CompletionModel> = {
     hook?: PromptHook | undefined;
     outputSchema?: JsonObject | undefined;
     observers?: AgentObserverRegistration[] | undefined;
+    approvals?: ToolApprovalsOptions | undefined;
     dynamicContexts?: DynamicContextRegistration[] | undefined;
     dynamicTools?: DynamicToolRegistration[] | undefined;
     middlewares?: AgentMiddleware[] | undefined;
@@ -337,6 +341,7 @@ declare class Agent<M extends CompletionModel = CompletionModel> {
     readonly hook: PromptHook | undefined;
     readonly outputSchema: JsonObject | undefined;
     readonly observers: AgentObserverRegistration[];
+    readonly approvals: ToolApprovalsOptions | undefined;
     readonly dynamicContexts: DynamicContextRegistration[];
     readonly dynamicTools: DynamicToolRegistration[];
     readonly middlewares: AgentMiddleware[];

package/dist/{chunk-GBBMMU5E.js → chunk-6OR42QTG.js}

@@ -6,8 +6,9 @@ import {
 } from "./chunk-YK4WAAS4.js";
 import {
   ToolSet,
+  parseToolArgs,
   toolResultContentToText
-} from "./chunk-5OGAUWM5.js";
+} from "./chunk-IA47SXLS.js";
 import {
   createTool
 } from "./chunk-66IJDP6L.js";
@@ -52,6 +53,14 @@ var PromptCancelledError = class extends Error {
   chatHistory;
   reason;
 };
+var ToolApprovalRequiredError = class extends Error {
+  constructor(request) {
+    super(`Tool approval required for ${request.toolName}, but no approval handler is configured.`);
+    this.request = request;
+    this.name = "ToolApprovalRequiredError";
+  }
+  request;
+};
 
 // src/agent/hooks.ts
 function createHook(hook) {
@@ -344,24 +353,6 @@ var ActiveToolObservers = class {
   }
 };
 
-// src/agent/request-types.ts
-function addTurn(turn, event) {
-  if (event.type === "text_delta") {
-    return { type: "text_delta", turn, delta: event.delta };
-  }
-  if (event.type === "reasoning_delta") {
-    const mapped = { type: "reasoning_delta", turn, delta: event.delta };
-    if (event.id !== void 0) mapped.id = event.id;
-    if (event.contentType !== void 0) mapped.contentType = event.contentType;
-    if (event.signature !== void 0) mapped.signature = event.signature;
-    return mapped;
-  }
-  return { type: "tool_call", turn, toolCall: event.toolCall };
-}
-function isGenerationDeltaEvent(type) {
-  return type === "text_delta" || type === "reasoning_delta" || type === "tool_call_delta" || type === "tool_call";
-}
-
 // src/agent/request-memory.ts
 var PromptRequestMemory = class {
   constructor(agent, memoryContext, initialHistory) {
@@ -454,6 +445,24 @@ var PromptRequestMemory = class {
   }
 };
 
+// src/agent/request-types.ts
+function addTurn(turn, event) {
+  if (event.type === "text_delta") {
+    return { type: "text_delta", turn, delta: event.delta };
+  }
+  if (event.type === "reasoning_delta") {
+    const mapped = { type: "reasoning_delta", turn, delta: event.delta };
+    if (event.id !== void 0) mapped.id = event.id;
+    if (event.contentType !== void 0) mapped.contentType = event.contentType;
+    if (event.signature !== void 0) mapped.signature = event.signature;
+    return mapped;
+  }
+  return { type: "tool_call", turn, toolCall: event.toolCall };
+}
+function isGenerationDeltaEvent(type) {
+  return type === "text_delta" || type === "reasoning_delta" || type === "tool_call_delta" || type === "tool_call";
+}
+
 // src/agent/retrieval.ts
 async function fetchDynamicContext(agent, ragText) {
   if (ragText === void 0 || ragText.length === 0 || agent.dynamicContexts.length === 0) {
@@ -766,15 +775,19 @@ function isEmptyToolArguments(value) {
 // src/agent/tool-execution.ts
 var MCP_TOOL_METADATA_KEY = /* @__PURE__ */ Symbol.for("anvia.mcp.tool.metadata");
 var ToolCallExecutor = class {
-  constructor(agent, activeHook, concurrency, requestMiddlewares, cancel) {
+  constructor(agent, activeHook, approvals, runContext, concurrency, requestMiddlewares, cancel) {
     this.agent = agent;
     this.activeHook = activeHook;
+    this.approvals = approvals;
+    this.runContext = runContext;
     this.concurrency = concurrency;
     this.requestMiddlewares = requestMiddlewares;
     this.cancel = cancel;
   }
   agent;
   activeHook;
+  approvals;
+  runContext;
   concurrency;
   requestMiddlewares;
   cancel;
@@ -795,16 +808,18 @@ var ToolCallExecutor = class {
         (definition) => definition.name === toolCall.function.name
       );
       const toolMetadata = toolTraceMetadata(tool);
-      const toolObservers = await observation?.runObservers.startTool(compact({
-        turn: observation.turn,
-        toolCall,
-        toolName: toolCall.function.name,
-        internalCallId,
-        args,
-        toolCallId: toolCall.callId,
-        toolDefinition,
-        toolMetadata
-      }));
+      const toolObservers = await observation?.runObservers.startTool(
+        compact({
+          turn: observation.turn,
+          toolCall,
+          toolName: toolCall.function.name,
+          internalCallId,
+          args,
+          toolCallId: toolCall.callId,
+          toolDefinition,
+          toolMetadata
+        })
+      );
       const callAction = await this.activeHook?.onToolCall?.({
         ...hookArgs,
         tool: toolCallControl
@@ -820,18 +835,6 @@ var ToolCallExecutor = class {
         );
         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;
       let effectiveArgs = args;
@@ -839,51 +842,70 @@ var ToolCallExecutor = class {
         output = callAction.reason;
         skipped = true;
       } else {
-        effectiveArgs = await this.runToolInputMiddlewares({
-          ...hookArgs,
-          turn: observation?.turn ?? 0,
-          originalArgs: args
-        });
+        let approvalDecision;
         try {
-          output = await this.agent.callTool(toolCall.function.name, effectiveArgs, {
-            emitStreamEvent: async (event) => {
-              await toolObservers?.streamEvent(
-                compact({
-                  turn: observation?.turn ?? 0,
-                  toolCall,
-                  toolName: toolCall.function.name,
-                  internalCallId,
-                  args: effectiveArgs,
-                  toolCallId: toolCall.callId,
-                  event
-                })
-              );
-              const payload = agentToolEventPayload(toolCall, internalCallId, event);
-              if (payload !== void 0) {
-                onStreamEvent?.(payload);
-              }
-            }
-          });
+          approvalDecision = callAction?.type === "approval_request" ? await this.requestApproval(tool, hookArgs, callAction) : await this.evaluateToolApproval(tool, hookArgs) ?? { approved: true };
         } catch (error) {
-          const errorAction = await this.activeHook?.onToolError?.({
-            ...hookArgs,
-            args: effectiveArgs,
-            error,
-            run: runControl
-          });
-          await toolObservers?.error({
-            turn: observation?.turn ?? 0,
+          await recordToolError(
+            toolObservers,
+            observation?.turn,
             toolCall,
-            toolName: toolCall.function.name,
             internalCallId,
-            args: effectiveArgs,
-            ...toolCall.callId !== void 0 && { toolCallId: toolCall.callId },
+            args,
             error
+          );
+          throw error;
+        }
+        if (!approvalDecision.approved) {
+          output = approvalDecision.result;
+          skipped = true;
+        } else {
+          effectiveArgs = await this.runToolInputMiddlewares({
+            ...hookArgs,
+            turn: observation?.turn ?? 0,
+            originalArgs: args
           });
-          if (errorAction?.type === "terminate") {
-            throw this.cancel(errorAction.reason);
+          try {
+            output = await this.agent.callTool(toolCall.function.name, effectiveArgs, {
+              emitStreamEvent: async (event) => {
+                await toolObservers?.streamEvent(
+                  compact({
+                    turn: observation?.turn ?? 0,
+                    toolCall,
+                    toolName: toolCall.function.name,
+                    internalCallId,
+                    args: effectiveArgs,
+                    toolCallId: toolCall.callId,
+                    event
+                  })
+                );
+                const payload = agentToolEventPayload(toolCall, internalCallId, event);
+                if (payload !== void 0) {
+                  onStreamEvent?.(payload);
+                }
+              }
+            });
+          } catch (error) {
+            const errorAction = await this.activeHook?.onToolError?.({
+              ...hookArgs,
+              args: effectiveArgs,
+              error,
+              run: runControl
+            });
+            await toolObservers?.error({
+              turn: observation?.turn ?? 0,
+              toolCall,
+              toolName: toolCall.function.name,
+              internalCallId,
+              args: effectiveArgs,
+              ...toolCall.callId !== void 0 && { toolCallId: toolCall.callId },
+              error
+            });
+            if (errorAction?.type === "terminate") {
+              throw this.cancel(errorAction.reason);
+            }
+            output = error instanceof Error ? error.toString() : String(error);
           }
-          output = error instanceof Error ? error.toString() : String(error);
         }
       }
       let result = toolOutputToText(output);
@@ -991,7 +1013,65 @@ var ToolCallExecutor = class {
   activeMiddlewares() {
     return [...this.agent.middlewares, ...this.requestMiddlewares];
   }
+  async evaluateToolApproval(tool, hookArgs) {
+    if (tool?.approval === void 0) {
+      return void 0;
+    }
+    const policy = tool.approval;
+    const context = approvalContext(tool, hookArgs, this.agent, this.runContext);
+    const required = await policy.when(context);
+    if (!required) {
+      return { approved: true };
+    }
+    const reason = await resolveApprovalText(policy.reason, context);
+    const rejectMessage = await resolveApprovalText(policy.rejectMessage, context);
+    return this.requestApproval(tool, hookArgs, compact({ reason, rejectMessage }));
+  }
+  async requestApproval(tool, hookArgs, options) {
+    const request = compact({
+      ...approvalContext(tool, hookArgs, this.agent, this.runContext),
+      reason: options.reason,
+      rejectMessage: options.rejectMessage
+    });
+    if (this.approvals === void 0) {
+      throw new ToolApprovalRequiredError(request);
+    }
+    const decision = normalizeApprovalDecision(await this.approvals.handler(request));
+    if (decision.approved) {
+      return { approved: true };
+    }
+    return {
+      approved: false,
+      result: decision.rejectMessage ?? decision.reason ?? request.rejectMessage ?? "Tool approval was rejected."
+    };
+  }
 };
+function approvalContext(tool, hookArgs, agent, run) {
+  const rawParsedArgs = parseToolArgs(hookArgs.args);
+  const parsedArgs = tool?.parseApprovalArgs?.(rawParsedArgs) ?? rawParsedArgs;
+  return compact({
+    toolName: hookArgs.toolName,
+    args: parsedArgs,
+    rawArgs: hookArgs.args,
+    toolCallId: hookArgs.toolCallId,
+    internalCallId: hookArgs.internalCallId,
+    run: compact({
+      agentId: agent.id,
+      runId: run.runId,
+      sessionId: run.sessionId,
+      metadata: run.metadata
+    })
+  });
+}
+function normalizeApprovalDecision(decision) {
+  if (typeof decision === "boolean") {
+    return { approved: decision };
+  }
+  return decision;
+}
+async function resolveApprovalText(value, context) {
+  return typeof value === "function" ? value(context) : value;
+}
 function normalizeToolOutputMiddlewareResult(result) {
   if (typeof result === "string") {
     return { result };
@@ -1046,16 +1126,20 @@ var PromptRequest = class _PromptRequest {
   constructor(agent, promptMessage, initialHistory = [], memoryContext = void 0) {
     this.agent = agent;
     this.promptMessage = promptMessage;
+    this.memoryContext = memoryContext;
     this.chatHistory = initialHistory;
     this.maxTurnCount = agent.defaultMaxTurns ?? 0;
     this.activeHook = agent.hook;
+    this.approvalOptions = agent.approvals;
     this.memoryRecorder = new PromptRequestMemory(agent, memoryContext, initialHistory);
   }
   agent;
   promptMessage;
+  memoryContext;
   chatHistory;
   maxTurnCount;
   activeHook;
+  approvalOptions;
   concurrency = 1;
   traceOptions;
   requestMiddlewares = [];
@@ -1074,6 +1158,10 @@ var PromptRequest = class _PromptRequest {
     this.activeHook = hook;
     return this;
   }
+  approvals(options) {
+    this.approvalOptions = options;
+    return this;
+  }
   /**
    * @deprecated Use `withHook` instead.
    */
@@ -1187,6 +1275,7 @@ var PromptRequest = class _PromptRequest {
           return result;
         }
         const toolResults = await this.executeToolCalls(
+          runId,
           toolCalls,
           newMessages,
           void 0,
@@ -1259,16 +1348,18 @@ var PromptRequest = class _PromptRequest {
         request = await this.runCompletionRequestMiddlewares(request, currentTurns);
         assertCompletionRequestSupported(this.agent.model, request, { streaming: true });
         const providerRequest = this.providerTraceRequest(request, { stream: true });
-        const generationObservers = await runObservers.startGeneration(compact({
-          turn: currentTurns,
-          request,
-          providerRequest,
-          modelInfo: {
-            provider: this.agent.model.provider,
-            defaultModel: this.agent.model.defaultModel,
-            capabilities: this.agent.model.capabilities
-          }
-        }));
+        const generationObservers = await runObservers.startGeneration(
+          compact({
+            turn: currentTurns,
+            request,
+            providerRequest,
+            modelInfo: {
+              provider: this.agent.model.provider,
+              defaultModel: this.agent.model.defaultModel,
+              capabilities: this.agent.model.capabilities
+            }
+          })
+        );
         const accumulator = new CompletionStreamAccumulator();
         const generationStartedAt = Date.now();
         let firstDeltaMs;
@@ -1291,11 +1382,13 @@ var PromptRequest = class _PromptRequest {
           throw error;
         }
         let response = accumulator.response();
-        await generationObservers.end(compact({
-          turn: currentTurns,
-          response,
-          firstDeltaMs
-        }));
+        await generationObservers.end(
+          compact({
+            turn: currentTurns,
+            response,
+            firstDeltaMs
+          })
+        );
         response = await this.runCompletionResponseMiddlewares(request, response, currentTurns);
         usage = Usage.add(usage, response.usage);
         await this.runCompletionResponseHook(prompt, response, newMessages);
@@ -1342,6 +1435,7 @@ var PromptRequest = class _PromptRequest {
         }
         const toolResultEvents = createAsyncQueue();
         const toolResultsPromise = this.executeToolCalls(
+          runId,
           toolCalls,
           newMessages,
           (result) => {
@@ -1391,16 +1485,18 @@ var PromptRequest = class _PromptRequest {
   async runCompletion(request, turn, runObservers) {
     assertCompletionRequestSupported(this.agent.model, request);
     const providerRequest = this.providerTraceRequest(request);
-    const generationObservers = await runObservers.startGeneration(compact({
-      turn,
-      request,
-      providerRequest,
-      modelInfo: {
-        provider: this.agent.model.provider,
-        defaultModel: this.agent.model.defaultModel,
-        capabilities: this.agent.model.capabilities
-      }
-    }));
+    const generationObservers = await runObservers.startGeneration(
+      compact({
+        turn,
+        request,
+        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 });
@@ -1419,10 +1515,16 @@ var PromptRequest = class _PromptRequest {
       };
     }
   }
-  async executeToolCalls(toolCalls, newMessages, onResult, onStreamEvent, observation) {
+  async executeToolCalls(runId, toolCalls, newMessages, onResult, onStreamEvent, observation) {
     const executor = new ToolCallExecutor(
       this.agent,
       this.activeHook,
+      this.approvalOptions,
+      {
+        runId,
+        sessionId: this.memoryContext?.sessionId,
+        metadata: this.memoryContext?.metadata
+      },
       this.concurrency,
       this.requestMiddlewares,
       (reason) => this.cancelled(newMessages, reason)
@@ -1650,6 +1752,7 @@ var Agent = class {
   hook;
   outputSchema;
   observers;
+  approvals;
   dynamicContexts;
   dynamicTools;
   middlewares;
@@ -1675,6 +1778,7 @@ var Agent = class {
     this.hook = options.hook;
     this.outputSchema = options.outputSchema;
     this.observers = options.observers ?? [];
+    this.approvals = options.approvals;
     this.dynamicContexts = options.dynamicContexts ?? [];
     this.dynamicTools = options.dynamicTools ?? [];
     this.middlewares = options.middlewares ?? options.toolMiddlewares ?? [];
@@ -1714,11 +1818,13 @@ var Agent = class {
         if (options.stream === true && context.emitStreamEvent !== void 0 && this.model.capabilities.streaming && isStreamingCompletionModel(this.model)) {
           let output = "";
           for await (const event of childRequest.stream()) {
-            await context.emitStreamEvent(compact({
-              agentId: this.id,
-              agentName: this.name,
-              event
-            }));
+            await context.emitStreamEvent(
+              compact({
+                agentId: this.id,
+                agentName: this.name,
+                event
+              })
+            );
             if (event.type === "final") {
               output = event.output;
             }
@@ -1796,6 +1902,7 @@ export {
   normalizeAgentId,
   MaxTurnsError,
   PromptCancelledError,
+  ToolApprovalRequiredError,
   createHook,
   cancelPrompt,
   skipTool,
@@ -1807,4 +1914,4 @@ export {
   Agent,
   AgentSession
 };
-//# sourceMappingURL=chunk-GBBMMU5E.js.map
+//# sourceMappingURL=chunk-6OR42QTG.js.map