@anvia/core 0.12.2 → 0.12.4

package/README.md

@@ -1,8 +1,14 @@
 # @anvia/core
 
-Core runtime primitives for Anvia agents, tools, structured extraction, pipelines, streaming, RAG, MCP, skills, and observability.
+Small, explicit, embeddable runtime contracts for Anvia agents, tools, structured extraction, pipelines, streaming, RAG, MCP, skills, and observability.
 
-This package is provider-neutral. Pair it with a provider adapter such as `@anvia/openai`, `@anvia/anthropic`, or `@anvia/gemini` to create runnable models.
+This package is provider-neutral. Pair it with a provider adapter such as `@anvia/openai`, `@anvia/anthropic`, or `@anvia/gemini` to create runnable model objects, then pass those objects into agents, extractors, pipelines, or direct completion helpers.
+
+## Design Philosophy
+
+`@anvia/core` owns the model/tool loop and the runtime contracts around it. Your application owns provider client construction, credentials, product data access, permissions, storage, deployment, observability backends, and response shape.
+
+The package is dependency-injection oriented: create provider models, typed tools, memory stores, vector indexes, observers, and services in application code, then pass the relevant objects into agents, prompt requests, runners, or adapters. Core receives those objects and coordinates the run without taking over product architecture.
 
 ## Installation
 

package/dist/agent/index.js

@@ -1,8 +1,8 @@
 import {
   AgentBuilder
-} from "../chunk-XUO3KR5T.js";
-import "../chunk-TUDZBJGF.js";
-import "../chunk-4NCRFQHS.js";
+} from "../chunk-OODGSEUU.js";
+import "../chunk-OQXRM5DO.js";
+import "../chunk-C7JLBS3F.js";
 import "../chunk-YK4WAAS4.js";
 import "../chunk-XUUY2L2D.js";
 import "../chunk-YVQBC3SJ.js";

package/dist/{chunk-4NCRFQHS.js → chunk-C7JLBS3F.js}

@@ -289,48 +289,34 @@ function formatMetadata(metadata) {
 }
 
 // src/internal/prompt-runtime/stream-accumulator.ts
-var CompletionStreamAccumulator = class _CompletionStreamAccumulator {
-  static defaultReasoningKey = "reasoning";
-  text = "";
-  reasoningById = /* @__PURE__ */ new Map();
-  reasoningOrder = [];
+var CompletionStreamAccumulator = class {
+  orderedParts = [];
+  textParts = /* @__PURE__ */ new Map();
+  reasoningByKey = /* @__PURE__ */ new Map();
+  reasoningKeyById = /* @__PURE__ */ new Map();
   toolCalls = /* @__PURE__ */ new Map();
-  toolCallOrder = [];
   finalResponse;
   messageId;
+  nextTextKey = 0;
+  nextReasoningKey = 0;
   accept(event) {
     if (event.type === "text_delta") {
-      this.text += event.delta;
+      this.appendText(event.delta);
       return { type: "text_delta", delta: event.delta };
     }
     if (event.type === "reasoning_delta") {
-      const key = event.id ?? _CompletionStreamAccumulator.defaultReasoningKey;
-      const existing = this.reasoningById.get(key);
-      const reasoning = existing ?? { text: "" };
-      if (!existing) {
-        this.reasoningOrder.push(key);
-      }
+      const reasoning = this.reasoningStateForEvent(event);
       this.appendReasoning(reasoning, event);
-      this.reasoningById.set(key, reasoning);
       return reasoningDeltaEvent(event);
     }
     if (event.type === "tool_call_delta") {
-      const existing = this.toolCalls.get(event.id);
-      const toolCall = existing ?? {
-        id: event.id,
-        name: "",
-        argumentsText: ""
-      };
-      if (!existing) {
-        this.toolCallOrder.push(event.id);
-      }
+      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.signature !== void 0) toolCall.signature = event.signature;
       if (event.argumentsDelta !== void 0) {
         toolCall.argumentsText += event.argumentsDelta;
       }
-      this.toolCalls.set(event.id, toolCall);
       return void 0;
     }
     if (event.type === "tool_call") {
@@ -350,16 +336,8 @@ var CompletionStreamAccumulator = class _CompletionStreamAccumulator {
   response() {
     const accumulatedResponse = this.buildAccumulatedResponse();
     if (this.finalResponse !== void 0) {
-      if (this.finalResponse.choice.length === 0) {
-        const response = {
-          ...accumulatedResponse,
-          usage: this.finalResponse.usage,
-          rawResponse: this.finalResponse.rawResponse
-        };
-        if (this.finalResponse.messageId !== void 0) {
-          response.messageId = this.finalResponse.messageId;
-        }
-        return response;
+      if (accumulatedResponse.choice.length === 0) {
+        return this.withMessageIdFallback(this.finalResponse, accumulatedResponse);
       }
       return this.mergeFinalResponse(accumulatedResponse, this.finalResponse);
     }
@@ -367,33 +345,24 @@ var CompletionStreamAccumulator = class _CompletionStreamAccumulator {
   }
   buildAccumulatedResponse() {
     const choice = [];
-    if (this.text.length > 0) {
-      choice.push({ type: "text", text: this.text });
-    }
-    for (const key of this.reasoningOrder) {
-      const reasoning = this.reasoningById.get(key) ?? { text: "" };
-      const id = key === _CompletionStreamAccumulator.defaultReasoningKey ? void 0 : key;
-      const content = reasoning.content === void 0 ? { type: "reasoning", text: reasoning.text } : { type: "reasoning", text: reasoning.text, content: reasoning.content };
-      choice.push(id === void 0 ? content : { ...content, id });
-    }
-    for (const id of this.toolCallOrder) {
-      const toolCall = this.toolCalls.get(id);
-      if (toolCall !== void 0) {
-        const content = {
-          type: "tool_call",
-          id: toolCall.id,
-          function: {
-            name: toolCall.name,
-            arguments: parseJsonValue(toolCall.argumentsText)
-          }
-        };
-        if (toolCall.callId !== void 0) {
-          content.callId = toolCall.callId;
+    for (const part of this.orderedParts) {
+      if (part.type === "text") {
+        const text = this.textParts.get(part.key) ?? "";
+        if (text.length > 0) {
+          choice.push({ type: "text", text });
         }
-        if (toolCall.signature !== void 0) {
-          content.signature = toolCall.signature;
+        continue;
+      }
+      if (part.type === "reasoning") {
+        const reasoning = this.reasoningByKey.get(part.key);
+        if (reasoning !== void 0) {
+          choice.push(reasoningContent(reasoning));
         }
-        choice.push(content);
+        continue;
+      }
+      const toolCall = this.toolCalls.get(part.key);
+      if (toolCall !== void 0) {
+        choice.push(toolCallContent(toolCall));
       }
     }
     const response = {
@@ -408,7 +377,7 @@ var CompletionStreamAccumulator = class _CompletionStreamAccumulator {
   }
   upsertToolCall(toolCall) {
     if (!this.toolCalls.has(toolCall.id)) {
-      this.toolCallOrder.push(toolCall.id);
+      this.orderedParts.push({ type: "tool_call", key: toolCall.id });
     }
     const partial = {
       id: toolCall.id,
@@ -421,39 +390,120 @@ var CompletionStreamAccumulator = class _CompletionStreamAccumulator {
     if (toolCall.signature !== void 0) {
       partial.signature = toolCall.signature;
     }
+    if (toolCall.additionalParams !== void 0) {
+      partial.additionalParams = toolCall.additionalParams;
+    }
     this.toolCalls.set(toolCall.id, partial);
   }
   mergeFinalResponse(accumulatedResponse, finalResponse) {
-    const accumulatedById = /* @__PURE__ */ new Map();
-    const accumulatedByCallId = /* @__PURE__ */ new Map();
-    for (const content of accumulatedResponse.choice) {
+    if (finalResponse.choice.length === 0) {
+      return this.withMessageIdFallback(
+        {
+          ...accumulatedResponse,
+          usage: finalResponse.usage,
+          rawResponse: finalResponse.rawResponse,
+          ...finalResponse.messageId === void 0 ? {} : { messageId: finalResponse.messageId }
+        },
+        accumulatedResponse
+      );
+    }
+    const finalById = /* @__PURE__ */ new Map();
+    const finalByCallId = /* @__PURE__ */ new Map();
+    for (const content of finalResponse.choice) {
       if (content.type !== "tool_call") {
         continue;
       }
-      accumulatedById.set(content.id, content);
+      finalById.set(content.id, content);
       if (content.callId !== void 0) {
-        accumulatedByCallId.set(content.callId, content);
+        finalByCallId.set(content.callId, content);
       }
     }
-    return {
-      ...finalResponse,
-      choice: finalResponse.choice.map((content) => {
-        if (content.type !== "tool_call" || !isEmptyToolArguments(content.function.arguments)) {
-          return content;
-        }
-        const accumulated = accumulatedById.get(content.id) ?? (content.callId === void 0 ? void 0 : accumulatedByCallId.get(content.callId));
-        if (accumulated === void 0 || isEmptyToolArguments(accumulated.function.arguments)) {
-          return content;
+    const matchedFinalToolCalls = /* @__PURE__ */ new Set();
+    const choice = accumulatedResponse.choice.map((content) => {
+      if (content.type !== "tool_call") {
+        return content;
+      }
+      const finalToolCall = finalById.get(content.id) ?? (content.callId === void 0 ? void 0 : finalByCallId.get(content.callId));
+      if (finalToolCall === void 0) {
+        return content;
+      }
+      matchedFinalToolCalls.add(finalToolCall);
+      return mergeFinalToolCall(content, finalToolCall);
+    });
+    for (const content of finalResponse.choice) {
+      if (content.type !== "tool_call") {
+        continue;
+      }
+      if (!matchedFinalToolCalls.has(content)) {
+        choice.push(content);
+      }
+    }
+    return this.withMessageIdFallback({ ...finalResponse, choice }, accumulatedResponse);
+  }
+  appendText(delta) {
+    const lastPart = this.orderedParts.at(-1);
+    const key = lastPart?.type === "text" ? lastPart.key : this.createTextKey();
+    if (lastPart?.type !== "text") {
+      this.orderedParts.push({ type: "text", key });
+    }
+    this.textParts.set(key, `${this.textParts.get(key) ?? ""}${delta}`);
+  }
+  reasoningStateForEvent(event) {
+    if (event.id !== void 0) {
+      const existingKey = this.reasoningKeyById.get(event.id);
+      if (existingKey !== void 0) {
+        const existing = this.reasoningByKey.get(existingKey);
+        if (existing !== void 0) {
+          return existing;
         }
-        return {
-          ...content,
-          function: {
-            ...content.function,
-            arguments: accumulated.function.arguments
-          }
-        };
-      })
+      }
+      const key2 = this.createReasoningKey();
+      const reasoning2 = { id: event.id, text: "" };
+      this.reasoningKeyById.set(event.id, key2);
+      this.reasoningByKey.set(key2, reasoning2);
+      this.orderedParts.push({ type: "reasoning", key: key2 });
+      return reasoning2;
+    }
+    const lastPart = this.orderedParts.at(-1);
+    if (lastPart?.type === "reasoning") {
+      const lastReasoning = this.reasoningByKey.get(lastPart.key);
+      if (lastReasoning !== void 0 && lastReasoning.id === void 0) {
+        return lastReasoning;
+      }
+    }
+    const key = this.createReasoningKey();
+    const reasoning = { text: "" };
+    this.reasoningByKey.set(key, reasoning);
+    this.orderedParts.push({ type: "reasoning", key });
+    return reasoning;
+  }
+  toolCallStateForId(id) {
+    const existing = this.toolCalls.get(id);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const toolCall = {
+      id,
+      name: "",
+      argumentsText: ""
     };
+    this.toolCalls.set(id, toolCall);
+    this.orderedParts.push({ type: "tool_call", key: id });
+    return toolCall;
+  }
+  withMessageIdFallback(response, accumulatedResponse) {
+    if (response.messageId !== void 0 || accumulatedResponse.messageId === void 0) {
+      return response;
+    }
+    return { ...response, messageId: accumulatedResponse.messageId };
+  }
+  createTextKey() {
+    this.nextTextKey += 1;
+    return `text_${this.nextTextKey.toString()}`;
+  }
+  createReasoningKey() {
+    this.nextReasoningKey += 1;
+    return `reasoning_${this.nextReasoningKey.toString()}`;
   }
   appendReasoning(reasoning, event) {
     const contentType = event.contentType ?? "text";
@@ -493,6 +543,42 @@ var CompletionStreamAccumulator = class _CompletionStreamAccumulator {
     reasoning.content.push({ type: "redacted", data: event.delta });
   }
 };
+function reasoningContent(reasoning) {
+  const content = reasoning.content === void 0 ? { type: "reasoning", text: reasoning.text } : { type: "reasoning", text: reasoning.text, content: reasoning.content };
+  return reasoning.id === void 0 ? content : { ...content, id: reasoning.id };
+}
+function toolCallContent(toolCall) {
+  const content = {
+    type: "tool_call",
+    id: toolCall.id,
+    function: {
+      name: toolCall.name,
+      arguments: parseJsonValue(toolCall.argumentsText)
+    }
+  };
+  if (toolCall.callId !== void 0) {
+    content.callId = toolCall.callId;
+  }
+  if (toolCall.signature !== void 0) {
+    content.signature = toolCall.signature;
+  }
+  if (toolCall.additionalParams !== void 0) {
+    content.additionalParams = toolCall.additionalParams;
+  }
+  return content;
+}
+function mergeFinalToolCall(accumulated, finalToolCall) {
+  const argumentsValue = isEmptyToolArguments(finalToolCall.function.arguments) ? accumulated.function.arguments : finalToolCall.function.arguments;
+  return {
+    ...accumulated,
+    ...finalToolCall,
+    function: {
+      ...accumulated.function,
+      ...finalToolCall.function,
+      arguments: argumentsValue
+    }
+  };
+}
 function reasoningDeltaEvent(event) {
   const mapped = { type: "reasoning_delta", delta: event.delta };
   if (event.id !== void 0) mapped.id = event.id;
@@ -2014,4 +2100,4 @@ export {
   extractRagText,
   PromptRequest
 };
-//# sourceMappingURL=chunk-4NCRFQHS.js.map
+//# sourceMappingURL=chunk-C7JLBS3F.js.map