@databuddy/sdk 2.3.23 → 2.3.25

package/dist/ai/vercel/index.mjs

@@ -1,19 +1,3 @@
-import { wrapLanguageModel } from 'ai';
-
-const extractToolInfo = (content) => {
-  const toolCalls = content.filter((part) => part.type === "tool-call");
-  const toolResults = content.filter((part) => part.type === "tool-result");
-  const toolCallNames = [
-    ...new Set(
-      toolCalls.map((c) => c.toolName).filter((name) => Boolean(name))
-    )
-  ];
-  return {
-    toolCallCount: toolCalls.length,
-    toolResultCount: toolResults.length,
-    toolCallNames
-  };
-};
 const computeCosts = async (modelId, provider, usage) => {
   try {
     const { computeCostUSD } = await import('tokenlens');
@@ -34,6 +18,337 @@ const computeCosts = async (modelId, provider, usage) => {
     return {};
   }
 };
+
+const extractTokenCount = (value) => {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (value && typeof value === "object" && "total" in value && typeof value.total === "number") {
+    return value.total;
+  }
+  return void 0;
+};
+const extractReasoningTokens = (usage) => {
+  if ("reasoningTokens" in usage && typeof usage.reasoningTokens === "number") {
+    return usage.reasoningTokens;
+  }
+  if ("outputTokens" in usage && usage.outputTokens && typeof usage.outputTokens === "object" && "reasoning" in usage.outputTokens && typeof usage.outputTokens.reasoning === "number") {
+    return usage.outputTokens.reasoning;
+  }
+  return void 0;
+};
+const extractCacheReadTokens = (usage) => {
+  if ("cachedInputTokens" in usage && typeof usage.cachedInputTokens === "number") {
+    return usage.cachedInputTokens;
+  }
+  if ("inputTokens" in usage && usage.inputTokens && typeof usage.inputTokens === "object" && "cacheRead" in usage.inputTokens && typeof usage.inputTokens.cacheRead === "number") {
+    return usage.inputTokens.cacheRead;
+  }
+  return void 0;
+};
+const extractCacheCreationTokens = (providerMetadata) => {
+  if (providerMetadata && typeof providerMetadata === "object" && "anthropic" in providerMetadata && providerMetadata.anthropic && typeof providerMetadata.anthropic === "object" && "cacheCreationInputTokens" in providerMetadata.anthropic && typeof providerMetadata.anthropic.cacheCreationInputTokens === "number") {
+    return providerMetadata.anthropic.cacheCreationInputTokens;
+  }
+  return void 0;
+};
+const calculateWebSearchCount = (result) => {
+  if (!result || typeof result !== "object") {
+    return 0;
+  }
+  if (result.usage && typeof result.usage === "object" && result.usage !== null && "search_context_size" in result.usage && result.usage.search_context_size) {
+    return 1;
+  }
+  return 0;
+};
+const extractWebSearchCount = (providerMetadata, usage) => {
+  if (providerMetadata && typeof providerMetadata === "object" && "anthropic" in providerMetadata && providerMetadata.anthropic && typeof providerMetadata.anthropic === "object" && "server_tool_use" in providerMetadata.anthropic) {
+    const serverToolUse = providerMetadata.anthropic.server_tool_use;
+    if (serverToolUse && typeof serverToolUse === "object" && "web_search_requests" in serverToolUse && typeof serverToolUse.web_search_requests === "number") {
+      return serverToolUse.web_search_requests;
+    }
+  }
+  return calculateWebSearchCount({ usage});
+};
+const extractToolInfo = (content, params) => {
+  const toolCalls = content.filter((part) => part.type === "tool-call");
+  const toolResults = content.filter((part) => part.type === "tool-result");
+  const toolCallNames = [
+    ...new Set(
+      toolCalls.map((c) => c.toolName).filter((name) => Boolean(name))
+    )
+  ];
+  const availableTools = params?.tools?.map((t) => t.name) ?? [];
+  return {
+    toolCallCount: toolCalls.length,
+    toolResultCount: toolResults.length,
+    toolCallNames,
+    availableTools: availableTools.length > 0 ? availableTools : void 0
+  };
+};
+const extractAdditionalTokenValues = (providerMetadata) => {
+  if (providerMetadata && typeof providerMetadata === "object" && "anthropic" in providerMetadata && providerMetadata.anthropic && typeof providerMetadata.anthropic === "object" && "cacheCreationInputTokens" in providerMetadata.anthropic) {
+    return {
+      cacheCreationInputTokens: providerMetadata.anthropic.cacheCreationInputTokens
+    };
+  }
+  return {};
+};
+const extractUsage = (usage, providerMetadata) => {
+  const usageObj = usage;
+  const inputTokens = extractTokenCount(usage.inputTokens) ?? 0;
+  const outputTokens = extractTokenCount(usage.outputTokens) ?? 0;
+  const totalTokens = usage.totalTokens ?? inputTokens + outputTokens;
+  const cachedInputTokens = extractCacheReadTokens(usageObj);
+  const cacheCreationInputTokens = extractCacheCreationTokens(providerMetadata);
+  const reasoningTokens = extractReasoningTokens(usageObj);
+  const webSearchCount = extractWebSearchCount(providerMetadata, usage);
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    cachedInputTokens,
+    cacheCreationInputTokens,
+    reasoningTokens,
+    webSearchCount
+  };
+};
+const adjustAnthropicV3CacheTokens = (model, provider, usage) => {
+  if (model.specificationVersion === "v3" && provider.toLowerCase().includes("anthropic")) {
+    const cacheReadTokens = usage.cachedInputTokens ?? 0;
+    const cacheWriteTokens = usage.cacheCreationInputTokens ?? 0;
+    const cacheTokens = cacheReadTokens + cacheWriteTokens;
+    if (usage.inputTokens && cacheTokens > 0) {
+      usage.inputTokens = Math.max(usage.inputTokens - cacheTokens, 0);
+      usage.totalTokens = usage.inputTokens + usage.outputTokens;
+    }
+  }
+};
+
+const MAX_TEXT_LENGTH = 1e5;
+const DATA_URL_REGEX = /^data:([^;,]+)/;
+const WHITESPACE_REGEX = /\s/;
+const BASE64_REGEX = /^[A-Za-z0-9+/=]+$/;
+const truncate = (text, maxLength = MAX_TEXT_LENGTH) => {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return `${text.slice(0, maxLength)}... [truncated ${text.length - maxLength} chars]`;
+};
+const redactBase64DataUrl = (data) => {
+  if (data.startsWith("data:")) {
+    const match = data.match(DATA_URL_REGEX);
+    const mediaType = match?.[1] ?? "unknown";
+    return `[${mediaType} data URL redacted]`;
+  }
+  if (data.length > 1e3 && !WHITESPACE_REGEX.test(data) && BASE64_REGEX.test(data)) {
+    return `[base64 data redacted - ${data.length} chars]`;
+  }
+  return data;
+};
+const toContentString = (content) => {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content.map((c) => {
+      if (typeof c === "string") {
+        return c;
+      }
+      if (c && typeof c === "object" && "text" in c) {
+        return c.text;
+      }
+      return "";
+    }).join("");
+  }
+  return "";
+};
+const generateTraceId = () => {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 11)}`;
+};
+
+const mapPromptToMessages = (prompt, maxSize) => {
+  const messages = prompt.map((message) => {
+    if (message.role === "system") {
+      return {
+        role: "system",
+        content: truncate(toContentString(message.content))
+      };
+    }
+    if (Array.isArray(message.content)) {
+      const content = message.content.map((c) => {
+        if (c.type === "text") {
+          return { type: "text", text: truncate(c.text) };
+        }
+        if (c.type === "file") {
+          const data = c.data;
+          const fileData = data instanceof URL ? data.toString() : typeof data === "string" ? redactBase64DataUrl(data) : "[binary file]";
+          return { type: "file", file: fileData, mediaType: c.mediaType };
+        }
+        if (c.type === "image") {
+          const data = c.image;
+          const imageData = data instanceof URL ? data.toString() : typeof data === "string" ? redactBase64DataUrl(data) : "[binary image]";
+          return {
+            type: "image",
+            image: imageData,
+            mediaType: c.mimeType ?? "image/unknown"
+          };
+        }
+        if (c.type === "tool-call") {
+          const input = c.input;
+          return {
+            type: "tool-call",
+            id: c.toolCallId,
+            function: {
+              name: c.toolName,
+              arguments: truncate(
+                typeof input === "string" ? input : JSON.stringify(input ?? {})
+              )
+            }
+          };
+        }
+        if (c.type === "tool-result") {
+          return {
+            type: "tool-result",
+            toolCallId: c.toolCallId,
+            toolName: c.toolName,
+            output: c.output,
+            isError: false
+          };
+        }
+        return { type: "text", text: "" };
+      });
+      return { role: message.role, content };
+    }
+    return {
+      role: message.role,
+      content: truncate(toContentString(message.content))
+    };
+  });
+  try {
+    let serialized = JSON.stringify(messages);
+    let removedCount = 0;
+    const initialSize = messages.length;
+    for (let i = 0; i < initialSize && Buffer.byteLength(serialized, "utf8") > maxSize; i++) {
+      messages.shift();
+      removedCount++;
+      serialized = JSON.stringify(messages);
+    }
+    if (removedCount > 0) {
+      messages.unshift({
+        role: "system",
+        content: `[${removedCount} message${removedCount === 1 ? "" : "s"} removed due to size limit]`
+      });
+    }
+  } catch (error) {
+    console.error("Error stringifying inputs", error);
+    return [
+      {
+        role: "system",
+        content: "An error occurred while processing your request. Please try again."
+      }
+    ];
+  }
+  return messages;
+};
+const mapResultToMessages = (content) => {
+  const mappedContent = content.map((item) => {
+    if (item.type === "text") {
+      return { type: "text", text: truncate(item.text ?? "") };
+    }
+    if (item.type === "reasoning") {
+      return { type: "reasoning", text: truncate(item.text ?? "") };
+    }
+    if (item.type === "tool-call") {
+      const toolItem = item;
+      const rawArgs = toolItem.args ?? toolItem.arguments ?? toolItem.input;
+      const argsValue = typeof rawArgs === "string" ? rawArgs : JSON.stringify(rawArgs ?? {});
+      return {
+        type: "tool-call",
+        id: toolItem.toolCallId ?? "",
+        function: {
+          name: toolItem.toolName ?? "",
+          arguments: truncate(argsValue)
+        }
+      };
+    }
+    if (item.type === "file") {
+      let fileData;
+      if (item.data instanceof URL) {
+        fileData = item.data.toString();
+      } else if (typeof item.data === "string") {
+        fileData = redactBase64DataUrl(item.data);
+        if (fileData === item.data && item.data.length > 1e3) {
+          fileData = `[${item.mediaType ?? "unknown"} file - ${item.data.length} bytes]`;
+        }
+      } else {
+        fileData = "[binary file]";
+      }
+      return {
+        type: "file",
+        file: fileData,
+        mediaType: item.mediaType ?? "application/octet-stream"
+      };
+    }
+    if (item.type === "source") {
+      return {
+        type: "source",
+        sourceType: item.sourceType ?? "unknown",
+        id: item.id ?? "",
+        url: item.url ?? "",
+        title: item.title ?? ""
+      };
+    }
+    return { type: "text", text: truncate(JSON.stringify(item)) };
+  });
+  if (mappedContent.length === 0) {
+    return [];
+  }
+  return [
+    {
+      role: "assistant",
+      content: mappedContent.length === 1 && mappedContent[0].type === "text" ? mappedContent[0].text : mappedContent
+    }
+  ];
+};
+const buildStreamOutput = (generatedText, reasoningText, toolCalls, sources = []) => {
+  const outputContent = [];
+  if (reasoningText) {
+    outputContent.push({ type: "reasoning", text: truncate(reasoningText) });
+  }
+  if (generatedText) {
+    outputContent.push({ type: "text", text: truncate(generatedText) });
+  }
+  for (const toolCall of toolCalls.values()) {
+    outputContent.push({
+      type: "tool-call",
+      id: toolCall.toolCallId,
+      function: {
+        name: toolCall.toolName,
+        arguments: truncate(toolCall.input)
+      }
+    });
+  }
+  for (const source of sources) {
+    outputContent.push({
+      type: "source",
+      sourceType: source.sourceType,
+      id: source.id,
+      url: source.url,
+      title: source.title
+    });
+  }
+  if (outputContent.length === 0) {
+    return [];
+  }
+  return [
+    {
+      role: "assistant",
+      content: outputContent.length === 1 && outputContent[0].type === "text" ? outputContent[0].text : outputContent
+    }
+  ];
+};
+
 const createDefaultTransport = (apiUrl, clientId, apiKey) => {
   return async (call) => {
     const headers = {
@@ -57,160 +372,6 @@ const createDefaultTransport = (apiUrl, clientId, apiKey) => {
     }
   };
 };
-const createMiddleware = (transport, options = {}) => {
-  const { computeCosts: shouldComputeCosts = true } = options;
-  return {
-    wrapGenerate: async ({ doGenerate, model }) => {
-      const startTime = Date.now();
-      try {
-        const result = await doGenerate();
-        const durationMs = Date.now() - startTime;
-        const tools = extractToolInfo(
-          result.content
-        );
-        const inputTokens = result.usage.inputTokens ?? 0;
-        const outputTokens = result.usage.outputTokens ?? 0;
-        const totalTokens = result.usage.totalTokens ?? inputTokens + outputTokens;
-        const cachedInputTokens = result.usage.cachedInputTokens;
-        const cost = shouldComputeCosts && (inputTokens > 0 || outputTokens > 0) ? await computeCosts(model.modelId, model.provider, {
-          inputTokens,
-          outputTokens
-        }) : {};
-        const call = {
-          timestamp: /* @__PURE__ */ new Date(),
-          type: "generate",
-          model: model.modelId,
-          provider: model.provider,
-          finishReason: result.finishReason,
-          usage: {
-            inputTokens,
-            outputTokens,
-            totalTokens,
-            cachedInputTokens
-          },
-          cost,
-          tools,
-          durationMs
-        };
-        const effectiveTransport = options.transport ?? transport;
-        const transportResult = effectiveTransport(call);
-        if (transportResult instanceof Promise) {
-          transportResult.catch(() => {
-          });
-        }
-        options.onSuccess?.(call);
-        return result;
-      } catch (error) {
-        const durationMs = Date.now() - startTime;
-        const call = {
-          timestamp: /* @__PURE__ */ new Date(),
-          type: "generate",
-          model: model.modelId,
-          provider: model.provider,
-          usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-          cost: {},
-          tools: { toolCallCount: 0, toolResultCount: 0, toolCallNames: [] },
-          durationMs,
-          error: {
-            name: error instanceof Error ? error.name : "UnknownError",
-            message: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error ? error.stack : void 0
-          }
-        };
-        const effectiveTransport = options.transport ?? transport;
-        const transportResult = effectiveTransport(call);
-        if (transportResult instanceof Promise) {
-          transportResult.catch(() => {
-          });
-        }
-        options.onError?.(call);
-        throw error;
-      }
-    },
-    wrapStream: async ({ doStream, model }) => {
-      const startTime = Date.now();
-      try {
-        const { stream, ...rest } = await doStream();
-        const durationMs = Date.now() - startTime;
-        const call = {
-          timestamp: /* @__PURE__ */ new Date(),
-          type: "stream",
-          model: model.modelId,
-          provider: model.provider,
-          usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-          cost: {},
-          tools: { toolCallCount: 0, toolResultCount: 0, toolCallNames: [] },
-          durationMs
-        };
-        const effectiveTransport = options.transport ?? transport;
-        const transportResult = effectiveTransport(call);
-        if (transportResult instanceof Promise) {
-          transportResult.catch(() => {
-          });
-        }
-        options.onSuccess?.(call);
-        return { stream, ...rest };
-      } catch (error) {
-        const durationMs = Date.now() - startTime;
-        const call = {
-          timestamp: /* @__PURE__ */ new Date(),
-          type: "stream",
-          model: model.modelId,
-          provider: model.provider,
-          usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-          cost: {},
-          tools: { toolCallCount: 0, toolResultCount: 0, toolCallNames: [] },
-          durationMs,
-          error: {
-            name: error instanceof Error ? error.name : "UnknownError",
-            message: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error ? error.stack : void 0
-          }
-        };
-        const effectiveTransport = options.transport ?? transport;
-        const transportResult = effectiveTransport(call);
-        if (transportResult instanceof Promise) {
-          transportResult.catch(() => {
-          });
-        }
-        options.onError?.(call);
-        throw error;
-      }
-    }
-  };
-};
-const databuddyLLM = (options = {}) => {
-  const {
-    apiUrl,
-    apiKey,
-    clientId,
-    transport: customTransport,
-    computeCosts: defaultComputeCosts = true,
-    onSuccess: defaultOnSuccess,
-    onError: defaultOnError
-  } = options;
-  let transport;
-  if (customTransport) {
-    transport = customTransport;
-  } else {
-    const endpoint = apiUrl ?? process.env.DATABUDDY_API_URL ?? "https://basket.databuddy.cc/llm";
-    const client = clientId ?? process.env.DATABUDDY_CLIENT_ID;
-    const key = apiKey ?? process.env.DATABUDDY_API_KEY;
-    transport = createDefaultTransport(endpoint, client, key);
-  }
-  const track = (model, trackOptions = {}) => {
-    return wrapLanguageModel({
-      model,
-      middleware: createMiddleware(transport, {
-        computeCosts: trackOptions.computeCosts ?? defaultComputeCosts,
-        onSuccess: trackOptions.onSuccess ?? defaultOnSuccess,
-        onError: trackOptions.onError ?? defaultOnError,
-        transport: trackOptions.transport
-      })
-    });
-  };
-  return { track };
-};
 const httpTransport = (url, clientId, apiKey) => {
   return async (call) => {
     const headers = {
@@ -235,4 +396,328 @@ const httpTransport = (url, clientId, apiKey) => {
   };
 };
 
+const MAX_CONTENT_SIZE = 1048576;
+const extractProvider = (model) => {
+  return model.provider.toLowerCase().split(".")[0];
+};
+const createErrorCall = (traceId, type, model, provider, input, durationMs, error) => {
+  return {
+    timestamp: /* @__PURE__ */ new Date(),
+    traceId,
+    type,
+    model,
+    provider,
+    input,
+    output: [],
+    usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+    cost: {},
+    tools: { toolCallCount: 0, toolResultCount: 0, toolCallNames: [] },
+    durationMs,
+    error: {
+      name: error instanceof Error ? error.name : "UnknownError",
+      message: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    }
+  };
+};
+const sendCall = (call, transport, onSuccess, onError) => {
+  Promise.resolve(transport(call)).catch((error) => {
+    console.error("[databuddy] Failed to send AI log:", error);
+  });
+  call.error ? onError?.(call) : onSuccess?.(call);
+};
+const databuddyLLM = (options = {}) => {
+  const {
+    apiUrl,
+    apiKey,
+    clientId,
+    transport: customTransport,
+    computeCosts: defaultComputeCosts = true,
+    privacyMode: defaultPrivacyMode = false,
+    maxContentSize = MAX_CONTENT_SIZE,
+    onSuccess: defaultOnSuccess,
+    onError: defaultOnError
+  } = options;
+  const transport = customTransport ? customTransport : createDefaultTransport(
+    apiUrl ?? process.env.DATABUDDY_API_URL ?? "https://basket.databuddy.cc/llm",
+    clientId ?? process.env.DATABUDDY_CLIENT_ID,
+    apiKey ?? process.env.DATABUDDY_API_KEY
+  );
+  const track = (model, trackOptions = {}) => {
+    const getEffectiveTransport = () => {
+      if (trackOptions.transport) {
+        return trackOptions.transport;
+      }
+      if (trackOptions.clientId && trackOptions.clientId !== clientId) {
+        return createDefaultTransport(
+          apiUrl ?? process.env.DATABUDDY_API_URL ?? "https://basket.databuddy.cc/llm",
+          trackOptions.clientId,
+          apiKey ?? process.env.DATABUDDY_API_KEY
+        );
+      }
+      return transport;
+    };
+    return Object.create(model, {
+      doGenerate: {
+        value: async (params) => {
+          const startTime = Date.now();
+          const traceId = trackOptions.traceId ?? generateTraceId();
+          const effectiveTransport = getEffectiveTransport();
+          try {
+            const result = await model.doGenerate(params);
+            const durationMs = Date.now() - startTime;
+            const tools = extractToolInfo(
+              result.content,
+              params
+            );
+            const provider = extractProvider(model);
+            const usage = extractUsage(result.usage, result.providerMetadata);
+            adjustAnthropicV3CacheTokens(model, provider, usage);
+            const cost = (trackOptions.computeCosts ?? defaultComputeCosts) && (usage.inputTokens > 0 || usage.outputTokens > 0) ? await computeCosts(model.modelId, model.provider, {
+              inputTokens: usage.inputTokens,
+              outputTokens: usage.outputTokens
+            }) : {};
+            const input = trackOptions.privacyMode ?? defaultPrivacyMode ? [] : mapPromptToMessages(
+              params.prompt,
+              maxContentSize
+            );
+            const output = trackOptions.privacyMode ?? defaultPrivacyMode ? [] : mapResultToMessages(
+              result.content
+            );
+            const rawFinishReason = result.finishReason;
+            let finishReason;
+            if (typeof rawFinishReason === "string") {
+              finishReason = rawFinishReason;
+            } else if (rawFinishReason && typeof rawFinishReason === "object") {
+              if ("unified" in rawFinishReason) {
+                finishReason = rawFinishReason.unified;
+              } else if ("type" in rawFinishReason) {
+                finishReason = rawFinishReason.type;
+              }
+            }
+            const call = {
+              timestamp: /* @__PURE__ */ new Date(),
+              traceId,
+              type: "generate",
+              model: result.response?.modelId ?? model.modelId,
+              provider,
+              finishReason,
+              input,
+              output,
+              usage,
+              cost,
+              tools,
+              durationMs,
+              httpStatus: 200
+            };
+            sendCall(
+              call,
+              effectiveTransport,
+              trackOptions.onSuccess ?? defaultOnSuccess,
+              trackOptions.onError ?? defaultOnError
+            );
+            return result;
+          } catch (error) {
+            const durationMs = Date.now() - startTime;
+            const input = trackOptions.privacyMode ?? defaultPrivacyMode ? [] : mapPromptToMessages(
+              params.prompt,
+              maxContentSize
+            );
+            const call = createErrorCall(
+              traceId,
+              "generate",
+              model.modelId,
+              extractProvider(model),
+              input,
+              durationMs,
+              error
+            );
+            sendCall(
+              call,
+              effectiveTransport,
+              trackOptions.onSuccess ?? defaultOnSuccess,
+              trackOptions.onError ?? defaultOnError
+            );
+            throw error;
+          }
+        },
+        writable: true,
+        configurable: true,
+        enumerable: false
+      },
+      doStream: {
+        value: async (params) => {
+          const startTime = Date.now();
+          const traceId = trackOptions.traceId ?? generateTraceId();
+          const effectiveTransport = getEffectiveTransport();
+          try {
+            const { stream, ...rest } = await model.doStream(params);
+            let generatedText = "";
+            let reasoningText = "";
+            let finishReason;
+            let providerMetadata;
+            let usage = {};
+            const toolCallsInProgress = /* @__PURE__ */ new Map();
+            const sources = [];
+            const transformStream = new TransformStream({
+              transform(chunk, controller) {
+                if (chunk.type === "text-delta") {
+                  generatedText += chunk.delta;
+                }
+                if (chunk.type === "reasoning-delta") {
+                  reasoningText += chunk.delta;
+                }
+                if (chunk.type === "tool-input-start") {
+                  toolCallsInProgress.set(chunk.id, {
+                    toolCallId: chunk.id,
+                    toolName: chunk.toolName,
+                    input: ""
+                  });
+                }
+                if (chunk.type === "tool-input-delta") {
+                  const toolCall = toolCallsInProgress.get(chunk.id);
+                  if (toolCall) {
+                    toolCall.input += chunk.delta;
+                  }
+                }
+                if (chunk.type === "tool-call") {
+                  const input = chunk.input;
+                  toolCallsInProgress.set(chunk.toolCallId, {
+                    toolCallId: chunk.toolCallId,
+                    toolName: chunk.toolName,
+                    input: typeof input === "string" ? input : JSON.stringify(input ?? {})
+                  });
+                }
+                if (chunk.type === "source") {
+                  const sourceChunk = chunk;
+                  sources.push({
+                    sourceType: sourceChunk.sourceType ?? "unknown",
+                    id: sourceChunk.id ?? "",
+                    url: sourceChunk.url ?? "",
+                    title: sourceChunk.title ?? ""
+                  });
+                }
+                if (chunk.type === "finish") {
+                  providerMetadata = chunk.providerMetadata;
+                  const additionalTokenValues = extractAdditionalTokenValues(
+                    providerMetadata
+                  );
+                  const chunkUsage = chunk.usage ?? {};
+                  usage = {
+                    inputTokens: extractTokenCount(chunk.usage?.inputTokens),
+                    outputTokens: extractTokenCount(chunk.usage?.outputTokens),
+                    reasoningTokens: extractReasoningTokens(chunkUsage),
+                    cacheReadInputTokens: extractCacheReadTokens(chunkUsage),
+                    ...additionalTokenValues
+                  };
+                  const rawFinishReason = chunk.finishReason;
+                  if (typeof rawFinishReason === "string") {
+                    finishReason = rawFinishReason;
+                  } else if (rawFinishReason && typeof rawFinishReason === "object") {
+                    if ("unified" in rawFinishReason) {
+                      finishReason = rawFinishReason.unified;
+                    } else if ("type" in rawFinishReason) {
+                      finishReason = rawFinishReason.type;
+                    }
+                  }
+                }
+                controller.enqueue(chunk);
+              },
+              flush: async () => {
+                const durationMs = Date.now() - startTime;
+                const webSearchCount = extractWebSearchCount(
+                  providerMetadata,
+                  usage
+                );
+                const finalUsageObj = {
+                  ...usage,
+                  webSearchCount
+                };
+                const finalUsage = extractUsage(
+                  finalUsageObj,
+                  providerMetadata
+                );
+                const provider = extractProvider(model);
+                adjustAnthropicV3CacheTokens(model, provider, finalUsage);
+                const output = trackOptions.privacyMode ?? defaultPrivacyMode ? [] : buildStreamOutput(
+                  generatedText,
+                  reasoningText,
+                  toolCallsInProgress,
+                  sources
+                );
+                const tools = {
+                  toolCallCount: toolCallsInProgress.size,
+                  toolResultCount: 0,
+                  toolCallNames: [
+                    ...new Set(
+                      [...toolCallsInProgress.values()].map((t) => t.toolName)
+                    )
+                  ],
+                  availableTools: params.tools?.map((t) => t.name)
+                };
+                const cost = (trackOptions.computeCosts ?? defaultComputeCosts) && (finalUsage.inputTokens > 0 || finalUsage.outputTokens > 0) ? await computeCosts(model.modelId, model.provider, {
+                  inputTokens: finalUsage.inputTokens,
+                  outputTokens: finalUsage.outputTokens
+                }) : {};
+                const input = trackOptions.privacyMode ?? defaultPrivacyMode ? [] : mapPromptToMessages(
+                  params.prompt,
+                  maxContentSize
+                );
+                const call = {
+                  timestamp: /* @__PURE__ */ new Date(),
+                  traceId,
+                  type: "stream",
+                  model: model.modelId,
+                  provider,
+                  finishReason,
+                  input,
+                  output,
+                  usage: finalUsage,
+                  cost,
+                  tools,
+                  durationMs,
+                  httpStatus: 200
+                };
+                sendCall(
+                  call,
+                  effectiveTransport,
+                  trackOptions.onSuccess ?? defaultOnSuccess,
+                  trackOptions.onError ?? defaultOnError
+                );
+              }
+            });
+            return { stream: stream.pipeThrough(transformStream), ...rest };
+          } catch (error) {
+            const durationMs = Date.now() - startTime;
+            const input = trackOptions.privacyMode ?? defaultPrivacyMode ? [] : mapPromptToMessages(
+              params.prompt,
+              maxContentSize
+            );
+            const call = createErrorCall(
+              traceId,
+              "stream",
+              model.modelId,
+              extractProvider(model),
+              input,
+              durationMs,
+              error
+            );
+            sendCall(
+              call,
+              effectiveTransport,
+              trackOptions.onSuccess ?? defaultOnSuccess,
+              trackOptions.onError ?? defaultOnError
+            );
+            throw error;
+          }
+        },
+        writable: true,
+        configurable: true,
+        enumerable: false
+      }
+    });
+  };
+  return { track };
+};
+
 export { databuddyLLM, httpTransport };