@anvia/core 1.1.1 → 1.2.0

package/dist/chunk-J4SINPUA.js

@@ -0,0 +1,939 @@
+import {
+  AgentInteractionSignal,
+  ToolExecutionSuspension
+} from "./chunk-5IURMWFN.js";
+import {
+  isQuestionTool
+} from "./chunk-IV6YQTY2.js";
+import {
+  isSkillTool
+} from "./chunk-2NLINXRF.js";
+import {
+  runControl,
+  toolCallControl
+} from "./chunk-FAPIZJS2.js";
+import {
+  parseAgentQuestionPrompts
+} from "./chunk-LBYJPMHC.js";
+import {
+  lifecycleSnapshot
+} from "./chunk-KFAVEL5F.js";
+import {
+  isMcpTool
+} from "./chunk-PLDJCCVL.js";
+import {
+  mapWithConcurrency
+} from "./chunk-4FIVU53H.js";
+import {
+  assertCompletionResponseIntegrity
+} from "./chunk-XQV3XNVT.js";
+import {
+  assertToolApprovalRequirement,
+  toolMayRequireApproval
+} from "./chunk-YZVFIW5D.js";
+import {
+  prepareToolCall,
+  prepareToolCallFromInput
+} from "./chunk-MHOJJYDK.js";
+import {
+  ToolOutput,
+  normalizeToolResultOutput,
+  parseToolArgs,
+  toolResultContentToText
+} from "./chunk-47NTHIVB.js";
+import {
+  Usage
+} from "./chunk-IDNL6IH4.js";
+import {
+  isJsonValue
+} from "./chunk-4C7AXYOM.js";
+import {
+  throwIfAborted
+} from "./chunk-USRKPEQN.js";
+
+// src/internal/agent-runtime/tool-execution.ts
+var ToolCallExecutor = class {
+  constructor(agent, activeHook, approvalHandler, lifecycle, runContext, concurrency, requestMiddlewares, abortSignal, cancel) {
+    this.agent = agent;
+    this.activeHook = activeHook;
+    this.approvalHandler = approvalHandler;
+    this.lifecycle = lifecycle;
+    this.runContext = runContext;
+    this.concurrency = concurrency;
+    this.requestMiddlewares = requestMiddlewares;
+    this.abortSignal = abortSignal;
+    this.cancel = cancel;
+  }
+  agent;
+  activeHook;
+  approvalHandler;
+  lifecycle;
+  runContext;
+  concurrency;
+  requestMiddlewares;
+  abortSignal;
+  cancel;
+  async execute(toolCalls, onResult, onStreamEvent, observation) {
+    assertCompletionResponseIntegrity({
+      response: {
+        choice: [...toolCalls],
+        usage: Usage.empty(),
+        rawResponse: void 0
+      }
+    });
+    const executeOne = async (toolCall) => {
+      throwIfAborted(this.abortSignal);
+      const args = JSON.stringify(toolCall.input);
+      const internalCallId = globalThis.crypto.randomUUID();
+      const hookArgs = {
+        toolName: toolCall.toolName,
+        toolCallId: toolCall.toolCallId,
+        internalCallId,
+        args
+      };
+      if (toolCall.callId !== void 0) {
+        hookArgs.callId = toolCall.callId;
+      }
+      const tool = this.agent.getTool(toolCall.toolName);
+      const toolDefinition = observation?.toolDefinitions?.find(
+        (definition) => definition.name === toolCall.toolName
+      );
+      const toolMetadata = toolTraceMetadata(tool);
+      let toolStartArgs = {
+        turn: observation?.turn ?? 0,
+        toolCall,
+        toolName: toolCall.toolName,
+        internalCallId,
+        args
+      };
+      if (toolCall.callId !== void 0) {
+        toolStartArgs = { ...toolStartArgs, toolCallId: toolCall.callId };
+      }
+      if (toolDefinition !== void 0) toolStartArgs = { ...toolStartArgs, toolDefinition };
+      if (toolMetadata !== void 0) toolStartArgs = { ...toolStartArgs, toolMetadata };
+      const toolObservers = await observation?.runObservers.startTool(toolStartArgs);
+      const toolObservation = new ToolObserverScope(toolObservers);
+      let output;
+      let skipped = false;
+      let toolExecutionFailed = false;
+      let effectiveArgs = args;
+      try {
+        const callAction = await this.activeHook?.onToolCall?.({
+          ...hookArgs,
+          tool: toolCallControl
+        });
+        if (callAction?.type === "terminate") {
+          throw this.cancel(callAction.reason);
+        }
+        if (callAction?.type === "skip") {
+          output = { type: "text", value: callAction.reason };
+          skipped = true;
+        } else {
+          try {
+            effectiveArgs = await this.runToolInputMiddlewares({
+              ...hookArgs,
+              turn: observation?.turn ?? 0,
+              originalArgs: args
+            });
+            hookArgs.args = effectiveArgs;
+            let prepared;
+            try {
+              prepared = this.prepareToolCall(tool, toolCall.toolName, effectiveArgs);
+            } catch (error) {
+              const outcome = await this.handleToolError(
+                toolCall,
+                hookArgs,
+                effectiveArgs,
+                error,
+                toolObservation,
+                observation
+              );
+              output = outcome.output;
+              toolExecutionFailed = outcome.failed;
+            }
+            if (prepared !== void 0 && isQuestionTool(tool)) {
+              try {
+                const questions = parseAgentQuestionPrompts(
+                  prepared.input.questions
+                );
+                const interaction = {
+                  type: "tool-question",
+                  id: globalThis.crypto.randomUUID(),
+                  toolName: toolCall.toolName,
+                  toolCallId: toolCall.toolCallId,
+                  internalCallId,
+                  questions
+                };
+                if (toolCall.callId !== void 0) {
+                  Object.assign(interaction, { callId: toolCall.callId });
+                }
+                throw new AgentInteractionSignal(interaction);
+              } catch (error) {
+                if (error instanceof AgentInteractionSignal) throw error;
+                const outcome = await this.handleToolError(
+                  toolCall,
+                  hookArgs,
+                  effectiveArgs,
+                  error,
+                  toolObservation,
+                  observation
+                );
+                output = outcome.output;
+                toolExecutionFailed = outcome.failed;
+                prepared = void 0;
+              }
+            }
+            if (prepared !== void 0) {
+              const approvalContext = createApprovalContext(
+                prepared.input,
+                hookArgs,
+                this.agent,
+                this.runContext
+              );
+              const approvalDecision = callAction?.type === "approval_request" ? await this.requestApproval(approvalContext, callAction, observation) : await this.evaluateToolApproval(tool, approvalContext, observation) ?? {
+                approved: true
+              };
+              if (!approvalDecision.approved) {
+                output = { type: "execution-denied", reason: approvalDecision.result };
+                skipped = true;
+              } else {
+                const step = observation?.turn ?? 0;
+                const lifecycleEvent = {
+                  runId: this.runContext.runId,
+                  step,
+                  toolName: toolCall.toolName,
+                  input: lifecycleSnapshot(prepared.input)
+                };
+                if (toolCall.callId !== void 0) {
+                  Object.assign(lifecycleEvent, { toolCallId: toolCall.callId });
+                }
+                await this.lifecycle?.onToolStart?.(lifecycleEvent);
+                const startedAt = Date.now();
+                const outcome = await this.runApprovedToolCall(
+                  prepared,
+                  toolCall,
+                  hookArgs,
+                  effectiveArgs,
+                  toolObservation,
+                  observation,
+                  onStreamEvent
+                );
+                output = outcome.output;
+                toolExecutionFailed = outcome.failed;
+                const durationMs = Date.now() - startedAt;
+                await this.lifecycle?.onToolFinish?.(
+                  outcome.failed ? {
+                    ...lifecycleEvent,
+                    durationMs,
+                    success: false,
+                    error: lifecycleSnapshot(outcome.error)
+                  } : {
+                    ...lifecycleEvent,
+                    durationMs,
+                    success: true,
+                    output: lifecycleSnapshot(output)
+                  }
+                );
+              }
+            }
+          } catch (error) {
+            if (error instanceof AgentInteractionSignal) {
+              await toolObservation.suspend({
+                ...toolStartArgs,
+                interaction: error.interaction
+              });
+              throw error;
+            }
+            await toolObservation.error(
+              toolErrorArgs(observation?.turn ?? 0, toolCall, internalCallId, effectiveArgs, error)
+            );
+            throw error;
+          }
+        }
+        if (output === void 0) {
+          throw new Error(`Tool "${toolCall.toolName}" did not produce an execution result.`);
+        }
+        let result = toolOutputToText(output);
+        let structuredResult = toolOutputToStructuredResult(output);
+        if (!isSkillTool(tool)) {
+          const middlewareReplacement = await this.runToolResultMiddlewares({
+            ...hookArgs,
+            args: effectiveArgs,
+            result,
+            originalResult: result,
+            structuredResult,
+            originalStructuredResult: structuredResult,
+            turn: observation?.turn ?? 0
+          });
+          if (middlewareReplacement !== void 0) {
+            output = middlewareReplacement;
+            result = toolOutputToText(middlewareReplacement);
+            structuredResult = toolOutputToStructuredResult(middlewareReplacement);
+          }
+        }
+        const resultAction = await this.activeHook?.onToolResult?.({
+          ...hookArgs,
+          args: effectiveArgs,
+          result,
+          structuredResult,
+          run: runControl
+        });
+        if (!toolExecutionFailed) {
+          await toolObservation.end({
+            turn: observation?.turn ?? 0,
+            toolCall,
+            toolName: toolCall.toolName,
+            internalCallId,
+            args: effectiveArgs,
+            result,
+            structuredResult,
+            skipped,
+            toolCallId: toolCall.callId
+          });
+        }
+        if (resultAction?.type === "terminate") {
+          throw this.cancel(resultAction.reason);
+        }
+        const resultPayload = {
+          type: "tool_result",
+          toolName: toolCall.toolName,
+          toolCallId: toolCall.toolCallId,
+          internalCallId,
+          args: effectiveArgs,
+          output,
+          result,
+          structuredResult
+        };
+        if (toolCall.callId !== void 0) resultPayload.callId = toolCall.callId;
+        onResult?.(resultPayload);
+        let resultPart = {
+          type: "tool-result",
+          toolCallId: toolCall.toolCallId,
+          toolName: toolCall.toolName,
+          output
+        };
+        if (toolCall.callId !== void 0) {
+          resultPart = { ...resultPart, callId: toolCall.callId };
+        }
+        return resultPart;
+      } catch (error) {
+        if (error instanceof AgentInteractionSignal) {
+          const pending = {
+            toolCall,
+            effectiveArgs,
+            input: error.interaction.type === "tool-approval" ? error.interaction.input : parseToolArgs(effectiveArgs),
+            internalCallId
+          };
+          if (error.rejectMessage !== void 0) pending.rejectMessage = error.rejectMessage;
+          throw new ToolExecutionSuspension(error.interaction, pending);
+        }
+        await toolObservation.error(
+          toolErrorArgs(observation?.turn ?? 0, toolCall, internalCallId, effectiveArgs, error)
+        );
+        throw error;
+      }
+    };
+    if (this.concurrency === 1) {
+      const results = [];
+      for (const toolCall of toolCalls) {
+        try {
+          results.push(await executeOne(toolCall));
+        } catch (error) {
+          if (error instanceof ToolExecutionSuspension) {
+            error.completedResults = [...results];
+            error.remainingToolCalls = toolCalls.slice(results.length + 1);
+          }
+          throw error;
+        }
+      }
+      return results;
+    }
+    return mapWithConcurrency(toolCalls, this.concurrency, executeOne);
+  }
+  async executeResumed(pending, onResult, onStreamEvent, observation) {
+    throwIfAborted(this.abortSignal);
+    const { toolCall, internalCallId, effectiveArgs } = pending;
+    const tool = this.agent.getTool(toolCall.toolName);
+    if (tool === void 0) {
+      throw new Error(
+        `Cannot resume tool interaction because tool "${toolCall.toolName}" is no longer registered.`
+      );
+    }
+    if (isQuestionTool(tool)) {
+      throw new TypeError("Question interactions are resolved from their submitted answers.");
+    }
+    const hookArgs = {
+      toolName: toolCall.toolName,
+      toolCallId: toolCall.toolCallId,
+      internalCallId,
+      args: effectiveArgs
+    };
+    if (toolCall.callId !== void 0) hookArgs.callId = toolCall.callId;
+    const toolDefinition = observation?.toolDefinitions?.find(
+      (definition) => definition.name === toolCall.toolName
+    );
+    const toolMetadata = toolTraceMetadata(tool);
+    let toolStartArgs = {
+      turn: observation?.turn ?? 0,
+      toolCall,
+      toolName: toolCall.toolName,
+      internalCallId,
+      args: effectiveArgs
+    };
+    if (toolCall.callId !== void 0) {
+      toolStartArgs = { ...toolStartArgs, toolCallId: toolCall.callId };
+    }
+    if (toolDefinition !== void 0) toolStartArgs = { ...toolStartArgs, toolDefinition };
+    if (toolMetadata !== void 0) toolStartArgs = { ...toolStartArgs, toolMetadata };
+    const observers = await observation?.runObservers.startTool(toolStartArgs);
+    const toolObservation = new ToolObserverScope(observers);
+    let output;
+    let failed = false;
+    try {
+      const prepared = prepareToolCallFromInput(tool, pending.input);
+      const step = observation?.turn ?? 0;
+      const lifecycleEvent = {
+        runId: this.runContext.runId,
+        step,
+        toolName: toolCall.toolName,
+        input: lifecycleSnapshot(prepared.input)
+      };
+      if (toolCall.callId !== void 0) {
+        Object.assign(lifecycleEvent, { toolCallId: toolCall.callId });
+      }
+      await this.lifecycle?.onToolStart?.(lifecycleEvent);
+      const startedAt = Date.now();
+      const outcome = await this.runApprovedToolCall(
+        prepared,
+        toolCall,
+        hookArgs,
+        effectiveArgs,
+        toolObservation,
+        observation,
+        onStreamEvent
+      );
+      output = outcome.output;
+      failed = outcome.failed;
+      const durationMs = Date.now() - startedAt;
+      await this.lifecycle?.onToolFinish?.(
+        outcome.failed ? {
+          ...lifecycleEvent,
+          durationMs,
+          success: false,
+          error: lifecycleSnapshot(outcome.error)
+        } : {
+          ...lifecycleEvent,
+          durationMs,
+          success: true,
+          output: lifecycleSnapshot(output)
+        }
+      );
+      let result = toolOutputToText(output);
+      let structuredResult = toolOutputToStructuredResult(output);
+      if (!isSkillTool(tool)) {
+        const replacement = await this.runToolResultMiddlewares({
+          ...hookArgs,
+          args: effectiveArgs,
+          result,
+          originalResult: result,
+          structuredResult,
+          originalStructuredResult: structuredResult,
+          turn: step
+        });
+        if (replacement !== void 0) {
+          output = replacement;
+          result = toolOutputToText(replacement);
+          structuredResult = toolOutputToStructuredResult(replacement);
+        }
+      }
+      const resultAction = await this.activeHook?.onToolResult?.({
+        ...hookArgs,
+        result,
+        structuredResult,
+        run: runControl
+      });
+      if (!failed) {
+        await toolObservation.end({
+          turn: step,
+          toolCall,
+          toolName: toolCall.toolName,
+          internalCallId,
+          args: effectiveArgs,
+          result,
+          structuredResult,
+          skipped: false,
+          toolCallId: toolCall.callId
+        });
+      }
+      if (resultAction?.type === "terminate") {
+        throw this.cancel(resultAction.reason);
+      }
+      const resultPayload = {
+        type: "tool_result",
+        toolName: toolCall.toolName,
+        toolCallId: toolCall.toolCallId,
+        internalCallId,
+        args: effectiveArgs,
+        output,
+        result,
+        structuredResult
+      };
+      if (toolCall.callId !== void 0) resultPayload.callId = toolCall.callId;
+      onResult?.(resultPayload);
+      let resultPart = {
+        type: "tool-result",
+        toolName: toolCall.toolName,
+        toolCallId: toolCall.toolCallId,
+        output
+      };
+      if (toolCall.callId !== void 0) resultPart = { ...resultPart, callId: toolCall.callId };
+      return resultPart;
+    } catch (error) {
+      await toolObservation.error(
+        toolErrorArgs(observation?.turn ?? 0, toolCall, internalCallId, effectiveArgs, error)
+      );
+      throw error;
+    }
+  }
+  async resolveResumed(pending, initialOutput, onResult, observation) {
+    throwIfAborted(this.abortSignal);
+    const { toolCall, internalCallId, effectiveArgs } = pending;
+    const tool = this.agent.getTool(toolCall.toolName);
+    if (tool === void 0) {
+      throw new Error(
+        `Cannot resume tool interaction because tool "${toolCall.toolName}" is no longer registered.`
+      );
+    }
+    const hookArgs = {
+      toolName: toolCall.toolName,
+      toolCallId: toolCall.toolCallId,
+      internalCallId,
+      args: effectiveArgs
+    };
+    if (toolCall.callId !== void 0) hookArgs.callId = toolCall.callId;
+    const toolDefinition = observation?.toolDefinitions?.find(
+      (definition) => definition.name === toolCall.toolName
+    );
+    const toolMetadata = toolTraceMetadata(tool);
+    let toolStartArgs = {
+      turn: observation?.turn ?? 0,
+      toolCall,
+      toolName: toolCall.toolName,
+      internalCallId,
+      args: effectiveArgs
+    };
+    if (toolCall.callId !== void 0) {
+      toolStartArgs = { ...toolStartArgs, toolCallId: toolCall.callId };
+    }
+    if (toolDefinition !== void 0) toolStartArgs = { ...toolStartArgs, toolDefinition };
+    if (toolMetadata !== void 0) toolStartArgs = { ...toolStartArgs, toolMetadata };
+    const observers = await observation?.runObservers.startTool(toolStartArgs);
+    const toolObservation = new ToolObserverScope(observers);
+    try {
+      let output = initialOutput;
+      let result = toolOutputToText(output);
+      let structuredResult = toolOutputToStructuredResult(output);
+      if (!isSkillTool(tool)) {
+        const replacement = await this.runToolResultMiddlewares({
+          ...hookArgs,
+          args: effectiveArgs,
+          result,
+          originalResult: result,
+          structuredResult,
+          originalStructuredResult: structuredResult,
+          turn: observation?.turn ?? 0
+        });
+        if (replacement !== void 0) {
+          output = replacement;
+          result = toolOutputToText(replacement);
+          structuredResult = toolOutputToStructuredResult(replacement);
+        }
+      }
+      const resultAction = await this.activeHook?.onToolResult?.({
+        ...hookArgs,
+        result,
+        structuredResult,
+        run: runControl
+      });
+      await toolObservation.end({
+        turn: observation?.turn ?? 0,
+        toolCall,
+        toolName: toolCall.toolName,
+        internalCallId,
+        args: effectiveArgs,
+        result,
+        structuredResult,
+        skipped: true,
+        toolCallId: toolCall.callId
+      });
+      if (resultAction?.type === "terminate") {
+        throw this.cancel(resultAction.reason);
+      }
+      const resultPayload = {
+        type: "tool_result",
+        toolName: toolCall.toolName,
+        toolCallId: toolCall.toolCallId,
+        internalCallId,
+        args: effectiveArgs,
+        output,
+        result,
+        structuredResult
+      };
+      if (toolCall.callId !== void 0) resultPayload.callId = toolCall.callId;
+      onResult?.(resultPayload);
+      let resultPart = {
+        type: "tool-result",
+        toolName: toolCall.toolName,
+        toolCallId: toolCall.toolCallId,
+        output
+      };
+      if (toolCall.callId !== void 0) resultPart = { ...resultPart, callId: toolCall.callId };
+      return resultPart;
+    } catch (error) {
+      await toolObservation.error(
+        toolErrorArgs(observation?.turn ?? 0, toolCall, internalCallId, effectiveArgs, error)
+      );
+      throw error;
+    }
+  }
+  async runApprovedToolCall(prepared, toolCall, hookArgs, effectiveArgs, toolObservation, observation, onStreamEvent) {
+    try {
+      const toolContext = {
+        abortSignal: this.abortSignal,
+        emitStreamEvent: async (event) => {
+          let streamEventArgs = {
+            turn: observation?.turn ?? 0,
+            toolCall,
+            toolName: toolCall.toolName,
+            internalCallId: hookArgs.internalCallId,
+            args: effectiveArgs,
+            event
+          };
+          if (toolCall.callId !== void 0) {
+            streamEventArgs = { ...streamEventArgs, toolCallId: toolCall.callId };
+          }
+          await toolObservation.streamEvent(streamEventArgs);
+          const payload = agentToolEventPayload(toolCall, hookArgs.internalCallId, event);
+          if (payload !== void 0) {
+            onStreamEvent?.(payload);
+          }
+        }
+      };
+      return {
+        output: await prepared.call(toolContext),
+        failed: false
+      };
+    } catch (error) {
+      return this.handleToolError(
+        toolCall,
+        hookArgs,
+        effectiveArgs,
+        error,
+        toolObservation,
+        observation
+      );
+    }
+  }
+  prepareToolCall(tool, toolName, args) {
+    if (tool !== void 0) {
+      return prepareToolCall(tool, args);
+    }
+    const input = parseToolArgs(args);
+    return {
+      input,
+      call: (context) => this.agent.callTool(toolName, args, context)
+    };
+  }
+  async handleToolError(toolCall, hookArgs, args, error, toolObservation, observation) {
+    const errorAction = await this.activeHook?.onToolError?.({
+      ...hookArgs,
+      args,
+      error,
+      run: runControl
+    });
+    await toolObservation.error(
+      toolErrorArgs(observation?.turn ?? 0, toolCall, hookArgs.internalCallId, args, error)
+    );
+    if (errorAction?.type === "terminate") {
+      throw this.cancel(errorAction.reason);
+    }
+    return {
+      output: {
+        type: "error-text",
+        value: error instanceof Error ? error.toString() : String(error)
+      },
+      failed: true,
+      error
+    };
+  }
+  async runToolResultMiddlewares(args) {
+    let result = args.result;
+    let structuredResult = args.structuredResult;
+    let replaced = false;
+    for (const middleware of this.activeMiddlewares()) {
+      const outputReplacement = await middleware.onToolOutput?.({
+        ...args,
+        result,
+        structuredResult
+      });
+      if (outputReplacement !== void 0) {
+        const normalized = normalizeToolOutputMiddlewareResult(outputReplacement);
+        if (normalized.result !== void 0) {
+          result = normalized.result;
+          structuredResult = void 0;
+        }
+        if (normalized.structuredResult !== void 0) {
+          structuredResult = normalized.structuredResult;
+          result = toolResultContentToText(normalized.structuredResult);
+        }
+        replaced = true;
+      }
+    }
+    return replaced ? structuredResult === void 0 ? { type: "text", value: result } : { type: "content", value: structuredResult } : void 0;
+  }
+  async runToolInputMiddlewares(args) {
+    let current = args.args;
+    for (const middleware of this.activeMiddlewares()) {
+      const replacement = await middleware.onToolInput?.({
+        ...args,
+        args: current
+      });
+      if (replacement?.args !== void 0) {
+        if (typeof replacement.args === "string") {
+          current = replacement.args;
+        } else {
+          if (!isJsonValue(replacement.args)) {
+            throw new TypeError("Tool input middleware args must be a strict JSON value.");
+          }
+          current = JSON.stringify(replacement.args);
+        }
+      }
+    }
+    return current;
+  }
+  activeMiddlewares() {
+    return [...this.agent.middlewares, ...this.requestMiddlewares];
+  }
+  async evaluateToolApproval(tool, context, observation) {
+    const requirement = tool?.requiresApproval;
+    if (requirement === void 0) return void 0;
+    const resolved = typeof requirement === "function" ? await requirement(context.args, context) : requirement;
+    assertToolApprovalRequirement(resolved, { allowFunction: false });
+    if (resolved === false) return { approved: true };
+    const reason = resolved === true ? void 0 : resolved.reason;
+    return this.requestApproval(context, reason === void 0 ? {} : { reason }, observation);
+  }
+  async requestApproval(context, options, observation) {
+    const request = {
+      ...context,
+      id: globalThis.crypto.randomUUID()
+    };
+    if (options.reason !== void 0) {
+      request.reason = options.reason;
+    }
+    if (options.rejectMessage !== void 0) {
+      request.rejectMessage = options.rejectMessage;
+    }
+    await observation?.runObservers.event({
+      name: "tool.approval_requested",
+      attributes: approvalEventAttributes(request, observation.turn)
+    });
+    let decision;
+    try {
+      decision = await this.approvalHandler(request);
+    } catch (error) {
+      if (error instanceof AgentInteractionSignal) {
+        throw error;
+      }
+      await observation?.runObservers.event({
+        name: "tool.approval_failed",
+        level: "ERROR",
+        attributes: {
+          ...approvalEventAttributes(request, observation.turn),
+          errorName: error instanceof Error ? error.name : typeof error
+        }
+      });
+      throw error;
+    }
+    const attributes = {
+      ...approvalEventAttributes(request, observation?.turn ?? 0),
+      approved: decision.approved
+    };
+    if (decision.reason !== void 0) attributes.decisionReason = decision.reason;
+    await observation?.runObservers.event({
+      name: "tool.approval_resolved",
+      attributes
+    });
+    if (decision.approved) {
+      return { approved: true };
+    }
+    return {
+      approved: false,
+      result: decision.reason ?? request.rejectMessage ?? "Tool approval was rejected."
+    };
+  }
+};
+function createApprovalContext(input, hookArgs, agent, run) {
+  const approvalRun = {
+    agentId: agent.id,
+    runId: run.runId
+  };
+  if (run.sessionId !== void 0) {
+    approvalRun.sessionId = run.sessionId;
+  }
+  if (run.metadata !== void 0) {
+    approvalRun.metadata = run.metadata;
+  }
+  const context = {
+    toolName: hookArgs.toolName,
+    args: lifecycleSnapshot(input),
+    rawArgs: hookArgs.args,
+    toolCallId: hookArgs.toolCallId,
+    internalCallId: hookArgs.internalCallId,
+    run: approvalRun
+  };
+  if (hookArgs.callId !== void 0) {
+    context.callId = hookArgs.callId;
+  }
+  return context;
+}
+function approvalEventAttributes(request, turn) {
+  const attributes = {
+    turn,
+    approvalId: request.id,
+    toolName: request.toolName,
+    internalCallId: request.internalCallId
+  };
+  if (request.toolCallId !== void 0) attributes.toolCallId = request.toolCallId;
+  if (request.reason !== void 0) attributes.reason = request.reason;
+  return attributes;
+}
+function normalizeToolOutputMiddlewareResult(result) {
+  if (typeof result === "string") {
+    return { result };
+  }
+  if (typeof result !== "object" || result === null) {
+    throw new TypeError("Tool output middleware must return text or structured content.");
+  }
+  const prototype = Object.getPrototypeOf(result);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new TypeError("Tool output middleware must return text or structured content.");
+  }
+  const keys = Reflect.ownKeys(result);
+  const hasResult = keys.includes("result");
+  const hasStructuredResult = keys.includes("structuredResult");
+  if (hasResult === hasStructuredResult || keys.some((key) => key !== "result" && key !== "structuredResult")) {
+    throw new TypeError(
+      "Tool output middleware must return exactly one of result or structuredResult."
+    );
+  }
+  if (hasResult) {
+    const descriptor2 = Object.getOwnPropertyDescriptor(result, "result");
+    if (descriptor2 === void 0 || !("value" in descriptor2) || typeof descriptor2.value !== "string") {
+      throw new TypeError("Tool output middleware result must be a string.");
+    }
+    return { result: descriptor2.value };
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(result, "structuredResult");
+  if (descriptor === void 0 || !("value" in descriptor)) {
+    throw new TypeError("Tool output middleware structuredResult must be valid tool content.");
+  }
+  const normalized = normalizeToolResultOutput(ToolOutput.content(descriptor.value));
+  if (normalized.type !== "content") {
+    throw new TypeError("Tool output middleware structuredResult must be valid tool content.");
+  }
+  return { structuredResult: normalized.value };
+}
+function toolTraceMetadata(tool) {
+  if (tool === void 0) {
+    return void 0;
+  }
+  const result = {
+    approvalRequired: toolMayRequireApproval(tool.requiresApproval)
+  };
+  if (isMcpTool(tool)) {
+    result.mcpServerName = tool.mcp.serverName;
+    result.mcpRemoteName = tool.mcp.remoteName;
+  }
+  return result;
+}
+function toolErrorArgs(turn, toolCall, internalCallId, args, error) {
+  let observerArgs = {
+    turn,
+    toolCall,
+    toolName: toolCall.toolName,
+    internalCallId,
+    args,
+    error
+  };
+  if (toolCall.callId !== void 0) {
+    observerArgs = { ...observerArgs, toolCallId: toolCall.callId };
+  }
+  return observerArgs;
+}
+var ToolObserverScope = class {
+  constructor(observers) {
+    this.observers = observers;
+  }
+  observers;
+  terminal = false;
+  streamEvent(args) {
+    return this.observers?.streamEvent(args);
+  }
+  async end(args) {
+    if (this.terminal) return;
+    this.terminal = true;
+    await this.observers?.end(args);
+  }
+  async suspend(args) {
+    if (this.terminal) return;
+    this.terminal = true;
+    await this.observers?.suspend(args);
+  }
+  async error(args) {
+    if (this.terminal) return;
+    this.terminal = true;
+    await this.observers?.error(args);
+  }
+};
+function toolOutputToText(output) {
+  switch (output.type) {
+    case "text":
+    case "error-text":
+      return output.value;
+    case "json":
+    case "error-json":
+      return JSON.stringify(output.value);
+    case "content":
+      return toolResultContentToText(output.value);
+    case "execution-denied":
+      return output.reason ?? "Tool execution was denied.";
+  }
+}
+function toolOutputToStructuredResult(output) {
+  return output.type === "content" ? output.value : void 0;
+}
+function agentToolEventPayload(toolCall, internalCallId, event) {
+  if (typeof event.agentId !== "string" || event.agentId.length === 0) {
+    return void 0;
+  }
+  const payload = {
+    type: "agent_tool_event",
+    toolName: toolCall.toolName,
+    internalCallId,
+    agentId: event.agentId,
+    event: event.event
+  };
+  if (toolCall.callId !== void 0) {
+    payload.toolCallId = toolCall.callId;
+  }
+  if (event.agentName !== void 0) {
+    payload.agentName = event.agentName;
+  }
+  return payload;
+}
+
+export {
+  ToolCallExecutor
+};
+//# sourceMappingURL=chunk-J4SINPUA.js.map