@anvia/core 0.6.2 → 0.7.0

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

@@ -6,19 +6,26 @@ import {
 } from "./chunk-YK4WAAS4.js";
 import {
   ToolSet,
+  parseToolArgs,
   toolResultContentToText
-} from "./chunk-AER5FGPK.js";
+} from "./chunk-IA47SXLS.js";
 import {
   createTool
-} from "./chunk-I47EHI45.js";
+} from "./chunk-66IJDP6L.js";
+import {
+  compact
+} from "./chunk-MMHG7WAM.js";
 import {
   CompletionRequestBuilder,
+  isStreamingCompletionModel
+} from "./chunk-S5IGJ4RB.js";
+import {
   Message,
   ToolContent,
   Usage,
   assertCompletionRequestSupported,
   textFromAssistantContent
-} from "./chunk-ZQQYFVO5.js";
+} from "./chunk-WJO6NVE2.js";
 import {
   mapWithConcurrency
 } from "./chunk-OIMLU4SF.js";
@@ -46,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) {
@@ -58,11 +73,11 @@ function skipTool(reason) {
   return { type: "skip", reason };
 }
 function requestToolApproval(options = {}) {
-  return {
+  return compact({
     type: "approval_request",
-    ...options.reason === void 0 ? {} : { reason: options.reason },
-    ...options.rejectMessage === void 0 ? {} : { rejectMessage: options.rejectMessage }
-  };
+    reason: options.reason,
+    rejectMessage: options.rejectMessage
+  });
 }
 var runControl = {
   continue() {
@@ -430,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) {
@@ -449,11 +482,11 @@ async function fetchDynamicContext(agent, ragText) {
         documents.push(formatted);
       } else {
         const metadata = formatMetadata(result.metadata);
-        documents.push({
+        documents.push(compact({
           id: result.id,
           text: typeof result.document === "string" ? result.document : JSON.stringify(result.document, null, 2),
-          ...metadata === void 0 ? {} : { additionalProps: metadata }
-        });
+          additionalProps: metadata
+        }));
       }
     }
   }
@@ -491,9 +524,6 @@ function formatMetadata(metadata) {
 }
 
 // src/agent/utils.ts
-function isStreamingCompletionModel(model) {
-  return "streamCompletion" in model && typeof model.streamCompletion === "function";
-}
 function extractRagText(message) {
   if (message.role === "user") {
     return message.content.flatMap((item) => item.type === "text" ? [item.text] : []).join("\n");
@@ -745,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;
@@ -774,16 +808,18 @@ var ToolCallExecutor = class {
         (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 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
@@ -799,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;
@@ -818,49 +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({
-                turn: observation?.turn ?? 0,
-                toolCall,
-                toolName: toolCall.function.name,
-                internalCallId,
-                args: effectiveArgs,
-                ...toolCall.callId === void 0 ? {} : { 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);
@@ -968,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 };
@@ -1007,15 +1110,15 @@ function agentToolEventPayload(toolCall, internalCallId, event) {
   if (typeof event.agentId !== "string" || event.agentId.length === 0) {
     return void 0;
   }
-  return {
+  return compact({
     type: "agent_tool_event",
     toolName: toolCall.function.name,
-    ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId },
+    toolCallId: toolCall.callId,
     internalCallId,
     agentId: event.agentId,
-    ...event.agentName === void 0 ? {} : { agentName: event.agentName },
+    agentName: event.agentName,
     event: event.event
-  };
+  });
 }
 
 // src/agent/request.ts
@@ -1023,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 = [];
@@ -1051,6 +1158,10 @@ var PromptRequest = class _PromptRequest {
     this.activeHook = hook;
     return this;
   }
+  approvals(options) {
+    this.approvalOptions = options;
+    return this;
+  }
   /**
    * @deprecated Use `withHook` instead.
    */
@@ -1164,6 +1275,7 @@ var PromptRequest = class _PromptRequest {
           return result;
         }
         const toolResults = await this.executeToolCalls(
+          runId,
           toolCalls,
           newMessages,
           void 0,
@@ -1236,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({
-          turn: currentTurns,
-          request,
-          ...providerRequest === void 0 ? {} : { 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;
@@ -1268,11 +1382,13 @@ var PromptRequest = class _PromptRequest {
           throw error;
         }
         let response = accumulator.response();
-        await generationObservers.end({
-          turn: currentTurns,
-          response,
-          ...firstDeltaMs === void 0 ? {} : { 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);
@@ -1319,6 +1435,7 @@ var PromptRequest = class _PromptRequest {
         }
         const toolResultEvents = createAsyncQueue();
         const toolResultsPromise = this.executeToolCalls(
+          runId,
           toolCalls,
           newMessages,
           (result) => {
@@ -1368,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({
-      turn,
-      request,
-      ...providerRequest === void 0 ? {} : { 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 });
@@ -1396,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)
@@ -1436,13 +1561,12 @@ var PromptRequest = class _PromptRequest {
     await registration.store.append({
       runId,
       agentId,
-      ...agentName === void 0 ? {} : { agentName },
-      ...turn === void 0 ? {} : { turn },
-      ...event.type === "agent_tool_event" ? {
+      ...compact({ agentName, turn }),
+      ...event.type === "agent_tool_event" ? compact({
         toolName: event.toolName,
-        ...event.toolCallId === void 0 ? {} : { toolCallId: event.toolCallId },
+        toolCallId: event.toolCallId,
         internalCallId: event.internalCallId
-      } : {},
+      }) : {},
       event
     });
   }
@@ -1609,22 +1733,6 @@ function normalizeSteeringInput(input) {
   }
   return Array.isArray(input) ? [...input] : [input];
 }
-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/agent.ts
 var DEFAULT_MAX_TURNS = 20;
@@ -1644,6 +1752,7 @@ var Agent = class {
   hook;
   outputSchema;
   observers;
+  approvals;
   dynamicContexts;
   dynamicTools;
   middlewares;
@@ -1669,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 ?? [];
@@ -1689,8 +1799,8 @@ var Agent = class {
     }
     return new AgentSession(this, {
       sessionId: normalized,
-      ...options.userId === void 0 ? {} : { userId: options.userId },
-      ...options.metadata === void 0 ? {} : { metadata: options.metadata }
+      ...options.userId !== void 0 && { userId: options.userId },
+      ...options.metadata !== void 0 && { metadata: options.metadata }
     });
   }
   asTool(options) {
@@ -1708,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({
-              agentId: this.id,
-              ...this.name === void 0 ? {} : { agentName: this.name },
-              event
-            });
+            await context.emitStreamEvent(
+              compact({
+                agentId: this.id,
+                agentName: this.name,
+                event
+              })
+            );
             if (event.type === "final") {
               output = event.output;
             }
@@ -1790,14 +1902,16 @@ export {
   normalizeAgentId,
   MaxTurnsError,
   PromptCancelledError,
+  ToolApprovalRequiredError,
   createHook,
   cancelPrompt,
   skipTool,
   requestToolApproval,
   runControl,
   toolCallControl,
+  extractRagText,
   DEFAULT_MAX_TURNS,
   Agent,
   AgentSession
 };
-//# sourceMappingURL=chunk-SWG6AORE.js.map
+//# sourceMappingURL=chunk-6OR42QTG.js.map