@anvia/core 0.13.0 → 0.13.2

package/dist/{chunk-HLISYYCB.js → chunk-YOXG2K7N.js}

@@ -4,21 +4,18 @@ import {
 import {
   parseToolArgs,
   toolResultContentToText
-} from "./chunk-46IR5ZTN.js";
+} from "./chunk-JIUZWN45.js";
 import {
   runControl,
   toolCallControl
-} from "./chunk-NPZDYOE6.js";
-import {
-  compact
-} from "./chunk-MMHG7WAM.js";
+} from "./chunk-2ODTMRHP.js";
 import {
   mapWithConcurrency
 } from "./chunk-OIMLU4SF.js";
 import {
   CompletionRequestBuilder,
   isStreamingCompletionModel
-} from "./chunk-W53PLBOL.js";
+} from "./chunk-YTF65GYU.js";
 import {
   AssistantContent,
   Message,
@@ -26,7 +23,7 @@ import {
   Usage,
   assertCompletionRequestSupported,
   textFromAssistantContent
-} from "./chunk-7H3TQN3I.js";
+} from "./chunk-CNTGKNZ3.js";
 import {
   appendGuardrailPolicies,
   hasEnforcedOutputGuardrails,
@@ -245,13 +242,14 @@ async function fetchDynamicContext(agent, ragText) {
         documents.push(formatted);
       } else {
         const metadata = formatMetadata(result.metadata);
-        documents.push(
-          compact({
-            id: result.id,
-            text: typeof result.document === "string" ? result.document : JSON.stringify(result.document, null, 2),
-            additionalProps: metadata
-          })
-        );
+        const document = {
+          id: result.id,
+          text: typeof result.document === "string" ? result.document : JSON.stringify(result.document, null, 2)
+        };
+        if (metadata !== void 0) {
+          document.additionalProps = metadata;
+        }
+        documents.push(document);
       }
     }
   }
@@ -311,8 +309,8 @@ var CompletionStreamAccumulator = class {
     }
     if (event.type === "tool_call_delta") {
       const toolCall = this.toolCallStateForId(event.id);
-      if (event.callId !== void 0) toolCall.callId = event.callId;
-      if (event.name !== void 0) toolCall.name = event.name;
+      if (event.callId !== void 0 && event.callId.length > 0) toolCall.callId = event.callId;
+      if (event.name !== void 0 && event.name.length > 0) toolCall.name = event.name;
       if (event.signature !== void 0) toolCall.signature = event.signature;
       if (event.argumentsDelta !== void 0) {
         toolCall.argumentsText += event.argumentsDelta;
@@ -397,15 +395,15 @@ var CompletionStreamAccumulator = class {
   }
   mergeFinalResponse(accumulatedResponse, finalResponse) {
     if (finalResponse.choice.length === 0) {
-      return this.withMessageIdFallback(
-        {
-          ...accumulatedResponse,
-          usage: finalResponse.usage,
-          rawResponse: finalResponse.rawResponse,
-          ...finalResponse.messageId === void 0 ? {} : { messageId: finalResponse.messageId }
-        },
-        accumulatedResponse
-      );
+      const mergedResponse = {
+        ...accumulatedResponse,
+        usage: finalResponse.usage,
+        rawResponse: finalResponse.rawResponse
+      };
+      if (finalResponse.messageId !== void 0) {
+        mergedResponse.messageId = finalResponse.messageId;
+      }
+      return this.withMessageIdFallback(mergedResponse, accumulatedResponse);
     }
     const finalById = /* @__PURE__ */ new Map();
     const finalByCallId = /* @__PURE__ */ new Map();
@@ -650,6 +648,13 @@ var ToolCallExecutor = class {
   requestMiddlewares;
   cancel;
   async execute(toolCalls, onResult, onStreamEvent, observation) {
+    for (const toolCall of toolCalls) {
+      if (toolCall.function.name.length === 0) {
+        throw new Error(
+          `Completion returned tool call "${toolCall.id}" with an empty function name; this indicates invalid provider output or provider mapping.`
+        );
+      }
+    }
     return mapWithConcurrency(toolCalls, this.concurrency, async (toolCall) => {
       const args = JSON.stringify(toolCall.function.arguments ?? {});
       const internalCallId = globalThis.crypto.randomUUID();
@@ -666,18 +671,23 @@ var ToolCallExecutor = class {
         (definition) => definition.name === toolCall.function.name
       );
       const toolMetadata = toolTraceMetadata(tool);
-      const toolObservers = await observation?.runObservers.startTool(
-        compact({
-          turn: observation.turn,
-          toolCall,
-          toolName: toolCall.function.name,
-          internalCallId,
-          args,
-          toolCallId: toolCall.callId,
-          toolDefinition,
-          toolMetadata
-        })
-      );
+      const toolStartArgs = {
+        turn: observation?.turn ?? 0,
+        toolCall,
+        toolName: toolCall.function.name,
+        internalCallId,
+        args
+      };
+      if (toolCall.callId !== void 0) {
+        toolStartArgs.toolCallId = toolCall.callId;
+      }
+      if (toolDefinition !== void 0) {
+        toolStartArgs.toolDefinition = toolDefinition;
+      }
+      if (toolMetadata !== void 0) {
+        toolStartArgs.toolMetadata = toolMetadata;
+      }
+      const toolObservers = await observation?.runObservers.startTool(toolStartArgs);
       let output;
       let skipped = false;
       let effectiveArgs = args;
@@ -805,17 +815,18 @@ var ToolCallExecutor = class {
     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 streamEventArgs = {
+            turn: observation?.turn ?? 0,
+            toolCall,
+            toolName: toolCall.function.name,
+            internalCallId: hookArgs.internalCallId,
+            args: middlewareArgs,
+            event
+          };
+          if (toolCall.callId !== void 0) {
+            streamEventArgs.toolCallId = toolCall.callId;
+          }
+          await toolObservers?.streamEvent(streamEventArgs);
           const payload = agentToolEventPayload(toolCall, hookArgs.internalCallId, event);
           if (payload !== void 0) {
             onStreamEvent?.(payload);
@@ -829,15 +840,15 @@ var ToolCallExecutor = class {
         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
-      });
+      await toolObservers?.error(
+        toolErrorArgs(
+          observation?.turn ?? 0,
+          toolCall,
+          hookArgs.internalCallId,
+          middlewareArgs,
+          error
+        )
+      );
       if (errorAction?.type === "terminate") {
         throw this.cancel(errorAction.reason);
       }
@@ -907,14 +918,28 @@ var ToolCallExecutor = class {
     }
     const reason = await resolveApprovalText(policy.reason, context);
     const rejectMessage = await resolveApprovalText(policy.rejectMessage, context);
-    return this.requestApproval(tool, hookArgs, compact({ reason, rejectMessage }));
+    const options = {};
+    if (reason !== void 0) {
+      options.reason = reason;
+    }
+    if (rejectMessage !== void 0) {
+      options.rejectMessage = rejectMessage;
+    }
+    return this.requestApproval(tool, hookArgs, options);
   }
   async requestApproval(tool, hookArgs, options) {
-    const request = compact({
-      ...approvalContext(tool, hookArgs, this.agent, this.runContext),
-      reason: options.reason,
-      rejectMessage: options.rejectMessage
-    });
+    const request = approvalContext(
+      tool,
+      hookArgs,
+      this.agent,
+      this.runContext
+    );
+    if (options.reason !== void 0) {
+      request.reason = options.reason;
+    }
+    if (options.rejectMessage !== void 0) {
+      request.rejectMessage = options.rejectMessage;
+    }
     if (this.approvals === void 0) {
       throw new ToolApprovalRequiredError(request);
     }
@@ -931,19 +956,27 @@ var ToolCallExecutor = class {
 function approvalContext(tool, hookArgs, agent, run) {
   const rawParsedArgs = parseToolArgs(hookArgs.args);
   const parsedArgs = tool?.parseApprovalArgs?.(rawParsedArgs) ?? rawParsedArgs;
-  return compact({
+  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: parsedArgs,
     rawArgs: hookArgs.args,
-    toolCallId: hookArgs.toolCallId,
     internalCallId: hookArgs.internalCallId,
-    run: compact({
-      agentId: agent.id,
-      runId: run.runId,
-      sessionId: run.sessionId,
-      metadata: run.metadata
-    })
-  });
+    run: approvalRun
+  };
+  if (hookArgs.toolCallId !== void 0) {
+    context.toolCallId = hookArgs.toolCallId;
+  }
+  return context;
 }
 function normalizeApprovalDecision(decision) {
   if (typeof decision === "boolean") {
@@ -966,10 +999,27 @@ function toolTraceMetadata(tool) {
   }
   const metadata = tool[MCP_TOOL_METADATA_KEY];
   const mcpMetadata = typeof metadata === "object" && metadata !== null ? metadata : void 0;
-  return {
-    approvalRequired: tool.approval !== void 0,
-    ...typeof mcpMetadata?.serverName === "string" && mcpMetadata.serverName.length > 0 ? { mcpServerName: mcpMetadata.serverName } : {}
+  const result = {
+    approvalRequired: tool.approval !== void 0
+  };
+  if (typeof mcpMetadata?.serverName === "string" && mcpMetadata.serverName.length > 0) {
+    result.mcpServerName = mcpMetadata.serverName;
+  }
+  return result;
+}
+function toolErrorArgs(turn, toolCall, internalCallId, args, error) {
+  const observerArgs = {
+    turn,
+    toolCall,
+    toolName: toolCall.function.name,
+    internalCallId,
+    args,
+    error
   };
+  if (toolCall.callId !== void 0) {
+    observerArgs.toolCallId = toolCall.callId;
+  }
+  return observerArgs;
 }
 async function recordToolError(toolObservers, turn, toolCall, internalCallId, args, error) {
   await toolObservers?.error({
@@ -992,15 +1042,20 @@ function agentToolEventPayload(toolCall, internalCallId, event) {
   if (typeof event.agentId !== "string" || event.agentId.length === 0) {
     return void 0;
   }
-  return compact({
+  const payload = {
     type: "agent_tool_event",
     toolName: toolCall.function.name,
-    toolCallId: toolCall.callId,
     internalCallId,
     agentId: event.agentId,
-    agentName: event.agentName,
     event: event.event
-  });
+  };
+  if (toolCall.callId !== void 0) {
+    payload.toolCallId = toolCall.callId;
+  }
+  if (event.agentName !== void 0) {
+    payload.agentName = event.agentName;
+  }
+  return payload;
 }
 
 // src/internal/rag-text.ts
@@ -1528,16 +1583,7 @@ var PromptRequest = class _PromptRequest {
         assertCompletionRequestSupported(this.agent.model, request, { streaming: true });
         const providerRequest = this.providerTraceRequest(request, { stream: true });
         const generationObservers = await runObservers.startGeneration(
-          compact({
-            turn: currentTurns,
-            request,
-            providerRequest,
-            modelInfo: {
-              provider: this.agent.model.provider,
-              defaultModel: this.agent.model.defaultModel,
-              capabilities: this.agent.model.capabilities
-            }
-          })
+          this.generationStartArgs(currentTurns, request, providerRequest)
         );
         const accumulator = new CompletionStreamAccumulator();
         const generationStartedAt = Date.now();
@@ -1570,13 +1616,14 @@ var PromptRequest = class _PromptRequest {
           throw error;
         }
         let response = accumulator.response();
-        await generationObservers.end(
-          compact({
-            turn: currentTurns,
-            response,
-            firstDeltaMs
-          })
-        );
+        const generationEndArgs = {
+          turn: currentTurns,
+          response
+        };
+        if (firstDeltaMs !== void 0) {
+          generationEndArgs.firstDeltaMs = firstDeltaMs;
+        }
+        await generationObservers.end(generationEndArgs);
         response = await this.runCompletionResponseMiddlewares(request, response, currentTurns);
         usage = Usage.add(usage, response.usage);
         await this.runCompletionResponseHook(prompt, response, newMessages);
@@ -1734,16 +1781,7 @@ var PromptRequest = class _PromptRequest {
     assertCompletionRequestSupported(this.agent.model, request);
     const providerRequest = this.providerTraceRequest(request);
     const generationObservers = await runObservers.startGeneration(
-      compact({
-        turn,
-        request,
-        providerRequest,
-        modelInfo: {
-          provider: this.agent.model.provider,
-          defaultModel: this.agent.model.defaultModel,
-          capabilities: this.agent.model.capabilities
-        }
-      })
+      this.generationStartArgs(turn, request, providerRequest)
     );
     try {
       const response = await this.agent.model.completion(request);
@@ -1763,6 +1801,21 @@ var PromptRequest = class _PromptRequest {
       };
     }
   }
+  generationStartArgs(turn, request, providerRequest) {
+    const args = {
+      turn,
+      request,
+      modelInfo: {
+        provider: this.agent.model.provider,
+        defaultModel: this.agent.model.defaultModel,
+        capabilities: this.agent.model.capabilities
+      }
+    };
+    if (providerRequest !== void 0) {
+      args.providerRequest = providerRequest;
+    }
+    return args;
+  }
   async executeToolCalls(runId, toolCalls, newMessages, onResult, onStreamEvent, observation) {
     const executor = new ToolCallExecutor(
       this.agent,
@@ -1812,12 +1865,17 @@ var PromptRequest = class _PromptRequest {
     });
   }
   guardrailRunContext(runId) {
-    return compact({
+    const context = {
       agentId: this.agent.id,
-      runId,
-      sessionId: this.memoryContext?.sessionId,
-      metadata: this.memoryContext?.metadata
-    });
+      runId
+    };
+    if (this.memoryContext !== void 0) {
+      context.sessionId = this.memoryContext.sessionId;
+      if (this.memoryContext.metadata !== void 0) {
+        context.metadata = this.memoryContext.metadata;
+      }
+    }
+    return context;
   }
   async startRunObservers() {
     const failOnObserverError = this.traceOptions?.failOnObserverError === true || this.agent.observers.some((registration) => registration.failOnObserverError === true);
@@ -1846,17 +1904,25 @@ var PromptRequest = class _PromptRequest {
     const turn = "turn" in event ? event.turn : void 0;
     const agentId = event.type === "agent_tool_event" ? event.agentId : this.agent.id;
     const agentName = event.type === "agent_tool_event" ? event.agentName : this.agent.name;
-    await registration.store.append({
+    const input = {
       runId,
       agentId,
-      ...compact({ agentName, turn }),
-      ...event.type === "agent_tool_event" ? compact({
-        toolName: event.toolName,
-        toolCallId: event.toolCallId,
-        internalCallId: event.internalCallId
-      }) : {},
       event
-    });
+    };
+    if (agentName !== void 0) {
+      input.agentName = agentName;
+    }
+    if (turn !== void 0) {
+      input.turn = turn;
+    }
+    if (event.type === "agent_tool_event") {
+      input.toolName = event.toolName;
+      input.internalCallId = event.internalCallId;
+      if (event.toolCallId !== void 0) {
+        input.toolCallId = event.toolCallId;
+      }
+    }
+    await registration.store.append(input);
   }
   async runCompletionCallHook(prompt, history, newMessages) {
     const action = await this.activeHook?.onCompletionCall?.({
@@ -2041,19 +2107,14 @@ function responseStreamEvents(turn, response) {
     if (item.type === "reasoning") {
       if (item.content === void 0) {
         if (item.text.length > 0) {
-          events.push(
-            compact({ type: "reasoning_delta", turn, delta: item.text, id: item.id })
-          );
+          events.push(reasoningDeltaEvent2(turn, item.text, { id: item.id }));
         }
         continue;
       }
       for (const content of item.content) {
         const delta = content.type === "encrypted" || content.type === "redacted" ? content.data : content.text;
         events.push(
-          compact({
-            type: "reasoning_delta",
-            turn,
-            delta,
+          reasoningDeltaEvent2(turn, delta, {
             id: item.id,
             contentType: content.type,
             signature: content.type === "text" ? content.signature : void 0
@@ -2068,6 +2129,23 @@ function responseStreamEvents(turn, response) {
   }
   return events;
 }
+function reasoningDeltaEvent2(turn, delta, details = {}) {
+  const event = {
+    type: "reasoning_delta",
+    turn,
+    delta
+  };
+  if (details.id !== void 0) {
+    event.id = details.id;
+  }
+  if (details.contentType !== void 0) {
+    event.contentType = details.contentType;
+  }
+  if (details.signature !== void 0) {
+    event.signature = details.signature;
+  }
+  return event;
+}
 function textFromMessage(message) {
   if (message.role === "system") {
     return message.content;
@@ -2083,17 +2161,22 @@ function textFromMessage(message) {
   }).join("\n");
 }
 function guardrailDecisionAttributes(decision) {
-  return compact({
+  const attributes = {
     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
-  });
+  };
+  if (decision.reason !== void 0) {
+    attributes.reason = decision.reason;
+  }
+  if (decision.message !== void 0) {
+    attributes.message = decision.message;
+  }
+  return attributes;
 }
 
 export {
@@ -2103,4 +2186,4 @@ export {
   extractRagText,
   PromptRequest
 };
-//# sourceMappingURL=chunk-HLISYYCB.js.map
+//# sourceMappingURL=chunk-YOXG2K7N.js.map