@anvia/core 0.4.2 → 0.6.0

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

@@ -7,10 +7,10 @@ import {
 import {
   ToolSet,
   toolResultContentToText
-} from "./chunk-35GF7P43.js";
+} from "./chunk-AER5FGPK.js";
 import {
   createTool
-} from "./chunk-P425B6GR.js";
+} from "./chunk-I47EHI45.js";
 import {
   CompletionRequestBuilder,
   Message,
@@ -18,7 +18,7 @@ import {
   Usage,
   assertCompletionRequestSupported,
   textFromAssistantContent
-} from "./chunk-6GJDBBDC.js";
+} from "./chunk-A4GUJSEK.js";
 import {
   mapWithConcurrency
 } from "./chunk-OIMLU4SF.js";
@@ -745,17 +745,17 @@ 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, requestToolMiddlewares, cancel) {
+  constructor(agent, activeHook, concurrency, requestMiddlewares, cancel) {
     this.agent = agent;
     this.activeHook = activeHook;
     this.concurrency = concurrency;
-    this.requestToolMiddlewares = requestToolMiddlewares;
+    this.requestMiddlewares = requestMiddlewares;
     this.cancel = cancel;
   }
   agent;
   activeHook;
   concurrency;
-  requestToolMiddlewares;
+  requestMiddlewares;
   cancel;
   async execute(toolCalls, onResult, onStreamEvent, observation) {
     return mapWithConcurrency(toolCalls, this.concurrency, async (toolCall) => {
@@ -813,19 +813,25 @@ var ToolCallExecutor = class {
       }
       let output;
       let skipped = false;
+      let effectiveArgs = args;
       if (callAction?.type === "skip") {
         output = callAction.reason;
         skipped = true;
       } else {
+        effectiveArgs = await this.runToolInputMiddlewares({
+          ...hookArgs,
+          turn: observation?.turn ?? 0,
+          originalArgs: args
+        });
         try {
-          output = await this.agent.callTool(toolCall.function.name, args, {
+          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,
+                args: effectiveArgs,
                 ...toolCall.callId === void 0 ? {} : { toolCallId: toolCall.callId },
                 event
               });
@@ -836,6 +842,24 @@ var ToolCallExecutor = class {
             }
           });
         } 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);
         }
       }
@@ -844,6 +868,7 @@ var ToolCallExecutor = class {
       if (this.agent.shouldApplyToolMiddleware(toolCall.function.name)) {
         const middlewareReplacement = await this.runToolResultMiddlewares({
           ...hookArgs,
+          args: effectiveArgs,
           result,
           originalResult: result,
           structuredResult,
@@ -852,12 +877,13 @@ var ToolCallExecutor = class {
         });
         if (middlewareReplacement !== void 0) {
           output = middlewareReplacement;
-          result = middlewareReplacement;
-          structuredResult = void 0;
+          result = toolOutputToText(middlewareReplacement);
+          structuredResult = toolOutputToStructuredResult(middlewareReplacement);
         }
       }
       const resultAction = await this.activeHook?.onToolResult?.({
         ...hookArgs,
+        args: effectiveArgs,
         result,
         structuredResult,
         run: runControl
@@ -867,7 +893,7 @@ var ToolCallExecutor = class {
         toolCall,
         toolName: toolCall.function.name,
         internalCallId,
-        args,
+        args: effectiveArgs,
         result,
         structuredResult,
         skipped,
@@ -880,7 +906,7 @@ var ToolCallExecutor = class {
         type: "tool_result",
         toolName: toolCall.function.name,
         internalCallId,
-        args,
+        args: effectiveArgs,
         result,
         structuredResult
       };
@@ -893,20 +919,62 @@ var ToolCallExecutor = class {
   }
   async runToolResultMiddlewares(args) {
     let result = args.result;
+    let structuredResult = args.structuredResult;
     let replaced = false;
-    for (const middleware of [...this.agent.toolMiddlewares, ...this.requestToolMiddlewares]) {
-      const replacement = await middleware.onResult?.({
+    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;
+      }
+      const legacyReplacement = await middleware.onResult?.({
         ...args,
-        result
+        result,
+        structuredResult
       });
-      if (replacement !== void 0) {
-        result = replacement;
+      if (legacyReplacement !== void 0) {
+        result = legacyReplacement;
+        structuredResult = void 0;
         replaced = true;
       }
     }
-    return replaced ? result : void 0;
+    return replaced ? structuredResult ?? result : 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) {
+        current = typeof replacement.args === "string" ? replacement.args : JSON.stringify(replacement.args);
+      }
+    }
+    return current;
+  }
+  activeMiddlewares() {
+    return [...this.agent.middlewares, ...this.requestMiddlewares];
   }
 };
+function normalizeToolOutputMiddlewareResult(result) {
+  if (typeof result === "string") {
+    return { result };
+  }
+  return result ?? {};
+}
 function toolTraceMetadata(tool) {
   if (tool === void 0) {
     return void 0;
@@ -967,7 +1035,7 @@ var PromptRequest = class _PromptRequest {
   activeHook;
   concurrency = 1;
   traceOptions;
-  requestToolMiddlewares = [];
+  requestMiddlewares = [];
   memoryRecorder;
   static fromAgent(agent, prompt, options = {}) {
     const normalized = normalizePromptInput(prompt);
@@ -977,22 +1045,40 @@ var PromptRequest = class _PromptRequest {
     this.maxTurnCount = maxTurns;
     return this;
   }
-  requestHook(hook) {
+  withHook(hook) {
     this.activeHook = hook;
     return this;
   }
+  /**
+   * @deprecated Use `withHook` instead.
+   */
+  requestHook(hook) {
+    return this.withHook(hook);
+  }
   withToolConcurrency(concurrency) {
     this.concurrency = Math.max(1, concurrency);
     return this;
   }
-  withToolMiddleware(middleware) {
-    this.requestToolMiddlewares.push(middleware);
+  withMiddleware(middleware) {
+    this.requestMiddlewares.push(middleware);
     return this;
   }
-  withToolMiddlewares(middlewares) {
-    this.requestToolMiddlewares.push(...middlewares);
+  withMiddlewares(middlewares) {
+    this.requestMiddlewares.push(...middlewares);
     return this;
   }
+  /**
+   * @deprecated Use `withMiddleware` instead.
+   */
+  withToolMiddleware(middleware) {
+    return this.withMiddleware(middleware);
+  }
+  /**
+   * @deprecated Use `withMiddlewares` instead.
+   */
+  withToolMiddlewares(middlewares) {
+    return this.withMiddlewares(middlewares);
+  }
   withTrace(trace) {
     this.traceOptions = trace;
     return this;
@@ -1007,6 +1093,7 @@ var PromptRequest = class _PromptRequest {
     let lastPrompt = this.promptMessage;
     const runObservers = await this.startRunObservers();
     try {
+      await this.runRunStartHook(newMessages);
       while (currentTurns <= this.maxTurnCount + 1) {
         const prompt = newMessages.at(-1);
         if (prompt === void 0) {
@@ -1015,14 +1102,24 @@ var PromptRequest = class _PromptRequest {
         lastPrompt = prompt;
         currentTurns += 1;
         const historyForRequest = [...this.chatHistory, ...newMessages.slice(0, -1)];
+        await this.runTurnStartHook(currentTurns, prompt, historyForRequest, newMessages);
         await this.runCompletionCallHook(prompt, historyForRequest, newMessages);
         const ragText = extractRagText(prompt);
         const dynamicContext = await fetchDynamicContext(this.agent, ragText);
         const toolDefs = await fetchToolDefinitions(this.agent, ragText);
-        const request = new CompletionRequestBuilder(this.agent.model, prompt).instructions(this.agent.instructions).messages(historyForRequest).documents([...this.agent.staticContext, ...dynamicContext]).tools(toolDefs).temperature(this.agent.temperature).maxTokens(this.agent.maxTokens).additionalParams(this.agent.additionalParams).toolChoice(this.agent.toolChoice).outputSchema(this.agent.outputSchema).build();
-        const response = await this.runCompletion(request, currentTurns, runObservers);
+        let 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();
+        request = await this.runCompletionRequestMiddlewares(request, currentTurns);
+        let response;
+        try {
+          response = await this.runCompletion(request, currentTurns, runObservers);
+        } catch (error) {
+          await this.runCompletionErrorHook(prompt, error, newMessages);
+          throw error;
+        }
+        response = await this.runCompletionResponseMiddlewares(request, response, currentTurns);
         usage = Usage.add(usage, response.usage);
         await this.runCompletionResponseHook(prompt, response, newMessages);
+        await this.runTurnEndHook(currentTurns, response, newMessages);
         const assistantMessage = Message.assistant(response.choice, response.messageId);
         newMessages.push(assistantMessage);
         await this.memoryRecorder.commitMessages(
@@ -1047,6 +1144,7 @@ var PromptRequest = class _PromptRequest {
             messages: [...newMessages],
             trace: runObservers.trace
           };
+          await this.runRunEndHook(result, newMessages);
           await runObservers.end(result);
           return result;
         }
@@ -1073,9 +1171,10 @@ var PromptRequest = class _PromptRequest {
       }
       throw new MaxTurnsError(this.maxTurnCount, [...this.chatHistory, ...newMessages], lastPrompt);
     } catch (error) {
-      await runObservers.error({ error, usage, messages: [...newMessages] });
-      await this.memoryRecorder.recordError(runId, error, newMessages);
-      throw error;
+      const finalError = await this.runRunErrorHook(error, usage, newMessages);
+      await runObservers.error({ error: finalError, usage, messages: [...newMessages] });
+      await this.memoryRecorder.recordError(runId, finalError, newMessages);
+      throw finalError;
     }
   }
   async *stream() {
@@ -1095,6 +1194,7 @@ var PromptRequest = class _PromptRequest {
       return event;
     };
     try {
+      await this.runRunStartHook(newMessages);
       while (currentTurns <= this.maxTurnCount + 1) {
         const prompt = newMessages.at(-1);
         if (prompt === void 0) {
@@ -1109,11 +1209,13 @@ var PromptRequest = class _PromptRequest {
           prompt,
           history: historyForRequest
         });
+        await this.runTurnStartHook(currentTurns, prompt, historyForRequest, newMessages);
         await this.runCompletionCallHook(prompt, historyForRequest, newMessages);
         const ragText = extractRagText(prompt);
         const dynamicContext = await fetchDynamicContext(this.agent, ragText);
         const toolDefs = await fetchToolDefinitions(this.agent, ragText);
-        const request = new CompletionRequestBuilder(this.agent.model, prompt).instructions(this.agent.instructions).messages(historyForRequest).documents([...this.agent.staticContext, ...dynamicContext]).tools(toolDefs).temperature(this.agent.temperature).maxTokens(this.agent.maxTokens).additionalParams(this.agent.additionalParams).toolChoice(this.agent.toolChoice).outputSchema(this.agent.outputSchema).build();
+        let 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();
+        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({
@@ -1144,16 +1246,19 @@ var PromptRequest = class _PromptRequest {
           }
         } catch (error) {
           await generationObservers.error({ turn: currentTurns, error });
+          await this.runCompletionErrorHook(prompt, error, newMessages);
           throw error;
         }
-        const response = accumulator.response();
+        let response = accumulator.response();
         await generationObservers.end({
           turn: currentTurns,
           response,
           ...firstDeltaMs === void 0 ? {} : { firstDeltaMs }
         });
+        response = await this.runCompletionResponseMiddlewares(request, response, currentTurns);
         usage = Usage.add(usage, response.usage);
         await this.runCompletionResponseHook(prompt, response, newMessages);
+        await this.runTurnEndHook(currentTurns, response, newMessages);
         const assistantMessage = Message.assistant(response.choice, response.messageId);
         newMessages.push(assistantMessage);
         await this.memoryRecorder.commitMessages(
@@ -1185,6 +1290,7 @@ var PromptRequest = class _PromptRequest {
             messages: [...newMessages],
             trace: runObservers.trace
           });
+          await this.runRunEndHook({ output, usage, messages: [...newMessages] }, newMessages);
           await runObservers.end({ output, usage, messages: [...newMessages] });
           return;
         }
@@ -1224,10 +1330,11 @@ var PromptRequest = class _PromptRequest {
       }
       throw new MaxTurnsError(this.maxTurnCount, [...this.chatHistory, ...newMessages], lastPrompt);
     } catch (error) {
-      await runObservers.error({ error, usage, messages: [...newMessages] });
-      await this.memoryRecorder.recordError(runId, error, newMessages);
-      yield await emit({ type: "error", error });
-      throw error;
+      const finalError = await this.runRunErrorHook(error, usage, newMessages);
+      await runObservers.error({ error: finalError, usage, messages: [...newMessages] });
+      await this.memoryRecorder.recordError(runId, finalError, newMessages);
+      yield await emit({ type: "error", error: finalError });
+      throw finalError;
     }
   }
   readableStream() {
@@ -1269,7 +1376,7 @@ var PromptRequest = class _PromptRequest {
       this.agent,
       this.activeHook,
       this.concurrency,
-      this.requestToolMiddlewares,
+      this.requestMiddlewares,
       (reason) => this.cancelled(newMessages, reason)
     );
     return executor.execute(toolCalls, onResult, onStreamEvent, observation);
@@ -1324,6 +1431,90 @@ var PromptRequest = class _PromptRequest {
       throw this.cancelled(newMessages, action.reason);
     }
   }
+  async runRunStartHook(newMessages) {
+    const action = await this.activeHook?.onRunStart?.({
+      prompt: this.promptMessage,
+      history: this.chatHistory,
+      maxTurns: this.maxTurnCount,
+      run: runControl
+    });
+    if (action?.type === "terminate") {
+      throw this.cancelled(newMessages, action.reason);
+    }
+  }
+  async runRunEndHook(result, newMessages) {
+    const action = await this.activeHook?.onRunEnd?.({
+      output: result.output,
+      usage: result.usage,
+      messages: result.messages,
+      run: runControl
+    });
+    if (action?.type === "terminate") {
+      throw this.cancelled(newMessages, action.reason);
+    }
+  }
+  async runRunErrorHook(error, usage, newMessages) {
+    const action = await this.activeHook?.onRunError?.({
+      error,
+      usage,
+      messages: [...this.chatHistory, ...newMessages],
+      run: runControl
+    });
+    if (action?.type === "terminate") {
+      return this.cancelled(newMessages, action.reason);
+    }
+    return error;
+  }
+  async runTurnStartHook(turn, prompt, history, newMessages) {
+    const action = await this.activeHook?.onTurnStart?.({
+      turn,
+      prompt,
+      history,
+      run: runControl
+    });
+    if (action?.type === "terminate") {
+      throw this.cancelled(newMessages, action.reason);
+    }
+  }
+  async runTurnEndHook(turn, response, newMessages) {
+    const action = await this.activeHook?.onTurnEnd?.({
+      turn,
+      response,
+      run: runControl
+    });
+    if (action?.type === "terminate") {
+      throw this.cancelled(newMessages, action.reason);
+    }
+  }
+  async runCompletionRequestMiddlewares(request, turn) {
+    let current = request;
+    for (const middleware of this.activeMiddlewares()) {
+      const replacement = await middleware.onCompletionRequest?.({
+        turn,
+        request: current,
+        originalRequest: request
+      });
+      if (replacement?.request !== void 0) {
+        current = replacement.request;
+      }
+    }
+    return current;
+  }
+  async runCompletionResponseMiddlewares(request, response, turn) {
+    let current = response;
+    for (const middleware of this.activeMiddlewares()) {
+      const replacement = await middleware.onCompletionResponse?.({
+        turn,
+        request,
+        response: current,
+        originalResponse: response
+      });
+      if (replacement?.response !== void 0) {
+        current = replacement.response;
+      }
+    }
+    return current;
+  }
   async runCompletionResponseHook(prompt, response, newMessages) {
     const action = await this.activeHook?.onCompletionResponse?.({
       prompt,
@@ -1334,6 +1525,19 @@ var PromptRequest = class _PromptRequest {
       throw this.cancelled(newMessages, action.reason);
     }
   }
+  async runCompletionErrorHook(prompt, error, newMessages) {
+    const action = await this.activeHook?.onCompletionError?.({
+      prompt,
+      error,
+      run: runControl
+    });
+    if (action?.type === "terminate") {
+      throw this.cancelled(newMessages, action.reason);
+    }
+  }
+  activeMiddlewares() {
+    return [...this.agent.middlewares, ...this.requestMiddlewares];
+  }
   cancelled(newMessages, reason) {
     return new PromptCancelledError([...this.chatHistory, ...newMessages], reason);
   }
@@ -1394,6 +1598,10 @@ var Agent = class {
   observers;
   dynamicContexts;
   dynamicTools;
+  middlewares;
+  /**
+   * @deprecated Use `middlewares` instead.
+   */
   toolMiddlewares;
   memory;
   eventStore;
@@ -1415,7 +1623,8 @@ var Agent = class {
     this.observers = options.observers ?? [];
     this.dynamicContexts = options.dynamicContexts ?? [];
     this.dynamicTools = options.dynamicTools ?? [];
-    this.toolMiddlewares = options.toolMiddlewares ?? [];
+    this.middlewares = options.middlewares ?? options.toolMiddlewares ?? [];
+    this.toolMiddlewares = this.middlewares;
     this.memory = options.memory;
     this.eventStore = options.eventStore;
   }
@@ -1543,4 +1752,4 @@ export {
   Agent,
   AgentSession
 };
-//# sourceMappingURL=chunk-N7NMSGZI.js.map
+//# sourceMappingURL=chunk-IXK3TEHJ.js.map