@anvia/core 0.11.3 → 0.12.1

package/dist/{chunk-7CQAERL3.js → chunk-CO7YK4JZ.js}

@@ -4,7 +4,14 @@ import {
 import {
   parseToolArgs,
   toolResultContentToText
-} from "./chunk-FV5B4SGK.js";
+} from "./chunk-GISFLLNL.js";
+import {
+  runControl,
+  toolCallControl
+} from "./chunk-NPZDYOE6.js";
+import {
+  compact
+} from "./chunk-MMHG7WAM.js";
 import {
   mapWithConcurrency
 } from "./chunk-OIMLU4SF.js";
@@ -13,6 +20,7 @@ import {
   isStreamingCompletionModel
 } from "./chunk-SRBW3LD7.js";
 import {
+  AssistantContent,
   Message,
   ToolContent,
   Usage,
@@ -20,12 +28,11 @@ import {
   textFromAssistantContent
 } from "./chunk-5LFGEMIW.js";
 import {
-  runControl,
-  toolCallControl
-} from "./chunk-NPZDYOE6.js";
-import {
-  compact
-} from "./chunk-MMHG7WAM.js";
+  appendGuardrailPolicies,
+  hasEnforcedOutputGuardrails,
+  runInputGuardrails,
+  runOutputGuardrails
+} from "./chunk-CWUJUSOS.js";
 
 // src/request/errors.ts
 var MaxTurnsError = class extends Error {
@@ -585,6 +592,9 @@ var ToolCallExecutor = class {
           toolMetadata
         })
       );
+      let output;
+      let skipped = false;
+      let effectiveArgs = args;
       const callAction = await this.activeHook?.onToolCall?.({
         ...hookArgs,
         tool: toolCallControl
@@ -595,14 +605,11 @@ var ToolCallExecutor = class {
           observation?.turn,
           toolCall,
           internalCallId,
-          args,
+          effectiveArgs,
           callAction.reason
         );
         throw this.cancel(callAction.reason);
       }
-      let output;
-      let skipped = false;
-      let effectiveArgs = args;
       if (callAction?.type === "skip") {
         output = callAction.reason;
         skipped = true;
@@ -614,8 +621,24 @@ var ToolCallExecutor = class {
             turn: observation?.turn ?? 0,
             originalArgs: args
           });
-          const effectiveHookArgs = { ...hookArgs, args: effectiveArgs };
-          approvalDecision = callAction?.type === "approval_request" ? await this.requestApproval(tool, effectiveHookArgs, callAction) : await this.evaluateToolApproval(tool, effectiveHookArgs) ?? { approved: true };
+          hookArgs.args = effectiveArgs;
+          approvalDecision = callAction?.type === "approval_request" ? await this.requestApproval(tool, hookArgs, callAction) : await this.evaluateToolApproval(tool, hookArgs) ?? { approved: true };
+          if (!approvalDecision.approved) {
+            output = approvalDecision.result;
+            skipped = true;
+          } else {
+            output = await this.runApprovedToolCall(
+              toolCall,
+              hookArgs,
+              effectiveArgs,
+              args,
+              toolObservers,
+              observation,
+              onStreamEvent,
+              false
+            );
+            effectiveArgs = hookArgs.args;
+          }
         } catch (error) {
           await recordToolError(
             toolObservers,
@@ -627,52 +650,6 @@ var ToolCallExecutor = class {
           );
           throw error;
         }
-        if (!approvalDecision.approved) {
-          output = approvalDecision.result;
-          skipped = true;
-        } else {
-          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);
-          }
-        }
       }
       let result = toolOutputToText(output);
       let structuredResult = toolOutputToStructuredResult(output);
@@ -728,6 +705,56 @@ var ToolCallExecutor = class {
       return ToolContent.toolResult(toolCall.id, output, toolCall.callId);
     });
   }
+  async runApprovedToolCall(toolCall, hookArgs, effectiveArgs, originalArgs, toolObservers, observation, onStreamEvent, applyInputMiddleware = true) {
+    const middlewareArgs = applyInputMiddleware ? await this.runToolInputMiddlewares({
+      ...hookArgs,
+      args: effectiveArgs,
+      turn: observation?.turn ?? 0,
+      originalArgs
+    }) : effectiveArgs;
+    hookArgs.args = middlewareArgs;
+    try {
+      return await this.agent.callTool(toolCall.function.name, middlewareArgs, {
+        emitStreamEvent: async (event) => {
+          await toolObservers?.streamEvent(
+            compact({
+              turn: observation?.turn ?? 0,
+              toolCall,
+              toolName: toolCall.function.name,
+              internalCallId: hookArgs.internalCallId,
+              args: middlewareArgs,
+              toolCallId: toolCall.callId,
+              event
+            })
+          );
+          const payload = agentToolEventPayload(toolCall, hookArgs.internalCallId, event);
+          if (payload !== void 0) {
+            onStreamEvent?.(payload);
+          }
+        }
+      });
+    } catch (error) {
+      const errorAction = await this.activeHook?.onToolError?.({
+        ...hookArgs,
+        args: middlewareArgs,
+        error,
+        run: runControl
+      });
+      await toolObservers?.error({
+        turn: observation?.turn ?? 0,
+        toolCall,
+        toolName: toolCall.function.name,
+        internalCallId: hookArgs.internalCallId,
+        args: middlewareArgs,
+        ...toolCall.callId !== void 0 && { toolCallId: toolCall.callId },
+        error
+      });
+      if (errorAction?.type === "terminate") {
+        throw this.cancel(errorAction.reason);
+      }
+      return error instanceof Error ? error.toString() : String(error);
+    }
+  }
   async runToolResultMiddlewares(args) {
     let result = args.result;
     let structuredResult = args.structuredResult;
@@ -1100,6 +1127,7 @@ var PromptRequest = class _PromptRequest {
     this.maxTurnCount = agent.defaultMaxTurns ?? 0;
     this.activeHook = agent.hook;
     this.approvalOptions = agent.approvals;
+    this.guardrailPolicies = [...agent.guardrails];
     this.memoryRecorder = new PromptRequestMemory(agent, memoryContext, initialHistory);
   }
   agent;
@@ -1109,6 +1137,8 @@ var PromptRequest = class _PromptRequest {
   maxTurnCount;
   activeHook;
   approvalOptions;
+  guardrailPolicies;
+  guardrailDecisions = [];
   concurrency = 1;
   traceOptions;
   requestMiddlewares = [];
@@ -1131,6 +1161,10 @@ var PromptRequest = class _PromptRequest {
     this.approvalOptions = options;
     return this;
   }
+  guardrails(policies) {
+    this.guardrailPolicies = appendGuardrailPolicies(this.guardrailPolicies, policies);
+    return this;
+  }
   /**
    * @deprecated Use `withHook` instead.
    */
@@ -1175,14 +1209,37 @@ var PromptRequest = class _PromptRequest {
   async send() {
     this.startRun();
     const runId = globalThis.crypto.randomUUID();
-    const newMessages = [this.promptMessage];
-    this.chatHistory = await this.memoryRecorder.prepareRun(runId, newMessages);
-    const pendingTurnMessages = this.memoryRecorder.pendingTurnMessages(newMessages);
     let usage = Usage.empty();
     let currentTurns = 0;
     let lastPrompt = this.promptMessage;
+    let newMessages = [this.promptMessage];
     const runObservers = await this.startRunObservers();
     try {
+      const inputResult = await runInputGuardrails(this.guardrailPolicies, {
+        prompt: this.promptMessage,
+        history: this.chatHistory,
+        inputText: textFromMessage(this.promptMessage),
+        run: this.guardrailRunContext(runId)
+      });
+      for (const decision of inputResult.decisions) {
+        await this.recordGuardrailDecision(decision, runObservers);
+      }
+      this.promptMessage = inputResult.prompt;
+      if (inputResult.blocked) {
+        const output = inputResult.message ?? "The request was blocked by a guardrail.";
+        const result = {
+          output,
+          usage: Usage.empty(),
+          messages: [this.promptMessage, Message.assistant(output)],
+          guardrails: [...this.guardrailDecisions]
+        };
+        await runObservers.end(result);
+        this.runState = "completed";
+        return result;
+      }
+      newMessages = [this.promptMessage];
+      this.chatHistory = await this.memoryRecorder.prepareRun(runId, newMessages);
+      const pendingTurnMessages = this.memoryRecorder.pendingTurnMessages(newMessages);
       await this.runRunStartHook(newMessages);
       while (currentTurns <= this.maxTurnCount + 1) {
         const prompt = newMessages.at(-1);
@@ -1213,27 +1270,46 @@ var PromptRequest = class _PromptRequest {
         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(
-          runId,
-          currentTurns,
-          [assistantMessage],
-          pendingTurnMessages
-        );
         const toolCalls = response.choice.filter(
           (item) => item.type === "tool_call"
         );
+        const assistantMessage = Message.assistant(response.choice, response.messageId);
+        newMessages.push(assistantMessage);
         if (toolCalls.length === 0) {
+          if (this.steeringMessages.length > 0) {
+            await this.memoryRecorder.commitMessages(
+              runId,
+              currentTurns,
+              [assistantMessage],
+              pendingTurnMessages
+            );
+          }
           if (await this.drainSteeringMessages(runId, currentTurns, newMessages, pendingTurnMessages)) {
             await this.memoryRecorder.commitCompletedTurn(runId, currentTurns, pendingTurnMessages);
             continue;
           }
+          const guardedOutput = await this.runOutputGuardrailsForResponse(
+            runId,
+            usage,
+            response,
+            newMessages,
+            runObservers
+          );
+          response = guardedOutput.response;
+          const finalAssistantMessage = Message.assistant(response.choice, response.messageId);
+          newMessages[newMessages.length - 1] = finalAssistantMessage;
+          await this.memoryRecorder.commitMessages(
+            runId,
+            currentTurns,
+            [finalAssistantMessage],
+            pendingTurnMessages
+          );
           const result = {
-            output: textFromAssistantContent(response.choice),
+            output: guardedOutput.output,
             usage,
             messages: [...newMessages],
-            trace: runObservers.trace
+            trace: runObservers.trace,
+            guardrails: [...this.guardrailDecisions]
           };
           await this.runRunEndHook(result, newMessages);
           await runObservers.end(result);
@@ -1246,6 +1322,12 @@ var PromptRequest = class _PromptRequest {
           this.runState = "completed";
           return result;
         }
+        await this.memoryRecorder.commitMessages(
+          runId,
+          currentTurns,
+          [assistantMessage],
+          pendingTurnMessages
+        );
         const toolResults = await this.executeToolCalls(
           runId,
           toolCalls,
@@ -1284,18 +1366,51 @@ var PromptRequest = class _PromptRequest {
     }
     this.startRun();
     const runId = globalThis.crypto.randomUUID();
-    const newMessages = [this.promptMessage];
-    this.chatHistory = await this.memoryRecorder.prepareRun(runId, newMessages);
-    const pendingTurnMessages = this.memoryRecorder.pendingTurnMessages(newMessages);
-    let usage = Usage.empty();
-    let currentTurns = 0;
-    let lastPrompt = this.promptMessage;
-    const runObservers = await this.startRunObservers();
     const emit = async (event) => {
       await this.recordAgentEvent(runId, event);
       return event;
     };
+    let usage = Usage.empty();
+    let currentTurns = 0;
+    let lastPrompt = this.promptMessage;
+    let newMessages = [this.promptMessage];
+    const runObservers = await this.startRunObservers();
+    const bufferOutputDeltas = hasEnforcedOutputGuardrails(this.guardrailPolicies);
     try {
+      const inputResult = await runInputGuardrails(this.guardrailPolicies, {
+        prompt: this.promptMessage,
+        history: this.chatHistory,
+        inputText: textFromMessage(this.promptMessage),
+        run: this.guardrailRunContext(runId)
+      });
+      for (const decision of inputResult.decisions) {
+        await this.recordGuardrailDecision(decision, runObservers);
+        yield await emit({ type: "guardrail_decision", decision });
+      }
+      this.promptMessage = inputResult.prompt;
+      if (inputResult.blocked) {
+        const output = inputResult.message ?? "The request was blocked by a guardrail.";
+        const result = {
+          output,
+          usage: Usage.empty(),
+          messages: [this.promptMessage, Message.assistant(output)],
+          guardrails: [...this.guardrailDecisions]
+        };
+        await runObservers.end(result);
+        this.runState = "completed";
+        yield await emit({
+          type: "final",
+          runId,
+          output: result.output,
+          usage: result.usage,
+          messages: result.messages,
+          guardrails: result.guardrails
+        });
+        return;
+      }
+      newMessages = [this.promptMessage];
+      this.chatHistory = await this.memoryRecorder.prepareRun(runId, newMessages);
+      const pendingTurnMessages = this.memoryRecorder.pendingTurnMessages(newMessages);
       await this.runRunStartHook(newMessages);
       while (currentTurns <= this.maxTurnCount + 1) {
         const prompt = newMessages.at(-1);
@@ -1354,7 +1469,8 @@ var PromptRequest = class _PromptRequest {
               if (mapped.type === "tool_call") {
                 emittedToolCallIds.add(mapped.toolCall.id);
               }
-              if (!bufferResponseEvents) {
+              const shouldBuffer = bufferResponseEvents || bufferOutputDeltas && (mapped.type === "text_delta" || mapped.type === "reasoning_delta");
+              if (!shouldBuffer) {
                 yield await emit(addTurn(currentTurns, mapped));
               }
             }
@@ -1376,39 +1492,67 @@ var PromptRequest = class _PromptRequest {
         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(
-          runId,
-          currentTurns,
-          [assistantMessage],
-          pendingTurnMessages
-        );
         const toolCalls = response.choice.filter(
           (item) => item.type === "tool_call"
         );
-        if (bufferResponseEvents) {
-          for (const event of responseStreamEvents(currentTurns, response)) {
-            yield await emit(event);
-          }
-        } else {
-          for (const toolCall of toolCalls) {
-            if (!emittedToolCallIds.has(toolCall.id)) {
-              yield await emit({ type: "tool_call", turn: currentTurns, toolCall });
+        let assistantMessage = Message.assistant(response.choice, response.messageId);
+        newMessages.push(assistantMessage);
+        if (toolCalls.length === 0) {
+          let emittedTurnEnd = false;
+          if (!bufferOutputDeltas) {
+            if (bufferResponseEvents) {
+              for (const event of responseStreamEvents(currentTurns, response)) {
+                yield await emit(event);
+              }
             }
+            yield await emit({ type: "turn_end", turn: currentTurns, response });
+            emittedTurnEnd = true;
+          }
+          if (this.steeringMessages.length > 0) {
+            await this.memoryRecorder.commitMessages(
+              runId,
+              currentTurns,
+              [assistantMessage],
+              pendingTurnMessages
+            );
           }
-        }
-        yield await emit({ type: "turn_end", turn: currentTurns, response });
-        if (toolCalls.length === 0) {
           if (await this.drainSteeringMessages(runId, currentTurns, newMessages, pendingTurnMessages)) {
             await this.memoryRecorder.commitCompletedTurn(runId, currentTurns, pendingTurnMessages);
             continue;
           }
+          const guardedOutput = await this.runOutputGuardrailsForResponse(
+            runId,
+            usage,
+            response,
+            newMessages,
+            runObservers
+          );
+          for (const decision of guardedOutput.decisions) {
+            yield await emit({ type: "guardrail_decision", decision });
+          }
+          response = guardedOutput.response;
+          assistantMessage = Message.assistant(response.choice, response.messageId);
+          newMessages[newMessages.length - 1] = assistantMessage;
+          await this.memoryRecorder.commitMessages(
+            runId,
+            currentTurns,
+            [assistantMessage],
+            pendingTurnMessages
+          );
+          if (!emittedTurnEnd && (bufferResponseEvents || bufferOutputDeltas)) {
+            for (const event of responseStreamEvents(currentTurns, response)) {
+              yield await emit(event);
+            }
+          }
+          if (!emittedTurnEnd) {
+            yield await emit({ type: "turn_end", turn: currentTurns, response });
+          }
           const result = {
-            output: textFromAssistantContent(response.choice),
+            output: guardedOutput.output,
             usage,
             messages: [...newMessages],
-            trace: runObservers.trace
+            trace: runObservers.trace,
+            guardrails: [...this.guardrailDecisions]
           };
           await this.runRunEndHook(result, newMessages);
           await runObservers.end(result);
@@ -1425,10 +1569,29 @@ var PromptRequest = class _PromptRequest {
             output: result.output,
             usage: result.usage,
             messages: result.messages,
-            trace: result.trace
+            trace: result.trace,
+            guardrails: result.guardrails
           });
           return;
         }
+        if (bufferResponseEvents) {
+          for (const event of responseStreamEvents(currentTurns, response)) {
+            yield await emit(event);
+          }
+        } else {
+          for (const toolCall of toolCalls) {
+            if (!emittedToolCallIds.has(toolCall.id)) {
+              yield await emit({ type: "tool_call", turn: currentTurns, toolCall });
+            }
+          }
+        }
+        await this.memoryRecorder.commitMessages(
+          runId,
+          currentTurns,
+          [assistantMessage],
+          pendingTurnMessages
+        );
+        yield await emit({ type: "turn_end", turn: currentTurns, response });
         const toolResultEvents = createAsyncQueue();
         const toolResultsPromise = this.executeToolCalls(
           runId,
@@ -1527,6 +1690,46 @@ var PromptRequest = class _PromptRequest {
     );
     return executor.execute(toolCalls, onResult, onStreamEvent, observation);
   }
+  async runOutputGuardrailsForResponse(runId, usage, response, messages, runObservers) {
+    const originalOutput = textFromAssistantContent(response.choice);
+    const result = await runOutputGuardrails(this.guardrailPolicies, {
+      outputText: originalOutput,
+      messages: [...this.chatHistory, ...messages],
+      usage,
+      run: this.guardrailRunContext(runId)
+    });
+    for (const decision of result.decisions) {
+      await this.recordGuardrailDecision(decision, runObservers);
+    }
+    const output = result.blocked ? result.message ?? "The response was blocked by a guardrail." : result.outputText;
+    if (output === originalOutput) {
+      return { output, response, decisions: result.decisions };
+    }
+    return {
+      output,
+      response: {
+        ...response,
+        choice: [AssistantContent.text(output)]
+      },
+      decisions: result.decisions
+    };
+  }
+  async recordGuardrailDecision(decision, runObservers) {
+    this.guardrailDecisions.push(decision);
+    await runObservers.event({
+      name: "guardrail.decision",
+      level: decision.action === "block" ? "WARNING" : "DEFAULT",
+      attributes: guardrailDecisionAttributes(decision)
+    });
+  }
+  guardrailRunContext(runId) {
+    return compact({
+      agentId: this.agent.id,
+      runId,
+      sessionId: this.memoryContext?.sessionId,
+      metadata: this.memoryContext?.metadata
+    });
+  }
   async startRunObservers() {
     const failOnObserverError = this.traceOptions?.failOnObserverError === true || this.agent.observers.some((registration) => registration.failOnObserverError === true);
     return startAgentRunObservers(
@@ -1776,6 +1979,33 @@ function responseStreamEvents(turn, response) {
   }
   return events;
 }
+function textFromMessage(message) {
+  if (message.role === "system") {
+    return message.content;
+  }
+  return message.content.flatMap((content) => {
+    if (content.type === "text") {
+      return [content.text];
+    }
+    if (content.type === "document" && content.source.type === "text") {
+      return [content.source.text];
+    }
+    return [];
+  }).join("\n");
+}
+function guardrailDecisionAttributes(decision) {
+  return compact({
+    policyId: decision.policyId,
+    guardrailId: decision.guardrailId,
+    boundary: decision.boundary,
+    mode: decision.mode,
+    action: decision.action,
+    applied: decision.applied,
+    reason: decision.reason,
+    message: decision.message,
+    latencyMs: decision.latencyMs
+  });
+}
 
 export {
   MaxTurnsError,
@@ -1784,4 +2014,4 @@ export {
   extractRagText,
   PromptRequest
 };
-//# sourceMappingURL=chunk-7CQAERL3.js.map
+//# sourceMappingURL=chunk-CO7YK4JZ.js.map