neatlogs 1.0.2 → 1.0.3

package/dist/index.cjs

@@ -40,6 +40,7 @@ __export(index_exports, {
   UserPromptTemplate: () => UserPromptTemplate,
   __version__: () => __version__,
   bindTemplates: () => bindTemplates,
+  createAITelemetry: () => createAITelemetry,
   createPrompt: () => createPrompt,
   deletePrompt: () => deletePrompt,
   fetchPrompt: () => fetchPrompt,
@@ -57,7 +58,8 @@ __export(index_exports, {
   shutdown: () => shutdown,
   span: () => span,
   trace: () => trace2,
-  updatePrompt: () => updatePrompt
+  updatePrompt: () => updatePrompt,
+  wrapAISDK: () => wrapAISDK
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -132,6 +134,9 @@ var SCOPE_PATTERNS = {
   // Neatlogs custom instrumentations
   "@neatlogs/instrumentation-google-genai": { provider: "google", framework: "google_genai" },
   "@neatlogs/instrumentation-mastra": { framework: "mastra" },
+  "@neatlogs/instrumentation-ai-sdk": { framework: "ai_sdk" },
+  // Vercel AI SDK native scope (the `ai` package emits this directly)
+  ai: { framework: "ai_sdk" },
   // OpenInference instrumentations (npm @arizeai scope names)
   "@arizeai/openinference-instrumentation-openai": { provider: "openai", framework: "openai" },
   "@arizeai/openinference-instrumentation-anthropic": { provider: "anthropic", framework: "anthropic" },
@@ -219,6 +224,8 @@ function parseInstrumentationScope(scopeName) {
     result.framework = "haystack";
   } else if (scopeLower.includes("dspy")) {
     result.framework = "dspy";
+  } else if (scopeLower.includes("vercel-ai") || scopeLower.includes("ai-sdk")) {
+    result.framework = "ai_sdk";
   }
   if (scopeLower.includes("openai")) {
     result.provider = "openai";
@@ -1231,6 +1238,7 @@ var UnifiedAttributeProcessor = class {
     this.addCrewaiTokenUsageFallback(attrs);
     this.addReasoningTokensFromOutputValue(attrs);
     this.addCrewaiKickoffTelemetry(attrs);
+    this.extractVercelAiSdkAttrs(attrs);
     this.extractToolCalls(attrs);
     for (const [k, v] of Object.entries(attrs)) {
       const m = INPUT_MSG_TOOL_RE.exec(k);
@@ -1591,6 +1599,167 @@ var UnifiedAttributeProcessor = class {
       attrs["llm.invocation_parameters"] = JSON.stringify(existing);
     }
   }
+  // ── Vercel AI SDK extraction ───────────────────────
+  /**
+   * The Vercel AI SDK emits its own `ai.*` namespace alongside `gen_ai.*`. Map
+   * the AI-SDK-specific keys onto the canonical `llm.*` / `gen_ai.*` / `tool.*`
+   * keys that the existing pipeline already understands. Span-kind inference
+   * runs first so downstream `applyNamespaceMapping` resolves it correctly.
+   */
+  extractVercelAiSdkAttrs(attrs) {
+    const spanName = attrs["_span_name"] ?? "";
+    const isAiSdkSpan = spanName.startsWith("ai.") || "ai.model.id" in attrs || "ai.toolCall.name" in attrs;
+    if (!isAiSdkSpan) return;
+    if (!("openinference.span.kind" in attrs)) {
+      if (spanName === "ai.toolCall") {
+        attrs["openinference.span.kind"] = "TOOL";
+      } else if (spanName.startsWith("ai.embed")) {
+        attrs["openinference.span.kind"] = "EMBEDDING";
+      } else if (spanName.startsWith("ai.rerank")) {
+        attrs["openinference.span.kind"] = "RERANKER";
+      } else if (spanName.endsWith(".doStream") || spanName.endsWith(".doGenerate") || spanName.endsWith(".doRerank") || spanName.endsWith(".doEmbed")) {
+        if (spanName.includes("embed")) {
+          attrs["openinference.span.kind"] = "EMBEDDING";
+        } else if (spanName.includes("rerank")) {
+          attrs["openinference.span.kind"] = "RERANKER";
+        } else {
+          attrs["openinference.span.kind"] = "LLM";
+        }
+      } else if (spanName === "ai.generateText" || spanName === "ai.streamText" || spanName === "ai.generateObject" || spanName === "ai.streamObject") {
+        attrs["openinference.span.kind"] = "CHAIN";
+      }
+    }
+    if ("ai.model.id" in attrs && !("llm.model_name" in attrs)) {
+      attrs["llm.model_name"] = attrs["ai.model.id"];
+    }
+    if ("ai.model.provider" in attrs && !("llm.provider" in attrs)) {
+      const raw = String(attrs["ai.model.provider"]);
+      attrs["llm.provider"] = raw.split(".")[0];
+    }
+    if ("ai.usage.promptTokens" in attrs && !("llm.token_count.prompt" in attrs)) {
+      attrs["llm.token_count.prompt"] = attrs["ai.usage.promptTokens"];
+    }
+    if ("ai.usage.completionTokens" in attrs && !("llm.token_count.completion" in attrs)) {
+      attrs["llm.token_count.completion"] = attrs["ai.usage.completionTokens"];
+    }
+    if ("ai.usage.totalTokens" in attrs && !("llm.token_count.total" in attrs)) {
+      attrs["llm.token_count.total"] = attrs["ai.usage.totalTokens"];
+    }
+    const settingMap = {
+      "ai.settings.temperature": "gen_ai.request.temperature",
+      "ai.settings.maxTokens": "gen_ai.request.max_tokens",
+      "ai.settings.topP": "gen_ai.request.top_p",
+      "ai.settings.topK": "gen_ai.request.top_k",
+      "ai.settings.frequencyPenalty": "gen_ai.request.frequency_penalty",
+      "ai.settings.presencePenalty": "gen_ai.request.presence_penalty",
+      "ai.settings.stopSequences": "gen_ai.request.stop_sequences"
+    };
+    for (const [src, tgt] of Object.entries(settingMap)) {
+      if (src in attrs && !(tgt in attrs)) {
+        attrs[tgt] = attrs[src];
+      }
+    }
+    if (!("llm.invocation_parameters" in attrs)) {
+      const params = {};
+      if ("gen_ai.request.temperature" in attrs) params.temperature = attrs["gen_ai.request.temperature"];
+      if ("gen_ai.request.max_tokens" in attrs) params.max_tokens = attrs["gen_ai.request.max_tokens"];
+      if ("gen_ai.request.top_p" in attrs) params.top_p = attrs["gen_ai.request.top_p"];
+      if ("gen_ai.request.top_k" in attrs) params.top_k = attrs["gen_ai.request.top_k"];
+      if ("gen_ai.request.frequency_penalty" in attrs) params.frequency_penalty = attrs["gen_ai.request.frequency_penalty"];
+      if ("gen_ai.request.presence_penalty" in attrs) params.presence_penalty = attrs["gen_ai.request.presence_penalty"];
+      if ("gen_ai.request.stop_sequences" in attrs) params.stop_sequences = attrs["gen_ai.request.stop_sequences"];
+      if (Object.keys(params).length > 0) {
+        attrs["llm.invocation_parameters"] = JSON.stringify(params);
+      }
+    }
+    if ("ai.operationId" in attrs && !("gen_ai.operation.name" in attrs)) {
+      attrs["gen_ai.operation.name"] = attrs["ai.operationId"];
+    }
+    if ("ai.response.text" in attrs && !("llm.output_messages.0.message.content" in attrs)) {
+      attrs["llm.output_messages.0.message.role"] = "assistant";
+      attrs["llm.output_messages.0.message.content"] = attrs["ai.response.text"];
+    }
+    if ("ai.response.finishReason" in attrs && !("llm.response.finish_reason" in attrs)) {
+      attrs["llm.response.finish_reason"] = attrs["ai.response.finishReason"];
+    }
+    if ("ai.response.id" in attrs && !("gen_ai.response.id" in attrs)) {
+      attrs["gen_ai.response.id"] = attrs["ai.response.id"];
+    }
+    const rawMessages = attrs["ai.prompt.messages"];
+    if (typeof rawMessages === "string") {
+      try {
+        const parsed = JSON.parse(rawMessages);
+        if (Array.isArray(parsed)) {
+          parsed.forEach((msg, i) => {
+            if (msg && typeof msg === "object") {
+              if (typeof msg.role === "string") {
+                attrs[`llm.input_messages.${i}.message.role`] = msg.role;
+              }
+              if (typeof msg.content === "string") {
+                attrs[`llm.input_messages.${i}.message.content`] = msg.content;
+              } else if (msg.content !== void 0) {
+                attrs[`llm.input_messages.${i}.message.content`] = JSON.stringify(msg.content);
+              }
+            }
+          });
+        }
+      } catch {
+      }
+    }
+    const rawToolCalls = attrs["ai.response.toolCalls"];
+    if (typeof rawToolCalls === "string") {
+      try {
+        const parsed = JSON.parse(rawToolCalls);
+        if (Array.isArray(parsed)) {
+          parsed.forEach((tc, i) => {
+            if (tc && typeof tc === "object") {
+              if (tc.toolName !== void 0) {
+                attrs[`llm.output_messages.0.message.tool_calls.${i}.tool_call.function.name`] = tc.toolName;
+              }
+              if (tc.args !== void 0) {
+                const argStr = typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args);
+                attrs[`llm.output_messages.0.message.tool_calls.${i}.tool_call.function.arguments`] = argStr;
+              }
+              if (tc.toolCallId !== void 0) {
+                attrs[`llm.output_messages.0.message.tool_calls.${i}.tool_call.id`] = tc.toolCallId;
+              }
+            }
+          });
+        }
+      } catch {
+      }
+    }
+    if ("ai.value" in attrs && typeof attrs["ai.value"] === "string") {
+      try {
+        attrs["ai.value"] = JSON.parse(attrs["ai.value"]);
+      } catch {
+      }
+    }
+    if ("ai.values" in attrs && Array.isArray(attrs["ai.values"])) {
+      attrs["ai.values"] = JSON.stringify(attrs["ai.values"].map((v) => {
+        if (typeof v === "string") {
+          try {
+            return JSON.parse(v);
+          } catch {
+          }
+        }
+        return v;
+      }));
+    }
+    if (spanName === "ai.toolCall") {
+      if ("ai.toolCall.name" in attrs && !("tool.name" in attrs)) {
+        attrs["tool.name"] = attrs["ai.toolCall.name"];
+      }
+      if ("ai.toolCall.args" in attrs && !("input.value" in attrs)) {
+        const raw = attrs["ai.toolCall.args"];
+        attrs["input.value"] = typeof raw === "string" ? raw : JSON.stringify(raw);
+      }
+      if ("ai.toolCall.result" in attrs && !("output.value" in attrs)) {
+        const raw = attrs["ai.toolCall.result"];
+        attrs["output.value"] = typeof raw === "string" ? raw : JSON.stringify(raw);
+      }
+    }
+  }
   // ── CrewAI-specific ─────────────────────────────────
   addCrewaiTokenUsageFallback(attrs) {
     const usage = attrs["neatlogs.crew.token_usage"];
@@ -1766,8 +1935,9 @@ var UnifiedAttributeProcessor = class {
       if (oiKind) {
         unified["neatlogs.span.kind"] = String(oiKind).toLowerCase();
       } else {
+        const scopeName = attrs["neatlogs.instrumentation.name"] ?? "";
         const spanName = attrs["_span_name"] ?? "";
-        if (spanName) {
+        if (spanName && scopeName !== "next.js") {
           const inferred = inferSpanKindFromName(spanName).toLowerCase();
           unified["neatlogs.span.kind"] = inferred;
         }
@@ -1776,7 +1946,8 @@ var UnifiedAttributeProcessor = class {
     const llmRequestType = (attrs["llm.request.type"] ?? "").toLowerCase();
     const genAiOperation = (attrs["gen_ai.operation.name"] ?? "").toLowerCase();
     const spanNameLower = (attrs["_span_name"] ?? "").toLowerCase();
-    if (llmRequestType === "rerank" || genAiOperation === "rerank" || spanNameLower.includes("rerank")) {
+    const hasExplicitKind = "openinference.span.kind" in attrs || "traceloop.span.kind" in attrs;
+    if (!hasExplicitKind && (llmRequestType === "rerank" || genAiOperation === "rerank" || spanNameLower.includes("rerank"))) {
       unified["neatlogs.span.kind"] = "reranker";
     }
     const spanKind = (attrs["neatlogs.span.kind"] ?? attrs["openinference.span.kind"] ?? "").toLowerCase();
@@ -1955,7 +2126,7 @@ var UnifiedAttributeProcessor = class {
   filterEmbeddingVectors(attrs) {
     const filtered = {};
     for (const [key, value] of Object.entries(attrs)) {
-      if (key.includes(".embedding.vector") || key.includes(".embeddings.")) {
+      if (key.includes(".embedding.vector") || key.includes(".embeddings.") || key === "ai.embeddings" || key === "ai.embedding") {
         if (this.debug) {
           logger2.debug(`[FILTER] Dropped embedding vector key: ${key}`);
         }
@@ -1982,7 +2153,7 @@ var UnifiedAttributeProcessor = class {
    * Check if the raw span kind indicates CLIENT (OTel SpanKind.CLIENT = 3).
    */
   isHttpLikeSpanKind(kind) {
-    if (typeof kind === "number") return kind === 2;
+    if (typeof kind === "number") return kind === 3;
     return String(kind).toUpperCase() === "CLIENT";
   }
 };
@@ -2613,21 +2784,24 @@ var attribute_mapping_default = {
             total: {
               sources: [
                 "llm.token_count.total",
-                "llm.usage.total_tokens"
+                "llm.usage.total_tokens",
+                "ai.usage.totalTokens"
               ],
               target: "neatlogs.llm.token_count.total"
             },
             prompt: {
               sources: [
                 "llm.token_count.prompt",
-                "gen_ai.usage.input_tokens"
+                "gen_ai.usage.input_tokens",
+                "ai.usage.promptTokens"
               ],
               target: "neatlogs.llm.token_count.prompt"
             },
             completion: {
               sources: [
                 "llm.token_count.completion",
-                "gen_ai.usage.output_tokens"
+                "gen_ai.usage.output_tokens",
+                "ai.usage.completionTokens"
               ],
               target: "neatlogs.llm.token_count.completion"
             },
@@ -3218,24 +3392,62 @@ var attribute_mapping_default = {
       },
       reranker: {
         description: "Reranker model attributes",
+        applies_to: ["reranker"],
         model_name: {
           sources: [
-            "reranker.model_name"
+            "reranker.model_name",
+            "ai.model.id"
           ],
           target: "neatlogs.reranker.model_name"
         },
+        provider: {
+          sources: [
+            "ai.model.provider"
+          ],
+          target: "neatlogs.reranker.provider",
+          description: "Vercel AI SDK reranker provider (e.g. gateway, cohere)"
+        },
         query: {
           sources: [
-            "reranker.query"
+            "reranker.query",
+            "ai.rerank.query"
           ],
           target: "neatlogs.reranker.query"
         },
+        documents: {
+          sources: [
+            "ai.documents"
+          ],
+          target: "neatlogs.reranker.input_documents",
+          description: "Vercel AI SDK rerank input documents array"
+        },
+        ranking: {
+          sources: [
+            "ai.ranking"
+          ],
+          target: "neatlogs.reranker.output_documents",
+          description: "Vercel AI SDK rerank output ranking array"
+        },
+        ranking_type: {
+          sources: [
+            "ai.ranking.type"
+          ],
+          target: "neatlogs.reranker.ranking_type",
+          description: "Vercel AI SDK rerank type (e.g. text)"
+        },
         top_k: {
           sources: [
             "reranker.top_k"
           ],
           target: "neatlogs.reranker.top_k"
         },
+        max_retries: {
+          sources: [
+            "ai.settings.maxRetries"
+          ],
+          target: "neatlogs.reranker.max_retries",
+          description: "Vercel AI SDK max retries setting"
+        },
         input_documents: {
           sources: {
             id: [
@@ -3273,9 +3485,19 @@ var attribute_mapping_default = {
       },
       embedding: {
         description: "Embedding model attributes",
+        applies_to: ["embedding"],
+        input: {
+          sources: [
+            "ai.value",
+            "ai.values"
+          ],
+          target: "neatlogs.embedding.input",
+          description: "Vercel AI SDK embed/embedMany input value(s)"
+        },
         model_name: {
           sources: [
-            "embedding.model_name"
+            "embedding.model_name",
+            "ai.model.id"
           ],
           target: "neatlogs.embedding.model_name"
         },
@@ -3293,7 +3515,8 @@ var attribute_mapping_default = {
         },
         token_count: {
           sources: [
-            "embedding.token_count"
+            "embedding.token_count",
+            "ai.usage.tokens"
           ],
           target: "neatlogs.embedding.token_count"
         },
@@ -3748,10 +3971,13 @@ var AttributeMapper = class {
   mapNestedConfig(config, attributes, spanKind) {
     const mapped = {};
     for (const [key, value] of Object.entries(config)) {
-      if (["description", "sources", "target", "indexed", "priority", "values"].includes(key)) {
+      if (["description", "sources", "target", "indexed", "priority", "values", "applies_to"].includes(key)) {
         continue;
       }
       if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        if (Array.isArray(value.applies_to) && spanKind && !value.applies_to.includes(spanKind)) {
+          continue;
+        }
         if ("sources" in value) {
           if (value.indexed) {
             const target = value.target ?? "";
@@ -3790,6 +4016,9 @@ var AttributeMapper = class {
     for (const [sectionName, sectionConfig] of Object.entries(this.mappings)) {
       if (sectionName === "span_kind" || sectionName === "keep_as_is" || sectionName === "ignore") continue;
       if (typeof sectionConfig === "object" && sectionConfig !== null) {
+        if (Array.isArray(sectionConfig.applies_to) && spanKind && !sectionConfig.applies_to.includes(spanKind)) {
+          continue;
+        }
         if ("mappings" in sectionConfig) {
           const nestedMapped = this.mapNestedConfig(
             sectionConfig.mappings,
@@ -3798,8 +4027,11 @@ var AttributeMapper = class {
           );
           Object.assign(mapped, nestedMapped);
           for (const [subKey, subVal] of Object.entries(sectionConfig)) {
-            if (subKey === "mappings" || subKey === "description") continue;
+            if (subKey === "mappings" || subKey === "description" || subKey === "applies_to") continue;
             if (typeof subVal === "object" && subVal !== null && !Array.isArray(subVal)) {
+              if (Array.isArray(subVal.applies_to) && spanKind && !subVal.applies_to.includes(spanKind)) {
+                continue;
+              }
               if ("sources" in subVal) {
                 if (subVal.indexed) {
                   const target = subVal.target ?? "";
@@ -4179,7 +4411,7 @@ var NeatlogsSpanProcessor = class {
         for (const key of Object.keys(unifiedAttrs)) {
           if (key.includes("input_messages") || key.includes("output_messages") || key.includes("gen_ai.prompt") || key.includes("gen_ai.completion") || key.includes(".content")) {
             keysToRemove.push(key);
-          } else if (skipOutput && (key === "neatlogs.embedding.input" || key === "neatlogs.embedding.output")) {
+          } else if (key === "neatlogs.embedding.output" || skipOutput && key === "neatlogs.embedding.input") {
             keysToRemove.push(key);
           }
         }
@@ -4482,7 +4714,7 @@ var FilteringExporter = class {
   _delegate;
   export(spans, resultCallback) {
     const filtered = spans.filter(
-      (s) => !s.attributes["neatlogs.dropped"]
+      (s) => !s.attributes["neatlogs.dropped"] && s.instrumentationLibrary.name !== "next.js"
     );
     if (filtered.length === 0) {
       resultCallback({ code: 0 });
@@ -4738,7 +4970,8 @@ var INSTRUMENTATION_REGISTRY = {
       "huggingface_hub",
       "litellm",
       "google_genai",
-      "portkey"
+      "portkey",
+      "ai_sdk"
     ],
     embedding: ["openai", "cohere", "huggingface", "vertexai", "mistralai", "ollama"],
     retrieval: [
@@ -4767,7 +5000,8 @@ var INSTRUMENTATION_REGISTRY = {
       "pydantic_ai",
       "smolagents",
       "strands",
-      "pipecat"
+      "pipecat",
+      "ai_sdk"
     ],
     tool: ["langchain", "llamaindex", "haystack", "mcp"],
     http: ["requests", "httpx", "urllib3", "aiohttp"],
@@ -4780,6 +5014,15 @@ var INSTRUMENTATION_REGISTRY = {
       neatlogs: null,
       default_span_kind: "LLM"
     },
+    ai_sdk: {
+      openinference: null,
+      openllmetry: null,
+      // The wrapper is opt-in per call site; init({ instrumentations: ['ai_sdk'] })
+      // is a no-op. This registry entry exists so scope detection and tagging stay
+      // consistent with other LLM/agent libraries.
+      neatlogs: "@neatlogs/instrumentation-ai-sdk",
+      default_span_kind: "LLM"
+    },
     openai: {
       openinference: "@arizeai/openinference-instrumentation-openai",
       openllmetry: null,
@@ -5107,63 +5350,14 @@ function getLibraryInfo(library) {
 var logger12 = getLogger();
 var InstrumentationManager = class {
   provider;
-  debug;
-  excludedUrls;
   _instrumented = [];
   constructor(options) {
     this.provider = options.provider;
-    this.debug = options.debug ?? false;
-    this.excludedUrls = options.excludedUrls ?? [];
   }
   /** Get list of successfully instrumented libraries. */
   get instrumented() {
     return [...this._instrumented];
   }
-  /**
-   * Instrument HTTP (fetch/undici) for W3C traceparent context propagation.
-   * Always called by init().
-   */
-  async instrumentHttp() {
-    const excludedUrls = this.excludedUrls;
-    const ignoreOutgoingRequestHook = excludedUrls.length > 0 ? (request) => {
-      try {
-        const url = typeof request === "string" ? request : request?.href ?? request?.path ?? "";
-        return excludedUrls.some((excluded) => url.includes(excluded));
-      } catch {
-        return false;
-      }
-    } : void 0;
-    try {
-      const { HttpInstrumentation } = await import("@opentelemetry/instrumentation-http");
-      const httpInstr = new HttpInstrumentation({
-        ...ignoreOutgoingRequestHook ? { ignoreOutgoingRequestHook } : {}
-      });
-      httpInstr.setTracerProvider(this.provider);
-      httpInstr.enable();
-      logger12.debug("Instrumented http/https for context propagation");
-    } catch {
-      logger12.debug("http instrumentation not available \u2014 skipping");
-    }
-    try {
-      const { UndiciInstrumentation } = await import("@opentelemetry/instrumentation-undici");
-      const ignoreUndiciHook = excludedUrls.length > 0 ? (request) => {
-        try {
-          const url = `${request?.origin ?? ""}${request?.path ?? ""}`;
-          return excludedUrls.some((excluded) => url.includes(excluded));
-        } catch {
-          return false;
-        }
-      } : void 0;
-      const undiciInstr = new UndiciInstrumentation({
-        ...ignoreUndiciHook ? { ignoreRequestHook: ignoreUndiciHook } : {}
-      });
-      undiciInstr.setTracerProvider(this.provider);
-      undiciInstr.enable();
-      logger12.debug("Instrumented undici for context propagation");
-    } catch {
-      logger12.debug("undici instrumentation not available \u2014 skipping");
-    }
-  }
   /**
    * Instrument the specified libraries.
    * Priority: neatlogs custom > OpenInference > skip
@@ -5832,10 +6026,8 @@ async function init(options = {}) {
   }
   const manager = new InstrumentationManager({
     provider,
-    debug: options.debug,
-    excludedUrls: [baseUrl, endpoint].filter(Boolean)
+    debug: options.debug
   });
-  await manager.instrumentHttp();
   if (options.instrumentations?.length) {
     await manager.instrument(options.instrumentations);
     if (options.debug) {
@@ -6126,6 +6318,166 @@ async function getMastraObservability() {
   return _cached;
 }
 
+// src/ai-sdk.ts
+var import_api8 = require("@opentelemetry/api");
+var TRACER_NAME2 = "neatlogs.ai-sdk";
+function createAITelemetry(opts = {}) {
+  const userMeta = opts.metadata ?? {};
+  return {
+    isEnabled: true,
+    recordInputs: true,
+    recordOutputs: true,
+    tracer: import_api8.trace.getTracer(TRACER_NAME2),
+    metadata: { ...userMeta, neatlogsWrapped: true }
+  };
+}
+function safeStringify2(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+function setInputValue(span2, opts) {
+  if (opts && ("prompt" in opts || "messages" in opts)) {
+    const input = opts.messages ?? opts.prompt;
+    const stringified2 = safeStringify2(input);
+    if (stringified2) {
+      span2.setAttribute("input.value", stringified2);
+    }
+    return;
+  }
+  const stringified = safeStringify2(opts);
+  if (stringified) {
+    span2.setAttribute("input.value", stringified);
+  }
+}
+function setOutputValue(span2, result) {
+  if (result && typeof result === "object") {
+    const r = result;
+    if ("text" in r && "finishReason" in r) {
+      const text = String(r.text ?? "");
+      if (text) {
+        span2.setAttribute("output.value", text);
+      }
+      if (r.finishReason) {
+        span2.setAttribute("gen_ai.finish_reason", String(r.finishReason));
+      }
+      return;
+    }
+  }
+  const stringified = safeStringify2(result);
+  if (stringified) {
+    span2.setAttribute("output.value", stringified);
+  }
+}
+var WRAPPED_FUNCTIONS = [
+  "generateText",
+  "streamText",
+  "generateObject",
+  "streamObject",
+  "embed",
+  "embedMany",
+  "rerank"
+];
+function wrapAISDK(aiModule) {
+  const wrapped = { ...aiModule };
+  for (const name of WRAPPED_FUNCTIONS) {
+    const original = aiModule[name];
+    if (typeof original !== "function") continue;
+    if (name === "streamText" || name === "streamObject") {
+      wrapped[name] = createSyncWrapper(name, original);
+    } else {
+      wrapped[name] = createAsyncWrapper(name, original);
+    }
+  }
+  return wrapped;
+}
+function rootSpanKind(name) {
+  if (name === "embed" || name === "embedMany" || name === "rerank") return "CHAIN";
+  return "WORKFLOW";
+}
+function getParentContext() {
+  const activeSpan = import_api8.trace.getActiveSpan();
+  if (activeSpan) {
+    const instrScope = activeSpan.instrumentationLibrary?.name ?? "";
+    if (instrScope === "next.js") {
+      return import_api8.ROOT_CONTEXT;
+    }
+  }
+  return import_api8.context.active();
+}
+function createAsyncWrapper(name, original) {
+  return async function wrappedAsyncFn(opts) {
+    const tracer = import_api8.trace.getTracer(TRACER_NAME2);
+    return tracer.startActiveSpan(
+      `ai.${name}`,
+      { attributes: { "openinference.span.kind": rootSpanKind(name) } },
+      getParentContext(),
+      async (span2) => {
+        try {
+          const isEmbedOrRerank = name === "embed" || name === "embedMany" || name === "rerank";
+          if (!isEmbedOrRerank) {
+            setInputValue(span2, opts);
+          }
+          if (name === "rerank" && opts?.query) {
+            span2.setAttribute("ai.rerank.query", String(opts.query));
+          }
+          const merged = mergeTelemetry(opts);
+          const result = await original(merged);
+          if (!isEmbedOrRerank) {
+            setOutputValue(span2, result);
+          }
+          return result;
+        } catch (err) {
+          recordSpanError(span2, err);
+          throw err;
+        } finally {
+          span2.end();
+        }
+      }
+    );
+  };
+}
+function createSyncWrapper(name, original) {
+  return function wrappedSyncFn(opts) {
+    const tracer = import_api8.trace.getTracer(TRACER_NAME2);
+    return tracer.startActiveSpan(`ai.${name}`, { attributes: { "openinference.span.kind": rootSpanKind(name) } }, getParentContext(), (span2) => {
+      try {
+        setInputValue(span2, opts);
+        const merged = mergeTelemetry(opts);
+        const result = original(merged);
+        return result;
+      } catch (err) {
+        recordSpanError(span2, err);
+        throw err;
+      } finally {
+        span2.end();
+      }
+    });
+  };
+}
+function mergeTelemetry(opts) {
+  const baseTelemetry = createAITelemetry({
+    metadata: opts?.experimental_telemetry?.metadata
+  });
+  return {
+    ...opts,
+    experimental_telemetry: {
+      ...opts?.experimental_telemetry,
+      ...baseTelemetry
+    }
+  };
+}
+function recordSpanError(span2, err) {
+  if (err instanceof Error) {
+    span2.setStatus({ code: import_api8.SpanStatusCode.ERROR, message: err.message });
+    span2.recordException(err);
+  } else {
+    span2.setStatus({ code: import_api8.SpanStatusCode.ERROR, message: String(err) });
+  }
+}
+
 // src/core/llm-binder.ts
 var logger15 = getLogger();
 function bindTemplates(llm, systemTpl, userTpl, compiledVars) {
@@ -6187,6 +6539,7 @@ function bindTemplates(llm, systemTpl, userTpl, compiledVars) {
   UserPromptTemplate,
   __version__,
   bindTemplates,
+  createAITelemetry,
   createPrompt,
   deletePrompt,
   fetchPrompt,
@@ -6204,6 +6557,7 @@ function bindTemplates(llm, systemTpl, userTpl, compiledVars) {
   shutdown,
   span,
   trace,
-  updatePrompt
+  updatePrompt,
+  wrapAISDK
 });
 //# sourceMappingURL=index.cjs.map