@brizz/sdk 0.1.2 → 0.1.3-rc.1

package/dist/preload.cjs

@@ -251,938 +251,6 @@ var import_instrumentation_pinecone = require("@traceloop/instrumentation-pineco
 var import_instrumentation_qdrant = require("@traceloop/instrumentation-qdrant");
 var import_instrumentation_together = require("@traceloop/instrumentation-together");
 var import_instrumentation_vertexai = require("@traceloop/instrumentation-vertexai");
-
-// src/internal/instrumentation/vercel-ai/instrumentation.ts
-var import_instrumentation = require("@opentelemetry/instrumentation");
-
-// src/internal/instrumentation/vercel-ai/patchers/base-patcher.ts
-var import_api2 = require("@opentelemetry/api");
-
-// src/internal/instrumentation/vercel-ai/semconv.ts
-var ATTR_GEN_AI_SYSTEM = "gen_ai.system";
-var ATTR_GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
-var ATTR_GEN_AI_REQUEST_MODEL = "gen_ai.request.model";
-var ATTR_GEN_AI_REQUEST_MAX_TOKENS = "gen_ai.request.max_tokens";
-var ATTR_GEN_AI_REQUEST_TEMPERATURE = "gen_ai.request.temperature";
-var ATTR_GEN_AI_REQUEST_TOP_P = "gen_ai.request.top_p";
-var ATTR_GEN_AI_REQUEST_TOP_K = "gen_ai.request.top_k";
-var ATTR_GEN_AI_REQUEST_STOP_SEQUENCES = "gen_ai.request.stop_sequences";
-var ATTR_GEN_AI_REQUEST_FREQUENCY_PENALTY = "gen_ai.request.frequency_penalty";
-var ATTR_GEN_AI_REQUEST_PRESENCE_PENALTY = "gen_ai.request.presence_penalty";
-var ATTR_GEN_AI_RESPONSE_ID = "gen_ai.response.id";
-var ATTR_GEN_AI_RESPONSE_MODEL = "gen_ai.response.model";
-var ATTR_GEN_AI_RESPONSE_FINISH_REASONS = "gen_ai.response.finish_reasons";
-var ATTR_GEN_AI_TOKEN_TYPE = "gen_ai.token.type";
-var ATTR_GEN_AI_PROMPT = "gen_ai.prompt";
-var ATTR_GEN_AI_COMPLETION = "gen_ai.completion";
-var ATTR_GEN_AI_OPENAI_API_BASE = "gen_ai.openai.api_base";
-var ATTR_EVENT_NAME = "event.name";
-var EVENT_GEN_AI_USER_MESSAGE = "gen_ai.user.message";
-var EVENT_GEN_AI_ASSISTANT_MESSAGE = "gen_ai.assistant.message";
-var EVENT_GEN_AI_SYSTEM_MESSAGE = "gen_ai.system.message";
-var EVENT_GEN_AI_TOOL_MESSAGE = "gen_ai.tool.message";
-var METRIC_GEN_AI_CLIENT_OPERATION_DURATION = "gen_ai.client.operation.duration";
-var METRIC_GEN_AI_CLIENT_TOKEN_USAGE = "gen_ai.client.token.usage";
-var OPERATION_NAME_CHAT = "chat";
-var OPERATION_NAME_EMBEDDINGS = "embeddings";
-var TOKEN_TYPE_INPUT = "input";
-var TOKEN_TYPE_OUTPUT = "output";
-var PROVIDER_OPENAI = "openai";
-var PROVIDER_ANTHROPIC = "anthropic";
-var PROVIDER_GOOGLE = "google";
-var PROVIDER_AMAZON = "amazon";
-var PROVIDER_AZURE = "azure";
-var PROVIDER_VERCEL = "vercel";
-var PROVIDER_UNKNOWN = "unknown";
-var SPAN_NAME_GEN_AI_CHAT = "gen_ai.chat";
-var SPAN_NAME_GEN_AI_EMBEDDINGS = "gen_ai.embeddings";
-
-// src/internal/instrumentation/vercel-ai/utils.ts
-function detectProvider(model) {
-  if (typeof model === "object" && model !== null) {
-    const modelObj = model;
-    if (modelObj.provider) {
-      return {
-        system: normalizeProviderName(modelObj.provider),
-        apiBase: extractApiBase(modelObj)
-      };
-    }
-    if (modelObj.modelId) {
-      return detectProviderFromModelId(modelObj.modelId);
-    }
-  }
-  if (typeof model === "string") {
-    return detectProviderFromModelId(model);
-  }
-  return { system: PROVIDER_UNKNOWN };
-}
-function detectProviderFromModelId(modelId) {
-  const lowerModel = modelId.toLowerCase();
-  if (lowerModel.startsWith("gpt-") || lowerModel.startsWith("text-davinci-") || lowerModel.startsWith("text-embedding-") || lowerModel.startsWith("dall-e") || lowerModel.startsWith("whisper-") || lowerModel.startsWith("tts-")) {
-    return { system: PROVIDER_OPENAI };
-  }
-  if (lowerModel.startsWith("claude-")) {
-    return { system: PROVIDER_ANTHROPIC };
-  }
-  if (lowerModel.startsWith("gemini-") || lowerModel.startsWith("palm-") || lowerModel.includes("bison") || lowerModel.includes("gecko")) {
-    return { system: PROVIDER_GOOGLE };
-  }
-  if (lowerModel.startsWith("amazon.") || lowerModel.startsWith("anthropic.claude-") || lowerModel.startsWith("ai21.") || lowerModel.startsWith("cohere.") || lowerModel.startsWith("meta.llama")) {
-    return { system: PROVIDER_AMAZON };
-  }
-  if (lowerModel.includes("azure") || lowerModel.includes(".openai.azure.com")) {
-    return { system: PROVIDER_AZURE };
-  }
-  const parts = modelId.split(/[-._/]/);
-  if (parts.length > 0 && parts[0]) {
-    return { system: normalizeProviderName(parts[0]) };
-  }
-  return { system: PROVIDER_UNKNOWN };
-}
-function normalizeProviderName(provider) {
-  const normalized = provider.toLowerCase().trim();
-  switch (normalized) {
-    case "openai":
-    case "open-ai":
-    case "open_ai": {
-      return PROVIDER_OPENAI;
-    }
-    case "anthropic":
-    case "claude": {
-      return PROVIDER_ANTHROPIC;
-    }
-    case "google":
-    case "vertex":
-    case "vertexai":
-    case "vertex-ai":
-    case "gemini": {
-      return PROVIDER_GOOGLE;
-    }
-    case "amazon":
-    case "aws":
-    case "bedrock":
-    case "amazon-bedrock": {
-      return PROVIDER_AMAZON;
-    }
-    case "azure":
-    case "azure-openai":
-    case "microsoft": {
-      return PROVIDER_AZURE;
-    }
-    case "vercel":
-    case "vercel-ai": {
-      return PROVIDER_VERCEL;
-    }
-    default: {
-      return normalized;
-    }
-  }
-}
-function extractApiBase(model) {
-  if (typeof model === "object" && model !== null) {
-    const anyModel = model;
-    return anyModel.apiBase || anyModel.baseURL || anyModel.endpoint || void 0;
-  }
-  return void 0;
-}
-function extractModelId(model) {
-  if (typeof model === "string") {
-    return model;
-  }
-  if (typeof model === "object" && model !== null) {
-    return model.modelId || "unknown";
-  }
-  return "unknown";
-}
-function messagesToAttributes(messages, prefix, captureContent) {
-  const attributes = {};
-  for (const [index, msg] of messages.entries()) {
-    const baseKey = `${prefix}.${index}`;
-    attributes[`${baseKey}.role`] = msg.role;
-    if (captureContent && msg.content) {
-      if (typeof msg.content === "string") {
-        attributes[`${baseKey}.content`] = msg.content;
-      } else if (Array.isArray(msg.content)) {
-        const textParts = msg.content.filter((part) => part.type === "text" && part.text).map((part) => part.text).join(" ");
-        if (textParts) {
-          attributes[`${baseKey}.content`] = textParts;
-        }
-      }
-    }
-    if (msg.toolInvocations && msg.toolInvocations.length > 0) {
-      attributes[`${baseKey}.tool_calls`] = msg.toolInvocations.length;
-    }
-  }
-  return attributes;
-}
-function promptToAttributes(prompt, captureContent) {
-  const attributes = {};
-  attributes[`${ATTR_GEN_AI_PROMPT}.0.role`] = "user";
-  if (captureContent) {
-    attributes[`${ATTR_GEN_AI_PROMPT}.0.content`] = prompt;
-  }
-  return attributes;
-}
-function completionToAttributes(text, finishReason, captureContent) {
-  const attributes = {};
-  attributes[`${ATTR_GEN_AI_COMPLETION}.0.role`] = "assistant";
-  if (captureContent) {
-    attributes[`${ATTR_GEN_AI_COMPLETION}.0.content`] = text;
-  }
-  if (finishReason) {
-    attributes[`${ATTR_GEN_AI_COMPLETION}.0.finish_reason`] = finishReason;
-  }
-  return attributes;
-}
-function tokenUsageToAttributes(usage) {
-  if (!usage) {
-    return {};
-  }
-  const attributes = {};
-  if (usage.inputTokens !== void 0) {
-    attributes["gen_ai.usage.prompt_tokens"] = usage.inputTokens;
-    attributes["gen_ai.usage.input_tokens"] = usage.inputTokens;
-    attributes["llm.usage.prompt_tokens"] = usage.inputTokens;
-  } else if (usage.promptTokens !== void 0) {
-    attributes["gen_ai.usage.prompt_tokens"] = usage.promptTokens;
-    attributes["gen_ai.usage.input_tokens"] = usage.promptTokens;
-    attributes["llm.usage.prompt_tokens"] = usage.promptTokens;
-  }
-  if (usage.outputTokens !== void 0) {
-    attributes["gen_ai.usage.completion_tokens"] = usage.outputTokens;
-    attributes["gen_ai.usage.output_tokens"] = usage.outputTokens;
-    attributes["llm.usage.completion_tokens"] = usage.outputTokens;
-  } else if (usage.completionTokens !== void 0) {
-    attributes["gen_ai.usage.completion_tokens"] = usage.completionTokens;
-    attributes["gen_ai.usage.output_tokens"] = usage.completionTokens;
-    attributes["llm.usage.completion_tokens"] = usage.completionTokens;
-  }
-  if (usage.totalTokens === void 0) {
-    const inputTokens = usage.inputTokens || usage.promptTokens;
-    const outputTokens = usage.outputTokens || usage.completionTokens;
-    if (inputTokens !== void 0 && outputTokens !== void 0) {
-      const totalTokens = inputTokens + outputTokens;
-      attributes["gen_ai.usage.total_tokens"] = totalTokens;
-      attributes["llm.usage.total_tokens"] = totalTokens;
-    }
-  } else {
-    attributes["gen_ai.usage.total_tokens"] = usage.totalTokens;
-    attributes["llm.usage.total_tokens"] = usage.totalTokens;
-  }
-  return attributes;
-}
-function shouldRecordError(error) {
-  if (error instanceof Error) {
-    const message = error.message.toLowerCase();
-    if (message.includes("abort") || message.includes("cancel")) {
-      return false;
-    }
-  }
-  return true;
-}
-function getEnvBool(name) {
-  const value = process.env[name];
-  if (value === void 0) {
-    return void 0;
-  }
-  return value.toLowerCase() === "true" || value === "1";
-}
-
-// src/internal/instrumentation/vercel-ai/patchers/base-patcher.ts
-var BasePatcher = class {
-  constructor(context8) {
-    this.context = context8;
-  }
-  createSpan(spanName, params, operationName, additionalAttributes) {
-    const provider = detectProvider(params.model);
-    const modelId = extractModelId(params.model);
-    const span = this.context.tracer.startSpan(spanName, {
-      kind: import_api2.SpanKind.CLIENT,
-      attributes: {
-        [ATTR_GEN_AI_SYSTEM]: provider.system,
-        [ATTR_GEN_AI_OPERATION_NAME]: operationName,
-        [ATTR_GEN_AI_REQUEST_MODEL]: modelId,
-        ...params.maxTokens && { [ATTR_GEN_AI_REQUEST_MAX_TOKENS]: params.maxTokens },
-        ...params.temperature !== void 0 && {
-          [ATTR_GEN_AI_REQUEST_TEMPERATURE]: params.temperature
-        },
-        ...params.topP !== void 0 && { [ATTR_GEN_AI_REQUEST_TOP_P]: params.topP },
-        ...params.topK !== void 0 && { [ATTR_GEN_AI_REQUEST_TOP_K]: params.topK },
-        ...params.frequencyPenalty !== void 0 && {
-          [ATTR_GEN_AI_REQUEST_FREQUENCY_PENALTY]: params.frequencyPenalty
-        },
-        ...params.presencePenalty !== void 0 && {
-          [ATTR_GEN_AI_REQUEST_PRESENCE_PENALTY]: params.presencePenalty
-        },
-        ...params.stopSequences && {
-          [ATTR_GEN_AI_REQUEST_STOP_SEQUENCES]: params.stopSequences
-        },
-        ...provider.apiBase && { [ATTR_GEN_AI_OPENAI_API_BASE]: provider.apiBase },
-        ...additionalAttributes
-      }
-    });
-    return { span, provider, modelId };
-  }
-  handleError(error, span) {
-    if (shouldRecordError(error)) {
-      span.recordException(error);
-      span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message: error.message });
-    }
-  }
-  finalizeDuration(span, startTime, config, provider, modelId, operationName) {
-    if (config.enableMetrics) {
-      const duration = (globalThis.performance.now() - startTime) / 1e3;
-      this.context.recordDurationMetric(duration, provider.system, modelId, operationName);
-    }
-    span.end();
-  }
-};
-
-// src/internal/instrumentation/vercel-ai/patchers/generate-text-patcher.ts
-var import_api3 = require("@opentelemetry/api");
-var GenerateTextPatcher = class extends BasePatcher {
-  patch(original) {
-    return async (params) => {
-      const config = this.context.getConfig();
-      const startTime = globalThis.performance.now();
-      const { span, provider, modelId } = this.createSpan(
-        SPAN_NAME_GEN_AI_CHAT,
-        params,
-        OPERATION_NAME_CHAT
-      );
-      if (params.prompt) {
-        span.setAttributes(
-          promptToAttributes(params.prompt, config.captureMessageContent || false)
-        );
-      } else if (params.messages) {
-        span.setAttributes(
-          messagesToAttributes(
-            params.messages,
-            "gen_ai.prompt",
-            config.captureMessageContent || false
-          )
-        );
-        if (config.emitEvents) {
-          this.context.emitMessageEvents(params.messages, provider.system, span);
-        }
-      }
-      try {
-        const result = await import_api3.context.with(
-          import_api3.trace.setSpan(import_api3.context.active(), span),
-          () => original(params)
-        );
-        if (result.response) {
-          span.setAttributes({
-            ...result.response.id && { [ATTR_GEN_AI_RESPONSE_ID]: result.response.id },
-            ...result.response.model && { [ATTR_GEN_AI_RESPONSE_MODEL]: result.response.model }
-          });
-        }
-        if (result.finishReason) {
-          span.setAttribute(ATTR_GEN_AI_RESPONSE_FINISH_REASONS, [result.finishReason]);
-        }
-        span.setAttributes(
-          completionToAttributes(
-            result.text,
-            result.finishReason,
-            config.captureMessageContent || false
-          )
-        );
-        const usage = result.usage || result.totalUsage || result.steps?.[0]?.usage;
-        if (usage) {
-          span.setAttributes(tokenUsageToAttributes(usage));
-          if (config.enableMetrics) {
-            this.context.recordTokenMetrics(usage, provider.system, modelId);
-          }
-        }
-        if (config.emitEvents) {
-          this.context.emitAssistantMessageEvent(result.text, provider.system, span);
-        }
-        span.setStatus({ code: import_api3.SpanStatusCode.OK });
-        return result;
-      } catch (error) {
-        this.handleError(error, span);
-        throw error;
-      } finally {
-        this.finalizeDuration(span, startTime, config, provider, modelId, OPERATION_NAME_CHAT);
-      }
-    };
-  }
-};
-
-// src/internal/instrumentation/vercel-ai/patchers/stream-text-patcher.ts
-var import_api4 = require("@opentelemetry/api");
-var StreamTextPatcher = class extends BasePatcher {
-  constructor(context8, streamHandler) {
-    super(context8);
-    this.streamHandler = streamHandler;
-  }
-  patch(original) {
-    return async (params) => {
-      const config = this.context.getConfig();
-      const startTime = globalThis.performance.now();
-      const { span, provider, modelId } = this.createSpan(
-        SPAN_NAME_GEN_AI_CHAT,
-        params,
-        OPERATION_NAME_CHAT,
-        { "gen_ai.streaming": true }
-      );
-      if (params.prompt) {
-        span.setAttributes(
-          promptToAttributes(params.prompt, config.captureMessageContent || false)
-        );
-      } else if (params.messages) {
-        span.setAttributes(
-          messagesToAttributes(
-            params.messages,
-            "gen_ai.prompt",
-            config.captureMessageContent || false
-          )
-        );
-        if (config.emitEvents) {
-          this.context.emitMessageEvents(params.messages, provider.system, span);
-        }
-      }
-      try {
-        const stream = await import_api4.context.with(
-          import_api4.trace.setSpan(import_api4.context.active(), span),
-          () => original(params)
-        );
-        return this.streamHandler.wrapStream(stream, span, config, provider, modelId, startTime);
-      } catch (error) {
-        this.handleError(error, span);
-        span.end();
-        throw error;
-      }
-    };
-  }
-};
-
-// src/internal/instrumentation/vercel-ai/patchers/embeddings-patcher.ts
-var import_api5 = require("@opentelemetry/api");
-var EmbeddingsPatcher = class extends BasePatcher {
-  patch(original, isMany = false) {
-    return async (params) => {
-      const config = this.context.getConfig();
-      const startTime = globalThis.performance.now();
-      const additionalAttributes = isMany ? { "gen_ai.embeddings.count": params.values ? params.values.length : 0 } : {};
-      const { span, provider, modelId } = this.createSpan(
-        SPAN_NAME_GEN_AI_EMBEDDINGS,
-        params,
-        OPERATION_NAME_EMBEDDINGS,
-        additionalAttributes
-      );
-      if (!isMany && config.captureMessageContent && params.value) {
-        span.setAttribute("gen_ai.prompt.0.content", params.value);
-      }
-      try {
-        const result = await import_api5.context.with(
-          import_api5.trace.setSpan(import_api5.context.active(), span),
-          () => original(params)
-        );
-        if (result.response) {
-          span.setAttributes({
-            ...result.response.id && { [ATTR_GEN_AI_RESPONSE_ID]: result.response.id },
-            ...result.response.model && { [ATTR_GEN_AI_RESPONSE_MODEL]: result.response.model }
-          });
-        }
-        if (isMany) {
-          if (result.embeddings && result.embeddings.length > 0 && result.embeddings[0]) {
-            span.setAttribute("gen_ai.response.embedding_dimensions", result.embeddings[0].length);
-          }
-        } else {
-          if (result.embedding) {
-            span.setAttribute("gen_ai.response.embedding_dimensions", result.embedding.length);
-          }
-        }
-        if (result.usage) {
-          span.setAttributes(tokenUsageToAttributes(result.usage));
-          if (config.enableMetrics) {
-            this.context.recordTokenMetrics(result.usage, provider.system, modelId);
-          }
-        }
-        span.setStatus({ code: import_api5.SpanStatusCode.OK });
-        return result;
-      } catch (error) {
-        this.handleError(error, span);
-        throw error;
-      } finally {
-        this.finalizeDuration(span, startTime, config, provider, modelId, OPERATION_NAME_EMBEDDINGS);
-      }
-    };
-  }
-};
-
-// src/internal/instrumentation/vercel-ai/stream-handler.ts
-var import_api6 = require("@opentelemetry/api");
-var StreamHandler = class {
-  constructor(context8) {
-    this.context = context8;
-  }
-  wrapStream(stream, span, config, provider, modelId, startTime) {
-    const self = this;
-    let fullText = "";
-    let finishReason;
-    let usage;
-    let response;
-    const wrappedStream = new Proxy(stream, {
-      get(target, prop) {
-        if (prop === Symbol.asyncIterator) {
-          return async function* () {
-            try {
-              for await (const chunk of target) {
-                if (chunk.type === "text-delta" && chunk.textDelta) {
-                  fullText += chunk.textDelta;
-                } else if (chunk.type === "finish") {
-                  finishReason = chunk.finishReason;
-                  usage = chunk.usage;
-                } else if (chunk.type === "response-metadata") {
-                  response = chunk.response;
-                }
-                yield chunk;
-              }
-            } finally {
-              self.finalizeStream(
-                span,
-                config,
-                provider,
-                modelId,
-                startTime,
-                fullText,
-                finishReason,
-                usage,
-                response
-              );
-            }
-          };
-        }
-        if (prop === "textStream" || prop === "fullStream") {
-          const originalStream = target[prop];
-          return {
-            [Symbol.asyncIterator]: async function* () {
-              try {
-                for await (const chunk of originalStream) {
-                  if (prop === "textStream") {
-                    fullText += chunk;
-                  }
-                  yield chunk;
-                }
-              } finally {
-                const streamUsage = await target.usage.catch(() => null);
-                if (streamUsage) {
-                  usage = streamUsage;
-                }
-                self.finalizeStream(
-                  span,
-                  config,
-                  provider,
-                  modelId,
-                  startTime,
-                  fullText,
-                  finishReason,
-                  usage,
-                  response
-                );
-              }
-            }
-          };
-        }
-        const value = target[prop];
-        if (typeof value === "function") {
-          return value.bind(target);
-        }
-        return value;
-      }
-    });
-    return wrappedStream;
-  }
-  finalizeStream(span, config, provider, modelId, startTime, fullText, finishReason, usage, response) {
-    if (response) {
-      span.setAttributes({
-        ...response.id && { [ATTR_GEN_AI_RESPONSE_ID]: response.id },
-        ...response.model && { [ATTR_GEN_AI_RESPONSE_MODEL]: response.model }
-      });
-    }
-    if (finishReason) {
-      span.setAttribute(ATTR_GEN_AI_RESPONSE_FINISH_REASONS, [finishReason]);
-    }
-    if (fullText) {
-      span.setAttributes(
-        completionToAttributes(
-          fullText,
-          finishReason,
-          config.captureMessageContent || false
-        )
-      );
-    }
-    if (usage) {
-      span.setAttributes(tokenUsageToAttributes(usage));
-      if (config.enableMetrics) {
-        this.context.recordTokenMetrics(usage, provider.system, modelId);
-      }
-    }
-    if (config.enableMetrics) {
-      const duration = (performance.now() - startTime) / 1e3;
-      this.context.recordDurationMetric(duration, provider.system, modelId, OPERATION_NAME_CHAT);
-    }
-    span.setStatus({ code: import_api6.SpanStatusCode.OK });
-    span.end();
-  }
-};
-
-// src/internal/instrumentation/vercel-ai/telemetry-recorder.ts
-var import_api7 = require("@opentelemetry/api");
-var import_api_logs = require("@opentelemetry/api-logs");
-var TelemetryRecorder = class {
-  constructor(genaiClientOperationDuration, genaiClientTokenUsage, logger2) {
-    this.genaiClientOperationDuration = genaiClientOperationDuration;
-    this.genaiClientTokenUsage = genaiClientTokenUsage;
-    this.logger = logger2;
-  }
-  /**
-   * Record token usage metrics
-   */
-  recordTokenMetrics(usage, system, model) {
-    if (!this.genaiClientTokenUsage) {
-      return;
-    }
-    const commonAttrs = {
-      [ATTR_GEN_AI_SYSTEM]: system,
-      [ATTR_GEN_AI_REQUEST_MODEL]: model
-    };
-    const inputTokens = usage.inputTokens || usage.promptTokens;
-    const outputTokens = usage.outputTokens || usage.completionTokens;
-    if (inputTokens !== void 0) {
-      this.genaiClientTokenUsage.record(inputTokens, {
-        ...commonAttrs,
-        [ATTR_GEN_AI_TOKEN_TYPE]: TOKEN_TYPE_INPUT
-      });
-    }
-    if (outputTokens !== void 0) {
-      this.genaiClientTokenUsage.record(outputTokens, {
-        ...commonAttrs,
-        [ATTR_GEN_AI_TOKEN_TYPE]: TOKEN_TYPE_OUTPUT
-      });
-    }
-  }
-  /**
-   * Record operation duration metric
-   */
-  recordDurationMetric(duration, system, model, operation) {
-    if (!this.genaiClientOperationDuration) {
-      return;
-    }
-    this.genaiClientOperationDuration.record(duration, {
-      [ATTR_GEN_AI_SYSTEM]: system,
-      [ATTR_GEN_AI_REQUEST_MODEL]: model,
-      [ATTR_GEN_AI_OPERATION_NAME]: operation
-    });
-  }
-  /**
-   * Emit message events
-   */
-  emitMessageEvents(messages, system, span) {
-    if (!this.logger) {
-      return;
-    }
-    const ctx = import_api7.trace.setSpan(import_api7.context.active(), span);
-    for (const msg of messages) {
-      let eventName;
-      switch (msg.role) {
-        case "system": {
-          eventName = EVENT_GEN_AI_SYSTEM_MESSAGE;
-          break;
-        }
-        case "user": {
-          eventName = EVENT_GEN_AI_USER_MESSAGE;
-          break;
-        }
-        case "assistant": {
-          eventName = EVENT_GEN_AI_ASSISTANT_MESSAGE;
-          break;
-        }
-        case "tool":
-        case "function": {
-          eventName = EVENT_GEN_AI_TOOL_MESSAGE;
-          break;
-        }
-        default: {
-          continue;
-        }
-      }
-      this.logger.emit({
-        timestamp: Date.now(),
-        context: ctx,
-        severityNumber: import_api_logs.SeverityNumber.INFO,
-        attributes: {
-          [ATTR_EVENT_NAME]: eventName,
-          [ATTR_GEN_AI_SYSTEM]: system
-        },
-        body: {
-          role: msg.role,
-          content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
-          name: msg.name
-        }
-      });
-    }
-  }
-  /**
-   * Emit assistant message event
-   */
-  emitAssistantMessageEvent(text, system, span) {
-    if (!this.logger) {
-      return;
-    }
-    const ctx = import_api7.trace.setSpan(import_api7.context.active(), span);
-    this.logger.emit({
-      timestamp: Date.now(),
-      context: ctx,
-      severityNumber: import_api_logs.SeverityNumber.INFO,
-      attributes: {
-        [ATTR_EVENT_NAME]: EVENT_GEN_AI_ASSISTANT_MESSAGE,
-        [ATTR_GEN_AI_SYSTEM]: system
-      },
-      body: {
-        role: "assistant",
-        content: text
-      }
-    });
-  }
-};
-
-// src/internal/instrumentation/vercel-ai/instrumentation.ts
-var PACKAGE_NAME = "@brizz/vercel-ai-instrumentation";
-var PACKAGE_VERSION = "0.1.0";
-var VercelAIInstrumentation = class _VercelAIInstrumentation extends import_instrumentation.InstrumentationBase {
-  _genaiClientOperationDuration;
-  _genaiClientTokenUsage;
-  _telemetryRecorder;
-  _streamHandler;
-  _patchers = /* @__PURE__ */ new Map();
-  // Holds last patched namespace when available (reserved for future factory wrapping)
-  _vercelAiNamespace = null;
-  static _WRAPPED_SYMBOL = Symbol.for("brizz.vercel-ai.patched");
-  constructor(config = {}) {
-    super(PACKAGE_NAME, PACKAGE_VERSION, config);
-    const cfg = this.getConfig();
-    const envCC = getEnvBool("OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT");
-    if (envCC !== void 0) {
-      cfg.captureMessageContent = envCC;
-    }
-    this._initializeComponents();
-  }
-  setConfig(config = {}) {
-    const {
-      captureMessageContent = true,
-      enableMetrics = true,
-      emitEvents = true,
-      ...validConfig
-    } = config;
-    const fullConfig = {
-      ...validConfig,
-      captureMessageContent,
-      enableMetrics,
-      emitEvents
-    };
-    super.setConfig(fullConfig);
-  }
-  _initializeComponents() {
-    this._telemetryRecorder = new TelemetryRecorder(
-      this._genaiClientOperationDuration,
-      this._genaiClientTokenUsage,
-      this.logger
-    );
-    this._streamHandler = new StreamHandler({
-      recordTokenMetrics: this._telemetryRecorder.recordTokenMetrics.bind(this._telemetryRecorder),
-      recordDurationMetric: this._telemetryRecorder.recordDurationMetric.bind(
-        this._telemetryRecorder
-      )
-    });
-    const patcherContext = {
-      tracer: this.tracer,
-      getConfig: this.getConfig.bind(this),
-      recordTokenMetrics: this._telemetryRecorder.recordTokenMetrics.bind(this._telemetryRecorder),
-      recordDurationMetric: this._telemetryRecorder.recordDurationMetric.bind(
-        this._telemetryRecorder
-      ),
-      emitMessageEvents: this._telemetryRecorder.emitMessageEvents.bind(this._telemetryRecorder),
-      emitAssistantMessageEvent: this._telemetryRecorder.emitAssistantMessageEvent.bind(
-        this._telemetryRecorder
-      )
-    };
-    this._patchers.set("generateText", new GenerateTextPatcher(patcherContext));
-    this._patchers.set("streamText", new StreamTextPatcher(patcherContext, this._streamHandler));
-    this._patchers.set("embed", new EmbeddingsPatcher(patcherContext));
-    this._patchers.set("embedMany", new EmbeddingsPatcher(patcherContext));
-  }
-  init() {
-    return [
-      new import_instrumentation.InstrumentationNodeModuleDefinition(
-        "ai",
-        [">=4.0.0 <6"],
-        (moduleExports) => {
-          logger.info("Starting instrumentation of Vercel AI SDK module");
-          this._vercelAiNamespace = moduleExports;
-          const patched = this._patchModuleExports(moduleExports);
-          return patched ?? moduleExports;
-        },
-        (moduleExports) => {
-          logger.debug("Uninstrumenting @vercel/ai module");
-          return moduleExports;
-        }
-      )
-    ];
-  }
-  _updateMetricInstruments() {
-    const config = this.getConfig();
-    if (!config.enableMetrics) {
-      return;
-    }
-    this._genaiClientOperationDuration = this.meter.createHistogram(
-      METRIC_GEN_AI_CLIENT_OPERATION_DURATION,
-      {
-        description: "GenAI operation duration",
-        unit: "s",
-        advice: {
-          explicitBucketBoundaries: [
-            0.01,
-            0.02,
-            0.04,
-            0.08,
-            0.16,
-            0.32,
-            0.64,
-            1.28,
-            2.56,
-            5.12,
-            10.24,
-            20.48,
-            40.96,
-            81.92
-          ]
-        }
-      }
-    );
-    this._genaiClientTokenUsage = this.meter.createHistogram(METRIC_GEN_AI_CLIENT_TOKEN_USAGE, {
-      description: "Measures number of input and output tokens used",
-      unit: "{token}",
-      advice: {
-        explicitBucketBoundaries: [
-          1,
-          4,
-          16,
-          64,
-          256,
-          1024,
-          4096,
-          16384,
-          65536,
-          262144,
-          1048576,
-          4194304,
-          16777216,
-          67108864
-        ]
-      }
-    });
-    this._telemetryRecorder = new TelemetryRecorder(
-      this._genaiClientOperationDuration,
-      this._genaiClientTokenUsage,
-      this.logger
-    );
-  }
-  /**
-   * Patch known AI SDK functions in-place on the provided module exports object.
-   * This approach is compatible with both CJS and ESM module loaders.
-   */
-  _patchModuleExports(moduleExports) {
-    if (!moduleExports || typeof moduleExports !== "object") {
-      return null;
-    }
-    let inPlacePatched = true;
-    const wrapFunction = (name, isEmbedMany = false) => {
-      const current = moduleExports[name];
-      if (typeof current !== "function") {
-        return;
-      }
-      const currentFn = current;
-      if (currentFn[_VercelAIInstrumentation._WRAPPED_SYMBOL]) {
-        return;
-      }
-      const descriptor = Object.getOwnPropertyDescriptor(moduleExports, name);
-      if (descriptor && (!descriptor.writable || !descriptor.configurable) && !descriptor.set) {
-        inPlacePatched = false;
-        return;
-      }
-      const patcher = this._patchers.get(name);
-      if (!patcher) {
-        return;
-      }
-      const patched = isEmbedMany ? patcher.patch(currentFn, true) : patcher.patch(currentFn);
-      try {
-        Object.defineProperty(patched, _VercelAIInstrumentation._WRAPPED_SYMBOL, {
-          value: true,
-          enumerable: false,
-          configurable: false
-        });
-      } catch {
-      }
-      try {
-        moduleExports[name] = patched;
-      } catch {
-        inPlacePatched = false;
-      }
-    };
-    wrapFunction("generateText");
-    wrapFunction("streamText");
-    wrapFunction("embed");
-    wrapFunction("embedMany", true);
-    if (!inPlacePatched) {
-      const proxiedModule = new Proxy(moduleExports, {
-        get: (target, prop, receiver) => {
-          const originalValue = Reflect.get(target, prop, receiver);
-          if (typeof originalValue === "function" && typeof prop === "string" && this._patchers.has(prop)) {
-            const patcher = this._patchers.get(prop);
-            const isEmbedMany = prop === "embedMany";
-            const wrapped = isEmbedMany ? patcher.patch(originalValue, true) : patcher.patch(originalValue);
-            return wrapped;
-          }
-          return originalValue;
-        }
-      });
-      return proxiedModule;
-    }
-    return moduleExports;
-  }
-  /**
-   * Manual instrumentation hook for bundlers/Next.js. Applies in-place wrapping
-   * on the provided module namespace.
-   */
-  manuallyInstrument(module3) {
-    try {
-      const result = this._patchModuleExports(module3);
-      if (result !== null) {
-        logger.debug("Applied manual Vercel AI instrumentation");
-        this._vercelAiNamespace = result;
-        return result;
-      }
-      logger.warn("Manual Vercel AI instrumentation received invalid module");
-      return module3;
-    } catch (error) {
-      logger.error(`Failed manual Vercel AI instrumentation: ${String(error)}`);
-      return this._vercelAiNamespace || module3;
-    }
-  }
-  /**
-   * Wrap a created provider/client instance (factory return) when possible.
-   * Call this from wrappers that construct provider clients (e.g., OpenAI SDK).
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  wrapFactoryReturn(instance) {
-    return instance;
-  }
-};
-
-// src/internal/instrumentation/registry.ts
 var InstrumentationRegistry = class _InstrumentationRegistry {
   static instance;
   manualModules = null;
@@ -1258,8 +326,7 @@ var InstrumentationRegistry = class _InstrumentationRegistry {
       },
       { class: import_instrumentation_chromadb.ChromaDBInstrumentation, name: "ChromaDB", module: this.manualModules?.chromadb },
       { class: import_instrumentation_qdrant.QdrantInstrumentation, name: "Qdrant", module: this.manualModules?.qdrant },
-      { class: import_instrumentation_together.TogetherInstrumentation, name: "Together", module: this.manualModules?.together },
-      { class: VercelAIInstrumentation, name: "Vercel AI", module: this.manualModules?.vercelAI }
+      { class: import_instrumentation_together.TogetherInstrumentation, name: "Together", module: this.manualModules?.together }
     ];
     for (const config of instrumentationConfigs) {
       if (config.module) {
@@ -1278,13 +345,13 @@ var InstrumentationRegistry = class _InstrumentationRegistry {
 };
 
 // src/internal/log/logging.ts
-var import_api_logs2 = require("@opentelemetry/api-logs");
+var import_api_logs = require("@opentelemetry/api-logs");
 var import_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-http");
 var import_resources = require("@opentelemetry/resources");
 var import_sdk_logs2 = require("@opentelemetry/sdk-logs");
 
 // src/internal/log/processors/log-processor.ts
-var import_api9 = require("@opentelemetry/api");
+var import_api3 = require("@opentelemetry/api");
 var import_sdk_logs = require("@opentelemetry/sdk-logs");
 
 // src/internal/masking/patterns.ts
@@ -1910,10 +977,10 @@ function maskAttributes(attributes, rules, outputOriginalValue = false) {
 }
 
 // src/internal/semantic-conventions.ts
-var import_api8 = require("@opentelemetry/api");
+var import_api2 = require("@opentelemetry/api");
 var BRIZZ = "brizz";
 var PROPERTIES = "properties";
-var PROPERTIES_CONTEXT_KEY = (0, import_api8.createContextKey)(PROPERTIES);
+var PROPERTIES_CONTEXT_KEY = (0, import_api2.createContextKey)(PROPERTIES);
 
 // src/internal/log/processors/log-processor.ts
 var DEFAULT_LOG_MASKING_RULES = [
@@ -1934,7 +1001,7 @@ var BrizzSimpleLogRecordProcessor = class extends import_sdk_logs.SimpleLogRecor
     if (maskingConfig) {
       maskLog(logRecord, maskingConfig);
     }
-    const associationProperties = import_api9.context.active().getValue(PROPERTIES_CONTEXT_KEY);
+    const associationProperties = import_api3.context.active().getValue(PROPERTIES_CONTEXT_KEY);
     if (associationProperties) {
       for (const [key, value] of Object.entries(associationProperties)) {
         logRecord.setAttribute(`${BRIZZ}.${key}`, value);
@@ -1954,7 +1021,7 @@ var BrizzBatchLogRecordProcessor = class extends import_sdk_logs.BatchLogRecordP
     if (maskingConfig) {
       maskLog(logRecord, maskingConfig);
     }
-    const associationProperties = import_api9.context.active().getValue(PROPERTIES_CONTEXT_KEY);
+    const associationProperties = import_api3.context.active().getValue(PROPERTIES_CONTEXT_KEY);
     if (associationProperties) {
       for (const [key, value] of Object.entries(associationProperties)) {
         logRecord.setAttribute(`${BRIZZ}.${key}`, value);
@@ -2091,7 +1158,7 @@ var LoggingModule = class _LoggingModule {
   /**
    * Emit a custom event to the telemetry pipeline
    */
-  emitEvent(name, attributes, body, severityNumber = import_api_logs2.SeverityNumber.INFO) {
+  emitEvent(name, attributes, body, severityNumber = import_api_logs.SeverityNumber.INFO) {
     logger.debug("Attempting to emit event", {
       name,
       hasAttributes: !!attributes,
@@ -2263,8 +1330,131 @@ function getMetricsReader() {
 var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
 
 // src/internal/trace/processors/span-processor.ts
-var import_api10 = require("@opentelemetry/api");
+var import_api4 = require("@opentelemetry/api");
 var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+
+// src/internal/trace/transformations/vercel-ai.ts
+var import_ai_semantic_conventions = require("@traceloop/ai-semantic-conventions");
+var AI_GENERATE_TEXT_DO_GENERATE = "ai.generateText.doGenerate";
+var AI_STREAM_TEXT_DO_STREAM = "ai.streamText.doStream";
+var HANDLED_SPAN_NAMES = {
+  [AI_GENERATE_TEXT_DO_GENERATE]: "gen_ai.chat",
+  [AI_STREAM_TEXT_DO_STREAM]: "gen_ai.chat",
+  "ai.streamText": "ai.streamText",
+  "ai.toolCall": (span) => {
+    const toolName = span.attributes["ai.toolCall.name"];
+    return `${toolName}.tool`;
+  }
+};
+var AI_RESPONSE_TEXT = "ai.response.text";
+var AI_PROMPT_MESSAGES = "ai.prompt.messages";
+var AI_USAGE_PROMPT_TOKENS = "ai.usage.promptTokens";
+var AI_USAGE_COMPLETION_TOKENS = "ai.usage.completionTokens";
+var AI_MODEL_PROVIDER = "ai.model.provider";
+var transformAiSdkSpanName = (span) => {
+  if (span.name in HANDLED_SPAN_NAMES) {
+    if (typeof HANDLED_SPAN_NAMES[span.name] === "function") {
+      span.name = HANDLED_SPAN_NAMES[span.name](span);
+    } else {
+      span.name = HANDLED_SPAN_NAMES[span.name];
+    }
+  }
+};
+var transformResponseText = (attributes) => {
+  if (AI_RESPONSE_TEXT in attributes) {
+    attributes[`${import_ai_semantic_conventions.SpanAttributes.LLM_COMPLETIONS}.0.content`] = attributes[AI_RESPONSE_TEXT];
+    attributes[`${import_ai_semantic_conventions.SpanAttributes.LLM_COMPLETIONS}.0.role`] = "assistant";
+    delete attributes[AI_RESPONSE_TEXT];
+  }
+};
+var transformPromptMessages = (attributes) => {
+  if (AI_PROMPT_MESSAGES in attributes) {
+    try {
+      const messages = JSON.parse(attributes[AI_PROMPT_MESSAGES]);
+      messages.forEach((msg, index) => {
+        logger.debug("Transforming prompt message", { msg, type: typeof msg.content });
+        if (typeof msg.content === "string") {
+          attributes[`${import_ai_semantic_conventions.SpanAttributes.LLM_PROMPTS}.${index}.content`] = msg.content;
+        } else {
+          if (Array.isArray(msg.content) && msg.content.length > 0) {
+            const lastContent = msg.content[msg.content.length - 1];
+            if (lastContent.text) {
+              attributes[`${import_ai_semantic_conventions.SpanAttributes.LLM_PROMPTS}.${index}.content`] = lastContent.text;
+            }
+          } else {
+            attributes[`${import_ai_semantic_conventions.SpanAttributes.LLM_PROMPTS}.${index}.content`] = JSON.stringify(
+              msg.content
+            );
+          }
+        }
+        attributes[`${import_ai_semantic_conventions.SpanAttributes.LLM_PROMPTS}.${index}.role`] = msg.role;
+      });
+      delete attributes[AI_PROMPT_MESSAGES];
+    } catch {
+    }
+  }
+};
+var transformPromptTokens = (attributes) => {
+  if (AI_USAGE_PROMPT_TOKENS in attributes) {
+    attributes[`${import_ai_semantic_conventions.SpanAttributes.LLM_USAGE_PROMPT_TOKENS}`] = attributes[AI_USAGE_PROMPT_TOKENS];
+    delete attributes[AI_USAGE_PROMPT_TOKENS];
+  }
+};
+var transformCompletionTokens = (attributes) => {
+  if (AI_USAGE_COMPLETION_TOKENS in attributes) {
+    attributes[`${import_ai_semantic_conventions.SpanAttributes.LLM_USAGE_COMPLETION_TOKENS}`] = attributes[AI_USAGE_COMPLETION_TOKENS];
+    delete attributes[AI_USAGE_COMPLETION_TOKENS];
+  }
+};
+var calculateTotalTokens = (attributes) => {
+  const promptTokens = attributes[`${import_ai_semantic_conventions.SpanAttributes.LLM_USAGE_PROMPT_TOKENS}`];
+  const completionTokens = attributes[`${import_ai_semantic_conventions.SpanAttributes.LLM_USAGE_COMPLETION_TOKENS}`];
+  if (promptTokens && completionTokens) {
+    attributes[`${import_ai_semantic_conventions.SpanAttributes.LLM_USAGE_TOTAL_TOKENS}`] = Number(promptTokens) + Number(completionTokens);
+  }
+};
+var transformVendor = (attributes) => {
+  if (AI_MODEL_PROVIDER in attributes) {
+    const vendor = attributes[AI_MODEL_PROVIDER];
+    if (vendor && vendor.startsWith("openai")) {
+      attributes[import_ai_semantic_conventions.SpanAttributes.LLM_SYSTEM] = "OpenAI";
+    } else {
+      attributes[import_ai_semantic_conventions.SpanAttributes.LLM_SYSTEM] = vendor;
+    }
+    delete attributes[AI_MODEL_PROVIDER];
+  }
+};
+var transformAiSdkAttributes = (attributes) => {
+  transformResponseText(attributes);
+  transformPromptMessages(attributes);
+  transformPromptTokens(attributes);
+  transformCompletionTokens(attributes);
+  calculateTotalTokens(attributes);
+  transformVendor(attributes);
+};
+var shouldHandleSpan = (span) => {
+  return span.name in HANDLED_SPAN_NAMES;
+};
+var transformAiSdkSpan = (span) => {
+  for (const key in span.attributes) {
+    if (Number.isNaN(span.attributes[key])) {
+      span.attributes[key] = 0;
+    }
+  }
+  logger.debug("Transforming AI SDK span", {
+    spanName: span.name,
+    spanContext: span.spanContext(),
+    attributes: span.attributes
+  });
+  if (!shouldHandleSpan(span)) {
+    logger.debug("Skipping span transformation", { spanName: span.name });
+    return;
+  }
+  transformAiSdkSpanName(span);
+  transformAiSdkAttributes(span.attributes);
+};
+
+// src/internal/trace/processors/span-processor.ts
 var DEFAULT_MASKING_RULES = [
   {
     mode: "partial",
@@ -2275,16 +1465,6 @@ var DEFAULT_MASKING_RULES = [
     mode: "partial",
     attributePattern: "gen_ai.completion",
     patterns: DEFAULT_PII_PATTERNS
-  },
-  {
-    mode: "partial",
-    attributePattern: "traceloop.entity.input",
-    patterns: DEFAULT_PII_PATTERNS
-  },
-  {
-    mode: "partial",
-    attributePattern: "traceloop.entity.output",
-    patterns: DEFAULT_PII_PATTERNS
   }
 ];
 var BrizzSimpleSpanProcessor = class extends import_sdk_trace_base.SimpleSpanProcessor {
@@ -2309,7 +1489,7 @@ var BrizzSimpleSpanProcessor = class extends import_sdk_trace_base.SimpleSpanPro
     if (maskingConfig) {
       maskSpan(span, maskingConfig);
     }
-    const associationProperties = import_api10.context.active().getValue(PROPERTIES_CONTEXT_KEY);
+    const associationProperties = import_api4.context.active().getValue(PROPERTIES_CONTEXT_KEY);
     if (associationProperties) {
       for (const [key, value] of Object.entries(associationProperties)) {
         span.setAttribute(`${BRIZZ}.${key}`, value);
@@ -2317,6 +1497,10 @@ var BrizzSimpleSpanProcessor = class extends import_sdk_trace_base.SimpleSpanPro
     }
     super.onStart(span, parentContext);
   }
+  onEnd(span) {
+    transformAiSdkSpan(span);
+    super.onEnd(span);
+  }
 };
 var BrizzBatchSpanProcessor = class extends import_sdk_trace_base.BatchSpanProcessor {
   config;
@@ -2329,7 +1513,7 @@ var BrizzBatchSpanProcessor = class extends import_sdk_trace_base.BatchSpanProce
     if (maskingConfig) {
       maskSpan(span, maskingConfig);
     }
-    const associationProperties = import_api10.context.active().getValue(PROPERTIES_CONTEXT_KEY);
+    const associationProperties = import_api4.context.active().getValue(PROPERTIES_CONTEXT_KEY);
     if (associationProperties) {
       for (const [key, value] of Object.entries(associationProperties)) {
         span.setAttribute(`${BRIZZ}.${key}`, value);
@@ -2337,6 +1521,10 @@ var BrizzBatchSpanProcessor = class extends import_sdk_trace_base.BatchSpanProce
     }
     super.onStart(span, parentContext);
   }
+  onEnd(span) {
+    transformAiSdkSpan(span);
+    super.onEnd(span);
+  }
 };
 function maskSpan(span, config) {
   if (!span.attributes || Object.keys(span.attributes).length === 0) {
@@ -2424,8 +1612,9 @@ var TracingModule = class _TracingModule {
       disableBatch: config.disableBatch,
       hasMasking: !!config.masking?.spanMasking
     });
-    this.spanProcessor = config.disableBatch ? new BrizzSimpleSpanProcessor(this.spanExporter, config) : new BrizzBatchSpanProcessor(this.spanExporter, config);
+    const spanProcessor = config.disableBatch ? new BrizzSimpleSpanProcessor(this.spanExporter, config) : new BrizzBatchSpanProcessor(this.spanExporter, config);
     logger.debug("Span processor initialized successfully");
+    this.spanProcessor = spanProcessor;
   }
   /**
    * Get the span exporter
@@ -2464,7 +1653,7 @@ function getSpanProcessor() {
 }
 
 // src/internal/trace/session.ts
-var import_api11 = require("@opentelemetry/api");
+var import_api5 = require("@opentelemetry/api");
 
 // src/internal/sdk.ts
 var _Brizz = class __Brizz {