@agentmark-ai/shared-utils 0.1.0

package/dist/index.js

@@ -0,0 +1,1546 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AiSdkTransformer: () => AiSdkTransformer,
+  MastraTransformer: () => MastraTransformer,
+  SpanType: () => SpanType,
+  TransformerRegistry: () => TransformerRegistry,
+  TypeClassifier: () => TypeClassifier,
+  convertOtlpAttributes: () => convertOtlpAttributes,
+  createSignature: () => createSignature,
+  detectVersion: () => detectVersion,
+  extractCustomMetadata: () => extractCustomMetadata,
+  extractReasoningFromProviderMetadata: () => extractReasoningFromProviderMetadata,
+  extractResourceScopeSpan: () => extractResourceScopeSpan,
+  fetchPromptsFrontmatter: () => fetchPromptsFrontmatter,
+  findPromptFiles: () => findPromptFiles,
+  generateTypeDefinitions: () => generateTypeDefinitions,
+  generateUnique8CharString: () => generateUnique8CharString,
+  normalizeOtlpSpans: () => normalizeOtlpSpans,
+  normalizeSpan: () => normalizeSpan,
+  parseAgentMarkAttributes: () => parseAgentMarkAttributes,
+  parseMetadata: () => parseMetadata,
+  parseTokens: () => parseTokens,
+  registry: () => registry,
+  toFrontMatter: () => toFrontMatter,
+  typeClassifier: () => typeClassifier,
+  verifySignature: () => verifySignature
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/generate-unique-8-char-string.ts
+var generateUnique8CharString = () => {
+  const timestamp = Date.now().toString(36);
+  const randomChars = Math.random().toString(36).substr(2, 6);
+  return timestamp + randomChars;
+};
+
+// src/hmac-256-signature.ts
+var encoder = new TextEncoder();
+async function createSignature(secret = "", payload) {
+  if (!secret) {
+    secret = "DEFAULT";
+  }
+  const algorithm = { name: "HMAC", hash: { name: "SHA-256" } };
+  const keyBytes = encoder.encode(secret);
+  const extractable = false;
+  const key = await crypto.subtle.importKey(
+    "raw",
+    keyBytes,
+    algorithm,
+    extractable,
+    ["sign", "verify"]
+  );
+  const signature = await crypto.subtle.sign(
+    algorithm,
+    key,
+    encoder.encode(payload)
+  );
+  return `sha256=${toHexString(signature)}`;
+}
+function toHexString(signature) {
+  return Array.from(new Uint8Array(signature)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function verifySignature(secret, header, payload) {
+  if (!secret) {
+    secret = "DEFAULT";
+  }
+  const parts = header.split("=");
+  const sigHex = parts[1];
+  const algorithm = { name: "HMAC", hash: { name: "SHA-256" } };
+  const keyBytes = encoder.encode(secret);
+  const extractable = false;
+  const key = await crypto.subtle.importKey(
+    "raw",
+    keyBytes,
+    algorithm,
+    extractable,
+    ["sign", "verify"]
+  );
+  const sigBytes = hexToBytes(sigHex);
+  const dataBytes = encoder.encode(payload);
+  const equal = await crypto.subtle.verify(
+    algorithm.name,
+    key,
+    sigBytes,
+    dataBytes
+  );
+  return equal;
+}
+function hexToBytes(hex) {
+  const len = hex.length / 2;
+  const bytes = new Uint8Array(len);
+  let index = 0;
+  for (let i = 0; i < hex.length; i += 2) {
+    const c = hex.slice(i, i + 2);
+    const b = parseInt(c, 16);
+    bytes[index] = b;
+    index += 1;
+  }
+  return bytes;
+}
+
+// src/serialize.ts
+function toFrontMatter(content) {
+  function jsonToFrontMatter(json, indent = 0) {
+    let frontMatter = "";
+    const indentation = "  ".repeat(indent);
+    for (const key in json) {
+      if (Object.prototype.hasOwnProperty.call(json, key)) {
+        const value = json[key];
+        if (typeof value === "object" && !Array.isArray(value)) {
+          frontMatter += `${indentation}${key}:
+`;
+          frontMatter += jsonToFrontMatter(value, indent + 1);
+        } else if (Array.isArray(value)) {
+          frontMatter += `${indentation}${key}:
+`;
+          value.forEach((item) => {
+            if (typeof item === "object") {
+              frontMatter += `${indentation}-
+`;
+              frontMatter += jsonToFrontMatter(item, indent + 2);
+            } else {
+              frontMatter += `${indentation}- ${item}
+`;
+            }
+          });
+        } else {
+          frontMatter += `${indentation}${key}: ${value}
+`;
+        }
+      }
+    }
+    return frontMatter;
+  }
+  return `---
+${jsonToFrontMatter(content)}---
+`;
+}
+
+// src/generate-types.ts
+var fs = __toESM(require("fs-extra"));
+var import_path = __toESM(require("path"));
+var import_front_matter = __toESM(require("front-matter"));
+var _compile = null;
+async function getCompile() {
+  var _a;
+  if (_compile) return _compile;
+  const mod = await import("json-schema-to-typescript");
+  const c = mod.compile || ((_a = mod.default) == null ? void 0 : _a.compile);
+  _compile = c.bind(mod);
+  return _compile;
+}
+function getInterfaceName(filePath) {
+  return filePath.replace(/\.prompt\.mdx$/, "").split("/").map((part) => {
+    return part.split(/[-_]|(?=[A-Z])/).map(
+      (word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+    ).join("").replace(/[^a-zA-Z0-9]/g, "");
+  }).join("$");
+}
+function getToolInterfaceName(toolName) {
+  return toolName.split(/[-_]|(?=[A-Z])/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+async function findPromptFiles(dir) {
+  const files = await fs.readdir(dir, { withFileTypes: true });
+  let promptFiles = [];
+  for (const file of files) {
+    const fullPath = import_path.default.join(dir, file.name);
+    if (file.isDirectory()) {
+      promptFiles = promptFiles.concat(await findPromptFiles(fullPath));
+    } else if (file.name.endsWith(".prompt.mdx")) {
+      promptFiles.push(fullPath);
+    }
+  }
+  return promptFiles;
+}
+async function generateTypeDefinitionsV1_0(prompts) {
+  const interfaces = [];
+  const headerComment = `// Auto-generated types from AgentMark
+// Do not edit this file directly
+
+`;
+  let output = "";
+  const typeMapping = [];
+  for (const prompt of prompts) {
+    const { path: promptPath, input_schema } = prompt;
+    const name = getInterfaceName(promptPath);
+    let tools = {};
+    try {
+      let kind = "text";
+      let output_schema = null;
+      if ("text_config" in prompt) {
+        kind = "text";
+        tools = prompt.text_config.tools || {};
+      } else if ("object_config" in prompt) {
+        kind = "object";
+        tools = prompt.object_config.tools || {};
+        output_schema = prompt.object_config.schema;
+      } else if ("image_config" in prompt) {
+        kind = "image";
+        tools = prompt.image_config.tools || {};
+      }
+      const compile = await getCompile();
+      const inputInterface = input_schema ? await compile(input_schema, `${name}In`, {
+        bannerComment: "",
+        additionalProperties: false
+      }) : `interface ${name}In { [key: string]: any }`;
+      const toolTypes = await generateToolTypes(tools);
+      const outputInterface = output_schema ? await compile(output_schema, `${name}Out`, {
+        bannerComment: "",
+        additionalProperties: false
+      }) : `type ${name}Out = string`;
+      interfaces.push(
+        inputInterface.replace("export interface", "interface"),
+        outputInterface.replace("export type", "type").replace("export interface", "interface")
+      );
+      output += toolTypes || "";
+      output += `type ${name} = {
+  kind: '${kind}';
+  input:  ${name}In;
+  output: ${name}Out;${toolTypes ? `
+  tools?: Array<keyof Tools>;` : ""}
+};
+
+`;
+      typeMapping.push(`  "${promptPath}": ${name}`);
+      const withoutMdx = promptPath.replace(/\.mdx$/, "");
+      if (withoutMdx !== promptPath) {
+        typeMapping.push(`  "${withoutMdx}": ${name}`);
+      }
+      const shortName = promptPath.replace(/\.prompt\.mdx$/, "");
+      if (shortName !== promptPath && shortName !== withoutMdx) {
+        typeMapping.push(`  "${shortName}": ${name}`);
+      }
+    } catch (error) {
+      console.error(`Error processing ${promptPath}:`, error);
+      interfaces.push(
+        `interface ${name}In { [key: string]: any }
+type ${name}Out = string`
+      );
+    }
+  }
+  output += `export default interface AgentmarkTypes {
+${typeMapping.join(",\n")}
+}
+`;
+  return headerComment + interfaces.join("\n\n") + "\n\n" + output;
+}
+async function generateTypeDefinitionsV0(prompts) {
+  var _a, _b;
+  const interfaces = [];
+  const headerComment = `// Auto-generated types from AgentMark
+// Do not edit this file directly
+
+`;
+  let output = "";
+  const typeMapping = [];
+  for (const prompt of prompts) {
+    const { path: promptPath, metadata, input_schema } = prompt;
+    const name = getInterfaceName(promptPath);
+    try {
+      const compile = await getCompile();
+      const inputInterface = input_schema ? await compile(input_schema, `${name}In`, {
+        bannerComment: "",
+        additionalProperties: false
+      }) : `interface ${name}In { [key: string]: any }`;
+      const outputSchema = (_b = (_a = metadata == null ? void 0 : metadata.model) == null ? void 0 : _a.settings) == null ? void 0 : _b.schema;
+      const outputInterface = outputSchema ? await compile(outputSchema, `${name}Out`, {
+        bannerComment: "",
+        additionalProperties: false
+      }) : `type ${name}Out = string`;
+      interfaces.push(
+        inputInterface.replace("export interface", "interface"),
+        outputInterface.replace("export type", "type").replace("export interface", "interface")
+      );
+      output += `interface ${name} {
+  input: ${name}In;
+  output: ${name}Out;
+}
+
+`;
+      typeMapping.push(`  "${promptPath}": ${name}`);
+      const withoutMdx = promptPath.replace(/\.mdx$/, "");
+      if (withoutMdx !== promptPath) {
+        typeMapping.push(`  "${withoutMdx}": ${name}`);
+      }
+      const shortName = promptPath.replace(/\.prompt\.mdx$/, "");
+      if (shortName !== promptPath && shortName !== withoutMdx) {
+        typeMapping.push(`  "${shortName}": ${name}`);
+      }
+    } catch (error) {
+      console.error(`Error processing ${promptPath}:`, error);
+      interfaces.push(
+        `interface ${name}In { [key: string]: any }
+type ${name}Out = string`
+      );
+      output += `interface ${name} {
+  input: ${name}In;
+  output: ${name}Out;
+}
+
+`;
+      typeMapping.push(`  "${promptPath}": ${name}`);
+      const withoutMdx = promptPath.replace(/\.mdx$/, "");
+      if (withoutMdx !== promptPath) {
+        typeMapping.push(`  "${withoutMdx}": ${name}`);
+      }
+      const shortName = promptPath.replace(/\.prompt\.mdx$/, "");
+      if (shortName !== promptPath && shortName !== withoutMdx) {
+        typeMapping.push(`  "${shortName}": ${name}`);
+      }
+    }
+  }
+  output += `export default interface AgentmarkTypes {
+${typeMapping.join(",\n")}
+}
+`;
+  return headerComment + interfaces.join("\n\n") + "\n\n" + output;
+}
+var isNewFormat = (frontmatter) => {
+  return frontmatter["text_config"] || frontmatter["object_config"] || frontmatter["image_config"];
+};
+async function generateTypeDefinitions(prompts) {
+  if (prompts[0].version === "1.0") {
+    return generateTypeDefinitionsV1_0(prompts);
+  }
+  return generateTypeDefinitionsV0(prompts);
+}
+async function fetchPromptsFrontmatter(options) {
+  if (options.local) {
+    const baseUrl = `http://localhost:${options.local}`;
+    try {
+      const pathsResponse = await fetch(`${baseUrl}/v1/prompts`);
+      if (!pathsResponse.ok) {
+        throw new Error(
+          `Failed to fetch prompt paths: ${pathsResponse.statusText}`
+        );
+      }
+      const { paths } = await pathsResponse.json();
+      return Promise.all(
+        paths.map(async (promptPath) => {
+          const templateResponse = await fetch(
+            `${baseUrl}/v1/templates?path=${promptPath}`
+          );
+          if (!templateResponse.ok) {
+            throw new Error(
+              `Failed to fetch template ${promptPath}: ${templateResponse.statusText}`
+            );
+          }
+          const { data: ast } = await templateResponse.json();
+          const yamlNode = ast.children.find(
+            (node) => node.type === "yaml"
+          );
+          if (!yamlNode) {
+            throw new Error(`No YAML frontmatter found in ${promptPath}`);
+          }
+          const { parse: parseYaml } = await import("yaml");
+          const frontmatter = parseYaml(yamlNode.value);
+          if (isNewFormat(frontmatter)) {
+            return {
+              path: promptPath,
+              ...frontmatter,
+              version: "1.0"
+            };
+          }
+          return {
+            path: promptPath,
+            ...frontmatter
+          };
+        })
+      );
+    } catch (error) {
+      if (error instanceof TypeError && error.message.includes("fetch failed")) {
+        console.error(`Connection failed to ${baseUrl}.`);
+      }
+      console.error("\nError details:", error);
+      throw error;
+    }
+  }
+  if (options.rootDir) {
+    if (!fs.existsSync(options.rootDir)) {
+      throw new Error(`Directory not found at: ${options.rootDir}`);
+    }
+    const promptFiles = await findPromptFiles(options.rootDir);
+    return Promise.all(
+      promptFiles.map(async (file) => {
+        const content = await fs.readFile(file, "utf-8");
+        const { attributes } = (0, import_front_matter.default)(content);
+        if (isNewFormat(attributes)) {
+          return {
+            path: import_path.default.relative(options.rootDir, file),
+            ...attributes,
+            version: "1.0"
+          };
+        }
+        return {
+          path: import_path.default.relative(options.rootDir, file),
+          ...attributes
+        };
+      })
+    );
+  }
+  throw new Error("Either --local or --root-dir must be specified");
+}
+async function generateToolTypes(tools) {
+  const toolArgTypes = [];
+  for (const [toolName, schema] of Object.entries(tools)) {
+    const typeName = `${getToolInterfaceName(toolName)}Args`;
+    try {
+      const compile = await getCompile();
+      const argInterface = schema.parameters ? await compile(schema.parameters, typeName, {
+        bannerComment: "",
+        additionalProperties: false
+      }) : `type ${typeName} = { ${Object.entries(schema.parameters || {}).map(([key]) => `${key}: any`).join("; ")} };`;
+      toolArgTypes.push(
+        argInterface.replace("export type", "type").replace("export interface", "interface")
+      );
+    } catch (error) {
+      console.error(`Error processing tool ${toolName}:`, error);
+      toolArgTypes.push(`type ${typeName} = { [key: string]: any };`);
+    }
+  }
+  if (Object.keys(tools).length > 0) {
+    const toolsInterface = `export interface Tools {
+${Object.keys(tools).map(
+      (toolName) => `  ${toolName}: { args: ${getToolInterfaceName(toolName)}Args };`
+    ).join("\n")}
+}`;
+    return toolArgTypes.join("\n\n") + "\n\n" + toolsInterface + "\n\n";
+  }
+  return null;
+}
+
+// src/normalizer/types.ts
+var SpanType = /* @__PURE__ */ ((SpanType2) => {
+  SpanType2["SPAN"] = "SPAN";
+  SpanType2["GENERATION"] = "GENERATION";
+  SpanType2["EVENT"] = "EVENT";
+  return SpanType2;
+})(SpanType || {});
+
+// src/normalizer/registry.ts
+var TransformerRegistry = class {
+  constructor() {
+    this.transformers = /* @__PURE__ */ new Map();
+    this.defaultTransformer = null;
+  }
+  register(scope, transformer) {
+    this.transformers.set(scope, transformer);
+  }
+  setDefault(transformer) {
+    this.defaultTransformer = transformer;
+  }
+  getTransformer(scope) {
+    return this.transformers.get(scope) || this.defaultTransformer;
+  }
+};
+var registry = new TransformerRegistry();
+
+// src/normalizer/transformers/ai-sdk/version-detector.ts
+function detectVersion(attributes) {
+  if (attributes["ai.response.text"] !== void 0 && attributes["ai.response.text"] !== null || attributes["ai.response.toolCalls"] !== void 0 && attributes["ai.response.toolCalls"] !== null || attributes["ai.response.object"] !== void 0 && attributes["ai.response.object"] !== null) {
+    return "v5";
+  }
+  if (attributes["ai.result.text"] !== void 0 && attributes["ai.result.text"] !== null || attributes["ai.result.toolCalls"] !== void 0 && attributes["ai.result.toolCalls"] !== null || attributes["ai.result.object"] !== void 0 && attributes["ai.result.object"] !== null) {
+    return "v4";
+  }
+  if (attributes["ai.prompt.messages"] !== void 0 && attributes["ai.prompt.messages"] !== null || attributes["ai.prompt"] !== void 0 && attributes["ai.prompt"] !== null) {
+    return "v4";
+  }
+  return "unknown";
+}
+
+// src/normalizer/extractors/token-parser.ts
+function parseTokens(attributes, keys) {
+  const result = {};
+  const parseIntSafe = (val) => {
+    if (typeof val === "number") return Math.floor(val);
+    if (typeof val === "string") {
+      try {
+        const parsed2 = JSON.parse(val);
+        if (typeof parsed2 === "number") return Math.floor(parsed2);
+        if (parsed2 && typeof parsed2.intValue === "number") return Math.floor(parsed2.intValue);
+      } catch {
+      }
+      const parsed = parseInt(val, 10);
+      return isNaN(parsed) ? void 0 : parsed;
+    }
+    return void 0;
+  };
+  if (keys.inputKey && attributes[keys.inputKey] !== void 0) {
+    result.inputTokens = parseIntSafe(attributes[keys.inputKey]);
+  } else if (keys.promptKey && attributes[keys.promptKey] !== void 0) {
+    result.inputTokens = parseIntSafe(attributes[keys.promptKey]);
+  }
+  if (keys.outputKey && attributes[keys.outputKey] !== void 0) {
+    result.outputTokens = parseIntSafe(attributes[keys.outputKey]);
+  } else if (keys.completionKey && attributes[keys.completionKey] !== void 0) {
+    result.outputTokens = parseIntSafe(attributes[keys.completionKey]);
+  }
+  if (keys.totalKey && attributes[keys.totalKey] !== void 0) {
+    result.totalTokens = parseIntSafe(attributes[keys.totalKey]);
+  }
+  if (result.totalTokens === void 0 && result.inputTokens !== void 0 && result.outputTokens !== void 0) {
+    result.totalTokens = result.inputTokens + result.outputTokens;
+  }
+  if (keys.reasoningKey && attributes[keys.reasoningKey] !== void 0) {
+    result.reasoningTokens = parseIntSafe(attributes[keys.reasoningKey]);
+  }
+  return result;
+}
+
+// src/normalizer/utils/key-sanitizer.ts
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isSafeKey(key) {
+  return !DANGEROUS_KEYS.has(key);
+}
+
+// src/normalizer/extractors/metadata-parser.ts
+var KNOWN_METADATA_FIELDS = /* @__PURE__ */ new Set([
+  "session_id",
+  "session_name",
+  "user_id",
+  "trace_name",
+  "dataset_run_id",
+  "dataset_run_name",
+  "dataset_path",
+  "dataset_item_name",
+  "dataset_expected_output",
+  "prompt_name",
+  "props",
+  "commit_sha"
+]);
+function parseMetadata(attributes, prefix = "agentmark.metadata.") {
+  const result = {};
+  const get = (key) => attributes[`${prefix}${key}`];
+  if (get("session_id")) result.sessionId = String(get("session_id"));
+  if (get("session_name")) result.sessionName = String(get("session_name"));
+  if (get("user_id")) result.userId = String(get("user_id"));
+  if (get("trace_name")) result.traceName = String(get("trace_name"));
+  if (get("dataset_run_id")) result.datasetRunId = String(get("dataset_run_id"));
+  if (get("dataset_run_name")) result.datasetRunName = String(get("dataset_run_name"));
+  if (get("dataset_path")) result.datasetPath = String(get("dataset_path"));
+  if (get("dataset_item_name")) result.datasetItemName = String(get("dataset_item_name"));
+  if (get("dataset_expected_output")) result.datasetExpectedOutput = String(get("dataset_expected_output"));
+  if (get("prompt_name")) result.promptName = String(get("prompt_name"));
+  if (get("props")) result.props = String(get("props"));
+  if (get("commit_sha")) result.commitSha = String(get("commit_sha"));
+  return result;
+}
+function extractCustomMetadata(attributes, prefix = "agentmark.metadata.") {
+  const customMetadata = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    if (key.startsWith(prefix)) {
+      const metadataKey = key.slice(prefix.length);
+      if (metadataKey && !KNOWN_METADATA_FIELDS.has(metadataKey) && isSafeKey(metadataKey)) {
+        customMetadata[metadataKey] = String(value);
+      }
+    }
+  }
+  return customMetadata;
+}
+
+// src/normalizer/transformers/ai-sdk/token-helpers.ts
+function extractReasoningFromProviderMetadata(attributes) {
+  var _a;
+  const providerMetadata = attributes["ai.response.providerMetadata"];
+  if (!providerMetadata) return void 0;
+  try {
+    const parsed = typeof providerMetadata === "string" ? JSON.parse(providerMetadata) : providerMetadata;
+    if (((_a = parsed == null ? void 0 : parsed.openai) == null ? void 0 : _a.reasoningTokens) !== void 0) {
+      return typeof parsed.openai.reasoningTokens === "number" ? parsed.openai.reasoningTokens : void 0;
+    }
+  } catch {
+  }
+  return void 0;
+}
+
+// src/normalizer/transformers/ai-sdk/strategies/v4.ts
+var AiSdkV4Strategy = class {
+  /**
+   * Normalize a content part from V4 format to standard format
+   */
+  normalizeContentPart(part) {
+    if (typeof part === "string") {
+      return part;
+    }
+    if (!part || typeof part !== "object") {
+      return part;
+    }
+    const type = part.type;
+    if (type === "text") {
+      return {
+        type: "text",
+        text: part.text || ""
+      };
+    }
+    if (type === "tool-call") {
+      return {
+        type: "tool-call",
+        toolCallId: part.toolCallId || "",
+        toolName: part.toolName || "",
+        args: part.args || {}
+        // V4 uses 'args' directly
+      };
+    }
+    if (type === "tool-result") {
+      return {
+        type: "tool-result",
+        toolCallId: part.toolCallId || "",
+        toolName: part.toolName || "",
+        result: part.result
+        // V4 uses 'result' directly
+      };
+    }
+    return part;
+  }
+  /**
+   * Normalize a single message from V4 format to standard format
+   */
+  normalizeMessage(message) {
+    if (!message || typeof message !== "object") {
+      return message;
+    }
+    const { role, content, ...rest } = message;
+    let normalizedContent;
+    if (typeof content === "string") {
+      normalizedContent = content;
+    } else if (Array.isArray(content)) {
+      normalizedContent = content.map((part) => this.normalizeContentPart(part));
+    } else if (content && typeof content === "object") {
+      normalizedContent = this.normalizeContentPart(content);
+    } else {
+      normalizedContent = content;
+    }
+    return {
+      role: role || "",
+      content: normalizedContent,
+      ...rest
+    };
+  }
+  /**
+   * Normalize messages array from V4 format to standard format
+   */
+  normalizeMessages(messages) {
+    if (!Array.isArray(messages)) {
+      return messages;
+    }
+    return messages.map((msg) => this.normalizeMessage(msg));
+  }
+  extractModel(attributes) {
+    return attributes["gen_ai.request.model"] || attributes["ai.model.id"];
+  }
+  extractInput(attributes) {
+    let messagesValue;
+    if (attributes["ai.prompt.messages"] !== void 0) {
+      messagesValue = attributes["ai.prompt.messages"];
+    } else if (attributes["ai.prompt"] !== void 0) {
+      const promptValue = attributes["ai.prompt"];
+      if (typeof promptValue === "string") {
+        try {
+          const parsed = JSON.parse(promptValue);
+          messagesValue = parsed.messages || parsed;
+        } catch {
+          return void 0;
+        }
+      } else {
+        messagesValue = promptValue.messages || promptValue;
+      }
+    } else {
+      return void 0;
+    }
+    let messages;
+    if (typeof messagesValue === "string") {
+      try {
+        messages = JSON.parse(messagesValue);
+      } catch {
+        return void 0;
+      }
+    } else {
+      messages = messagesValue;
+    }
+    if (!Array.isArray(messages)) {
+      return void 0;
+    }
+    return this.normalizeMessages(messages);
+  }
+  extractOutput(attributes) {
+    if (attributes["ai.result.text"] !== void 0) return attributes["ai.result.text"];
+    if (attributes["ai.response.text"] !== void 0) return attributes["ai.response.text"];
+    return void 0;
+  }
+  extractOutputObject(attributes) {
+    let objValue;
+    if (attributes["ai.result.object"] !== void 0) {
+      objValue = attributes["ai.result.object"];
+    } else if (attributes["ai.response.object"] !== void 0) {
+      objValue = attributes["ai.response.object"];
+    } else {
+      return void 0;
+    }
+    if (typeof objValue === "string") {
+      try {
+        return JSON.parse(objValue);
+      } catch {
+        return void 0;
+      }
+    }
+    return objValue;
+  }
+  extractToolCalls(attributes) {
+    let toolCallsValue;
+    if (attributes["ai.result.toolCalls"] !== void 0) {
+      toolCallsValue = attributes["ai.result.toolCalls"];
+    } else if (attributes["ai.response.toolCalls"] !== void 0) {
+      toolCallsValue = attributes["ai.response.toolCalls"];
+    } else {
+      if (attributes["ai.toolCall.name"] !== void 0) {
+        const toolCallId = attributes["ai.toolCall.id"];
+        const toolName = attributes["ai.toolCall.name"];
+        const argsValue = attributes["ai.toolCall.args"];
+        const resultValue = attributes["ai.toolCall.result"];
+        if (toolCallId && toolName) {
+          let args = {};
+          if (argsValue !== void 0) {
+            if (typeof argsValue === "string") {
+              try {
+                args = JSON.parse(argsValue);
+              } catch {
+                args = {};
+              }
+            } else if (typeof argsValue === "object" && argsValue !== null) {
+              args = argsValue;
+            }
+          }
+          let result;
+          if (resultValue !== void 0) {
+            if (typeof resultValue === "string") {
+              result = resultValue;
+            } else {
+              try {
+                result = JSON.stringify(resultValue);
+              } catch {
+                result = String(resultValue);
+              }
+            }
+          }
+          return [{
+            type: "tool-call",
+            toolCallId: String(toolCallId),
+            toolName: String(toolName),
+            args,
+            result
+          }];
+        }
+      }
+      return void 0;
+    }
+    let toolCalls;
+    if (typeof toolCallsValue === "string") {
+      try {
+        toolCalls = JSON.parse(toolCallsValue);
+      } catch {
+        return void 0;
+      }
+    } else {
+      toolCalls = toolCallsValue;
+    }
+    if (!Array.isArray(toolCalls)) {
+      return void 0;
+    }
+    return toolCalls.map((tc) => ({
+      type: tc.type || "tool-call",
+      toolCallId: tc.toolCallId,
+      toolName: tc.toolName,
+      args: tc.args || tc.input || {}
+      // v4 uses 'args', normalize to 'args'
+    }));
+  }
+  extractFinishReason(attributes) {
+    if (attributes["ai.result.finishReason"] !== void 0) {
+      return String(attributes["ai.result.finishReason"]);
+    }
+    if (attributes["ai.response.finishReason"] !== void 0) {
+      return String(attributes["ai.response.finishReason"]);
+    }
+    if (attributes["gen_ai.response.finish_reasons"] !== void 0) {
+      const reasons = attributes["gen_ai.response.finish_reasons"];
+      if (Array.isArray(reasons) && reasons.length > 0) {
+        return String(reasons[0]);
+      }
+      return String(reasons);
+    }
+    return void 0;
+  }
+  extractSettings(attributes) {
+    var _a, _b, _c, _d, _e;
+    const settings = {};
+    if (attributes["gen_ai.request.temperature"] !== void 0 || attributes["ai.settings.temperature"] !== void 0) {
+      const value = (_a = attributes["gen_ai.request.temperature"]) != null ? _a : attributes["ai.settings.temperature"];
+      settings.temperature = typeof value === "number" ? value : parseFloat(String(value));
+    }
+    if (attributes["gen_ai.request.max_tokens"] !== void 0 || attributes["ai.settings.maxTokens"] !== void 0) {
+      const value = (_b = attributes["gen_ai.request.max_tokens"]) != null ? _b : attributes["ai.settings.maxTokens"];
+      settings.maxTokens = typeof value === "number" ? value : parseInt(String(value), 10);
+    }
+    if (attributes["gen_ai.request.top_p"] !== void 0 || attributes["ai.settings.topP"] !== void 0) {
+      const value = (_c = attributes["gen_ai.request.top_p"]) != null ? _c : attributes["ai.settings.topP"];
+      settings.topP = typeof value === "number" ? value : parseFloat(String(value));
+    }
+    if (attributes["gen_ai.request.presence_penalty"] !== void 0 || attributes["ai.settings.presencePenalty"] !== void 0) {
+      const value = (_d = attributes["gen_ai.request.presence_penalty"]) != null ? _d : attributes["ai.settings.presencePenalty"];
+      settings.presencePenalty = typeof value === "number" ? value : parseFloat(String(value));
+    }
+    if (attributes["gen_ai.request.frequency_penalty"] !== void 0 || attributes["ai.settings.frequencyPenalty"] !== void 0) {
+      const value = (_e = attributes["gen_ai.request.frequency_penalty"]) != null ? _e : attributes["ai.settings.frequencyPenalty"];
+      settings.frequencyPenalty = typeof value === "number" ? value : parseFloat(String(value));
+    }
+    return Object.keys(settings).length > 0 ? settings : void 0;
+  }
+  extractTokens(attributes) {
+    const tokens = parseTokens(attributes, {
+      inputKey: "gen_ai.usage.prompt_tokens",
+      outputKey: "gen_ai.usage.completion_tokens",
+      totalKey: "gen_ai.usage.total_tokens",
+      promptKey: "ai.usage.promptTokens",
+      // SDK specific fallback
+      completionKey: "ai.usage.completionTokens"
+      // SDK specific fallback
+    });
+    tokens.reasoningTokens = extractReasoningFromProviderMetadata(attributes);
+    if (!tokens.reasoningTokens) {
+      tokens.reasoningTokens = 0;
+    }
+    return {
+      input: tokens.inputTokens,
+      output: tokens.outputTokens,
+      total: tokens.totalTokens,
+      reasoning: tokens.reasoningTokens
+    };
+  }
+  extractMetadata(attributes) {
+    const result = parseMetadata(attributes);
+    const aiTelemetryResult = parseMetadata(attributes, "ai.telemetry.metadata.");
+    const agentmarkCustomMetadata = extractCustomMetadata(attributes, "agentmark.metadata.");
+    const aiTelemetryCustomMetadata = extractCustomMetadata(attributes, "ai.telemetry.metadata.");
+    const mergedCustomMetadata = {
+      ...agentmarkCustomMetadata,
+      ...aiTelemetryCustomMetadata
+    };
+    return {
+      ...result,
+      ...aiTelemetryResult,
+      // Only include metadata field if there are custom metadata keys
+      ...Object.keys(mergedCustomMetadata).length > 0 ? { metadata: mergedCustomMetadata } : {}
+    };
+  }
+};
+
+// src/normalizer/transformers/ai-sdk/strategies/v5.ts
+var AiSdkV5Strategy = class {
+  /**
+   * Normalize a content part from V5 format to standard format
+   */
+  normalizeContentPart(part) {
+    if (typeof part === "string") {
+      return part;
+    }
+    if (!part || typeof part !== "object") {
+      return part;
+    }
+    const type = part.type;
+    if (type === "text") {
+      return {
+        type: "text",
+        text: part.text || ""
+      };
+    }
+    if (type === "tool-call") {
+      return {
+        type: "tool-call",
+        toolCallId: part.toolCallId || "",
+        toolName: part.toolName || "",
+        args: part.input || part.args || {}
+        // V5 uses 'input', normalize to 'args'
+      };
+    }
+    if (type === "tool-result") {
+      let normalizedResult;
+      if (part.output !== void 0) {
+        if (typeof part.output === "object" && part.output !== null) {
+          if ("value" in part.output) {
+            normalizedResult = part.output.value;
+          } else {
+            normalizedResult = part.output;
+          }
+        } else {
+          normalizedResult = part.output;
+        }
+      } else if (part.result !== void 0) {
+        normalizedResult = part.result;
+      } else {
+        normalizedResult = void 0;
+      }
+      return {
+        type: "tool-result",
+        toolCallId: part.toolCallId || "",
+        toolName: part.toolName || "",
+        result: normalizedResult
+      };
+    }
+    return part;
+  }
+  /**
+   * Normalize a single message from V5 format to standard format
+   */
+  normalizeMessage(message) {
+    if (!message || typeof message !== "object") {
+      return message;
+    }
+    const { role, content, ...rest } = message;
+    let normalizedContent;
+    if (typeof content === "string") {
+      normalizedContent = content;
+    } else if (Array.isArray(content)) {
+      normalizedContent = content.map((part) => this.normalizeContentPart(part));
+    } else if (content && typeof content === "object") {
+      normalizedContent = this.normalizeContentPart(content);
+    } else {
+      normalizedContent = content;
+    }
+    return {
+      role: role || "",
+      content: normalizedContent,
+      ...rest
+    };
+  }
+  /**
+   * Normalize messages array from V5 format to standard format
+   */
+  normalizeMessages(messages) {
+    if (!Array.isArray(messages)) {
+      return messages;
+    }
+    return messages.map((msg) => this.normalizeMessage(msg));
+  }
+  extractModel(attributes) {
+    return attributes["gen_ai.request.model"] || attributes["ai.model.id"];
+  }
+  extractInput(attributes) {
+    let messagesValue;
+    if (attributes["ai.prompt.messages"] !== void 0) {
+      messagesValue = attributes["ai.prompt.messages"];
+    } else if (attributes["ai.prompt"] !== void 0) {
+      const promptValue = attributes["ai.prompt"];
+      if (typeof promptValue === "string") {
+        try {
+          const parsed = JSON.parse(promptValue);
+          messagesValue = parsed.messages || parsed;
+        } catch {
+          return void 0;
+        }
+      } else {
+        messagesValue = promptValue.messages || promptValue;
+      }
+    } else {
+      return void 0;
+    }
+    let messages;
+    if (typeof messagesValue === "string") {
+      try {
+        messages = JSON.parse(messagesValue);
+      } catch {
+        return void 0;
+      }
+    } else {
+      messages = messagesValue;
+    }
+    if (!Array.isArray(messages)) {
+      return void 0;
+    }
+    return this.normalizeMessages(messages);
+  }
+  extractOutput(attributes) {
+    if (attributes["ai.response.text"] !== void 0) return attributes["ai.response.text"];
+    return void 0;
+  }
+  extractOutputObject(attributes) {
+    if (attributes["ai.response.object"] === void 0) {
+      return void 0;
+    }
+    const objValue = attributes["ai.response.object"];
+    if (typeof objValue === "string") {
+      try {
+        return JSON.parse(objValue);
+      } catch {
+        return void 0;
+      }
+    }
+    if (typeof objValue === "object" && objValue !== null) {
+      return objValue;
+    }
+    return void 0;
+  }
+  extractToolCalls(attributes) {
+    if (attributes["ai.response.toolCalls"] !== void 0) {
+      const toolCallsValue = attributes["ai.response.toolCalls"];
+      let toolCalls;
+      if (typeof toolCallsValue === "string") {
+        try {
+          toolCalls = JSON.parse(toolCallsValue);
+        } catch {
+          return void 0;
+        }
+      } else {
+        toolCalls = toolCallsValue;
+      }
+      if (!Array.isArray(toolCalls)) {
+        return void 0;
+      }
+      return toolCalls.map((tc) => ({
+        type: tc.type || "tool-call",
+        toolCallId: tc.toolCallId,
+        toolName: tc.toolName,
+        args: tc.input || tc.args || {},
+        // v5 uses 'input', normalize to 'args'
+        providerMetadata: tc.providerMetadata || tc.providerOptions
+      }));
+    }
+    if (attributes["ai.toolCall.name"] !== void 0) {
+      const toolCallId = attributes["ai.toolCall.id"];
+      const toolName = attributes["ai.toolCall.name"];
+      const argsValue = attributes["ai.toolCall.args"];
+      const resultValue = attributes["ai.toolCall.result"];
+      if (toolCallId && toolName) {
+        let args = {};
+        if (argsValue !== void 0) {
+          if (typeof argsValue === "string") {
+            try {
+              args = JSON.parse(argsValue);
+            } catch {
+              args = {};
+            }
+          } else if (typeof argsValue === "object" && argsValue !== null) {
+            args = argsValue;
+          }
+        }
+        let result;
+        if (resultValue !== void 0) {
+          if (typeof resultValue === "string") {
+            result = resultValue;
+          } else {
+            try {
+              result = JSON.stringify(resultValue);
+            } catch {
+              result = String(resultValue);
+            }
+          }
+        }
+        return [{
+          type: "tool-call",
+          toolCallId: String(toolCallId),
+          toolName: String(toolName),
+          args,
+          result
+        }];
+      }
+    }
+    return void 0;
+  }
+  extractFinishReason(attributes) {
+    if (attributes["ai.response.finishReason"] !== void 0) {
+      return String(attributes["ai.response.finishReason"]);
+    }
+    if (attributes["gen_ai.response.finish_reasons"] !== void 0) {
+      const reasons = attributes["gen_ai.response.finish_reasons"];
+      if (Array.isArray(reasons) && reasons.length > 0) {
+        return String(reasons[0]);
+      }
+      return String(reasons);
+    }
+    return void 0;
+  }
+  extractSettings(attributes) {
+    var _a, _b, _c, _d, _e;
+    const settings = {};
+    if (attributes["gen_ai.request.temperature"] !== void 0 || attributes["ai.settings.temperature"] !== void 0) {
+      const value = (_a = attributes["gen_ai.request.temperature"]) != null ? _a : attributes["ai.settings.temperature"];
+      settings.temperature = typeof value === "number" ? value : parseFloat(String(value));
+    }
+    if (attributes["gen_ai.request.max_tokens"] !== void 0 || attributes["ai.settings.maxTokens"] !== void 0) {
+      const value = (_b = attributes["gen_ai.request.max_tokens"]) != null ? _b : attributes["ai.settings.maxTokens"];
+      settings.maxTokens = typeof value === "number" ? value : parseInt(String(value), 10);
+    }
+    if (attributes["gen_ai.request.top_p"] !== void 0 || attributes["ai.settings.topP"] !== void 0) {
+      const value = (_c = attributes["gen_ai.request.top_p"]) != null ? _c : attributes["ai.settings.topP"];
+      settings.topP = typeof value === "number" ? value : parseFloat(String(value));
+    }
+    if (attributes["gen_ai.request.presence_penalty"] !== void 0 || attributes["ai.settings.presencePenalty"] !== void 0) {
+      const value = (_d = attributes["gen_ai.request.presence_penalty"]) != null ? _d : attributes["ai.settings.presencePenalty"];
+      settings.presencePenalty = typeof value === "number" ? value : parseFloat(String(value));
+    }
+    if (attributes["gen_ai.request.frequency_penalty"] !== void 0 || attributes["ai.settings.frequencyPenalty"] !== void 0) {
+      const value = (_e = attributes["gen_ai.request.frequency_penalty"]) != null ? _e : attributes["ai.settings.frequencyPenalty"];
+      settings.frequencyPenalty = typeof value === "number" ? value : parseFloat(String(value));
+    }
+    return Object.keys(settings).length > 0 ? settings : void 0;
+  }
+  extractTokens(attributes) {
+    const tokens = parseTokens(attributes, {
+      inputKey: "gen_ai.usage.input_tokens",
+      outputKey: "gen_ai.usage.output_tokens",
+      totalKey: "gen_ai.usage.total_tokens",
+      promptKey: "ai.usage.promptTokens",
+      // SDK specific fallback
+      completionKey: "ai.usage.completionTokens",
+      // SDK specific fallback
+      reasoningKey: "ai.usage.reasoningTokens"
+      // AI SDK v5 uses this
+    });
+    if (tokens.reasoningTokens === void 0) {
+      tokens.reasoningTokens = extractReasoningFromProviderMetadata(attributes);
+    }
+    if (!tokens.reasoningTokens) {
+      tokens.reasoningTokens = 0;
+    }
+    return {
+      input: tokens.inputTokens,
+      output: tokens.outputTokens,
+      total: tokens.totalTokens,
+      reasoning: tokens.reasoningTokens
+    };
+  }
+  extractMetadata(attributes) {
+    const result = parseMetadata(attributes);
+    const aiTelemetryResult = parseMetadata(attributes, "ai.telemetry.metadata.");
+    const agentmarkCustomMetadata = extractCustomMetadata(attributes, "agentmark.metadata.");
+    const aiTelemetryCustomMetadata = extractCustomMetadata(attributes, "ai.telemetry.metadata.");
+    const mergedCustomMetadata = {
+      ...agentmarkCustomMetadata,
+      ...aiTelemetryCustomMetadata
+    };
+    return {
+      ...result,
+      ...aiTelemetryResult,
+      // Only include metadata field if there are custom metadata keys
+      ...Object.keys(mergedCustomMetadata).length > 0 ? { metadata: mergedCustomMetadata } : {}
+    };
+  }
+};
+
+// src/normalizer/transformers/ai-sdk/index.ts
+var AiSdkTransformer = class {
+  constructor() {
+    this.strategies = {
+      v4: new AiSdkV4Strategy(),
+      v5: new AiSdkV5Strategy()
+    };
+  }
+  classify(span, _attributes) {
+    const isGenerationSpan = span.name === "ai.generateText.doGenerate" || span.name === "ai.streamText.doStream" || span.name === "ai.generateObject.doGenerate" || span.name === "ai.streamObject.doStream";
+    return isGenerationSpan ? "GENERATION" /* GENERATION */ : "SPAN" /* SPAN */;
+  }
+  transform(_span, attributes) {
+    const version = detectVersion(attributes);
+    const strategy = version === "v5" ? this.strategies.v5 : this.strategies.v4;
+    const tokens = strategy.extractTokens(attributes);
+    const toolCalls = strategy.extractToolCalls(attributes);
+    const result = {
+      model: strategy.extractModel(attributes),
+      input: strategy.extractInput(attributes),
+      output: strategy.extractOutput(attributes),
+      outputObject: strategy.extractOutputObject(attributes),
+      toolCalls,
+      finishReason: strategy.extractFinishReason(attributes),
+      settings: strategy.extractSettings(attributes),
+      inputTokens: tokens.input,
+      outputTokens: tokens.output,
+      totalTokens: tokens.total,
+      reasoningTokens: tokens.reasoning,
+      ...strategy.extractMetadata(attributes)
+    };
+    const toolName = attributes["ai.toolCall.name"];
+    if (toolName && typeof toolName === "string") {
+      result.name = toolName;
+    }
+    return result;
+  }
+};
+
+// src/normalizer/transformers/mastra/index.ts
+var MastraTransformer = class {
+  classify(span, _attributes) {
+    const isGenerationSpan = span.name === "agent.streamLegacy" || span.name === "agent.stream" || span.name === "agent.streamObject" || span.name === "agent.generate" || span.name === "agent.generateObject";
+    return isGenerationSpan ? "GENERATION" /* GENERATION */ : "SPAN" /* SPAN */;
+  }
+  transform(span, attributes) {
+    const result = {};
+    const modelConfig = this.extractModelConfig(attributes, span);
+    if (modelConfig == null ? void 0 : modelConfig.modelId) {
+      result.model = modelConfig.modelId;
+    }
+    const input = this.extractInput(span, attributes);
+    if (input) {
+      result.input = input;
+    }
+    const streamResult = this.extractStreamResult(span, attributes);
+    if (streamResult) {
+      if (streamResult.output) {
+        result.output = streamResult.output;
+      }
+      if (streamResult.outputObject) {
+        result.outputObject = streamResult.outputObject;
+      }
+      if (streamResult.usage) {
+        result.inputTokens = streamResult.usage.promptTokens;
+        result.outputTokens = streamResult.usage.completionTokens;
+        result.totalTokens = streamResult.usage.totalTokens;
+      }
+    }
+    if (attributes["agentmark.trace_name"]) {
+      result.traceName = attributes["agentmark.trace_name"];
+    } else if (attributes["componentName"]) {
+      result.traceName = attributes["componentName"];
+    }
+    if (modelConfig == null ? void 0 : modelConfig.settings) {
+      result.settings = modelConfig.settings;
+    }
+    return result;
+  }
+  extractModelConfig(attributes, _span) {
+    var _a, _b;
+    const resolveModelConfigResult = attributes["agent.resolveModelConfig.result"];
+    if (resolveModelConfigResult) {
+      try {
+        const config = typeof resolveModelConfigResult === "string" ? JSON.parse(resolveModelConfigResult) : resolveModelConfigResult;
+        if (config.modelId) {
+          return {
+            modelId: config.modelId,
+            provider: (_a = config.config) == null ? void 0 : _a.provider,
+            settings: config.settings
+          };
+        }
+      } catch {
+      }
+    }
+    const prepareLLMOptionsResult = attributes["agent.prepareLLMOptions.result"];
+    if (prepareLLMOptionsResult) {
+      try {
+        const result = typeof prepareLLMOptionsResult === "string" ? JSON.parse(prepareLLMOptionsResult) : prepareLLMOptionsResult;
+        if ((_b = result.llm) == null ? void 0 : _b.name) {
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  extractInput(span, attributes) {
+    const spanName = span.name;
+    const argument0 = attributes[`${spanName}.argument.0`] || attributes["agent.prepareLLMOptions.argument.0"] || attributes["agent.stream.argument.0"] || attributes["agent.streamLegacy.argument.0"];
+    if (argument0) {
+      try {
+        const messages = typeof argument0 === "string" ? JSON.parse(argument0) : argument0;
+        if (Array.isArray(messages)) {
+          return messages;
+        }
+      } catch {
+      }
+    }
+    return void 0;
+  }
+  extractStreamResult(span, attributes) {
+    const spanName = span.name;
+    const resultAttr = attributes[`${spanName}.result`] || attributes["agent.stream.result"] || attributes["agent.streamLegacy.result"] || attributes["agent.streamObject.result"];
+    if (resultAttr) {
+      try {
+        const result = typeof resultAttr === "string" ? JSON.parse(resultAttr) : resultAttr;
+        const extracted = {};
+        if (result.usage) {
+          extracted.usage = {
+            promptTokens: result.usage.promptTokens,
+            completionTokens: result.usage.completionTokens,
+            totalTokens: result.usage.totalTokens
+          };
+        }
+        if (result.object) {
+          extracted.outputObject = result.object;
+          extracted.output = JSON.stringify(result.object);
+        } else if (result.text) {
+          extracted.output = result.text;
+        } else if (result.response) {
+          if (typeof result.response === "string") {
+            extracted.output = result.response;
+          } else {
+            extracted.output = JSON.stringify(result.response);
+            extracted.outputObject = result.response;
+          }
+        }
+        return extracted;
+      } catch {
+      }
+    }
+    return null;
+  }
+};
+
+// src/normalizer/converters/otlp-converter.ts
+function convertOtlpValue(value) {
+  var _a;
+  if (value.stringValue !== void 0) {
+    return value.stringValue;
+  }
+  if (value.intValue !== void 0) {
+    return typeof value.intValue === "string" ? parseInt(value.intValue, 10) : value.intValue;
+  }
+  if (value.doubleValue !== void 0) {
+    return value.doubleValue;
+  }
+  if (value.boolValue !== void 0) {
+    return value.boolValue;
+  }
+  if ((_a = value.arrayValue) == null ? void 0 : _a.values) {
+    return value.arrayValue.values.map(convertOtlpValue);
+  }
+  if (value.bytesValue !== void 0) {
+    return value.bytesValue;
+  }
+  return void 0;
+}
+function convertOtlpAttributes(attributes) {
+  if (!attributes || attributes.length === 0) {
+    return {};
+  }
+  const result = {};
+  for (const attr of attributes) {
+    if (attr.key && isSafeKey(attr.key)) {
+      result[attr.key] = convertOtlpValue(attr.value);
+    }
+  }
+  return result;
+}
+function extractResourceScopeSpan(resourceSpans) {
+  var _a, _b, _c;
+  const result = [];
+  const resourceAttributes = convertOtlpAttributes((_a = resourceSpans.resource) == null ? void 0 : _a.attributes);
+  for (const scopeSpans of resourceSpans.scopeSpans || []) {
+    const scope = {
+      name: (_b = scopeSpans.scope) == null ? void 0 : _b.name,
+      version: (_c = scopeSpans.scope) == null ? void 0 : _c.version
+    };
+    for (const otlpSpan of scopeSpans.spans || []) {
+      const spanAttributes = convertOtlpAttributes(otlpSpan.attributes);
+      const events = (otlpSpan.events || []).map((otlpEvent) => ({
+        timeUnixNano: otlpEvent.timeUnixNano,
+        name: otlpEvent.name,
+        attributes: convertOtlpAttributes(otlpEvent.attributes)
+      }));
+      const links = (otlpSpan.links || []).map((otlpLink) => ({
+        traceId: otlpLink.traceId,
+        spanId: otlpLink.spanId,
+        traceState: otlpLink.traceState,
+        attributes: convertOtlpAttributes(otlpLink.attributes)
+      }));
+      const span = {
+        traceId: otlpSpan.traceId,
+        spanId: otlpSpan.spanId,
+        parentSpanId: otlpSpan.parentSpanId,
+        traceState: otlpSpan.traceState,
+        name: otlpSpan.name,
+        kind: otlpSpan.kind,
+        startTimeUnixNano: otlpSpan.startTimeUnixNano,
+        endTimeUnixNano: otlpSpan.endTimeUnixNano,
+        attributes: spanAttributes,
+        events,
+        links,
+        status: otlpSpan.status
+      };
+      const resource = {
+        attributes: resourceAttributes
+      };
+      result.push({ resource, scope, span });
+    }
+  }
+  return result;
+}
+
+// src/normalizer/extractors/agentmark-parser.ts
+function parseAgentMarkAttributes(attributes, prefix = "agentmark.") {
+  const result = {};
+  const get = (key) => attributes[`${prefix}${key}`];
+  if (get("session_id")) result.sessionId = String(get("session_id"));
+  if (get("session_name")) result.sessionName = String(get("session_name"));
+  if (get("user_id")) result.userId = String(get("user_id"));
+  if (get("trace_name")) result.traceName = String(get("trace_name"));
+  if (get("dataset_run_id")) result.datasetRunId = String(get("dataset_run_id"));
+  if (get("dataset_run_name")) result.datasetRunName = String(get("dataset_run_name"));
+  if (get("dataset_item_name")) result.datasetItemName = String(get("dataset_item_name"));
+  if (get("dataset_expected_output")) result.datasetExpectedOutput = String(get("dataset_expected_output"));
+  return result;
+}
+
+// src/normalizer/type-classifier.ts
+var TypeClassifier = class {
+  classify(span, attributes) {
+    if (attributes["gen_ai.system"] || attributes["gen_ai.request.model"] || attributes["gen_ai.operation.name"]) {
+      return "GENERATION" /* GENERATION */;
+    }
+    if (attributes["ai.response.text"] || attributes["ai.result.text"] || attributes["ai.response.toolCalls"] || attributes["ai.result.toolCalls"]) {
+      return "GENERATION" /* GENERATION */;
+    }
+    if (span.name.startsWith("ai.generate") || span.name.startsWith("ai.stream")) {
+      return "GENERATION" /* GENERATION */;
+    }
+    return "SPAN" /* SPAN */;
+  }
+};
+var typeClassifier = new TypeClassifier();
+
+// src/normalizer/index.ts
+registry.register("ai", new AiSdkTransformer());
+registry.register("default-tracer", new MastraTransformer());
+registry.setDefault(new AiSdkTransformer());
+function normalizeSpan(resource, scope, span) {
+  var _a, _b, _c;
+  const allAttributes = {
+    ...resource.attributes || {},
+    ...span.attributes || {}
+  };
+  const transformer = registry.getTransformer(scope.name || "");
+  const type = transformer ? transformer.classify(span, allAttributes) : "SPAN" /* SPAN */;
+  const startNs = BigInt(span.startTimeUnixNano);
+  const endNs = BigInt(span.endTimeUnixNano);
+  const startMsInt = startNs / BigInt(1e6);
+  const startMsRemainder = Number(startNs % BigInt(1e6)) / 1e6;
+  const endMsInt = endNs / BigInt(1e6);
+  const endMsRemainder = Number(endNs % BigInt(1e6)) / 1e6;
+  const startMs = Number(startMsInt) + startMsRemainder;
+  const endMs = Number(endMsInt) + endMsRemainder;
+  const normalized = {
+    // Identity
+    traceId: span.traceId,
+    spanId: span.spanId,
+    parentSpanId: span.parentSpanId,
+    traceState: span.traceState,
+    // Type
+    type,
+    // Timing (convert nanoseconds to milliseconds: divide by 1,000,000)
+    startTime: startMs,
+    endTime: endMs,
+    duration: endMs - startMs,
+    // Metadata
+    name: span.name,
+    kind: span.kind.toString(),
+    serviceName: (_a = resource.attributes) == null ? void 0 : _a["service.name"],
+    statusCode: ((_b = span.status) == null ? void 0 : _b.code.toString()) || "0",
+    statusMessage: (_c = span.status) == null ? void 0 : _c.message,
+    // Raw Data
+    resourceAttributes: resource.attributes || {},
+    spanAttributes: span.attributes || {},
+    events: (span.events || []).map((e) => ({
+      timestamp: Number(BigInt(e.timeUnixNano)) / 1e6,
+      name: e.name,
+      attributes: e.attributes || {}
+    })),
+    links: (span.links || []).map((l) => ({
+      traceId: l.traceId,
+      spanId: l.spanId,
+      traceState: l.traceState,
+      attributes: l.attributes
+    }))
+  };
+  if (transformer) {
+    const transformed = transformer.transform(span, allAttributes);
+    Object.assign(normalized, transformed);
+  }
+  const agentMarkAttributes = parseAgentMarkAttributes(allAttributes);
+  Object.assign(normalized, agentMarkAttributes);
+  return normalized;
+}
+function normalizeOtlpSpans(resourceSpans) {
+  const normalizedSpans = [];
+  for (const resourceSpan of resourceSpans) {
+    const extracted = extractResourceScopeSpan(resourceSpan);
+    for (const { resource, scope, span } of extracted) {
+      normalizedSpans.push(normalizeSpan(resource, scope, span));
+    }
+  }
+  return normalizedSpans;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AiSdkTransformer,
+  MastraTransformer,
+  SpanType,
+  TransformerRegistry,
+  TypeClassifier,
+  convertOtlpAttributes,
+  createSignature,
+  detectVersion,
+  extractCustomMetadata,
+  extractReasoningFromProviderMetadata,
+  extractResourceScopeSpan,
+  fetchPromptsFrontmatter,
+  findPromptFiles,
+  generateTypeDefinitions,
+  generateUnique8CharString,
+  normalizeOtlpSpans,
+  normalizeSpan,
+  parseAgentMarkAttributes,
+  parseMetadata,
+  parseTokens,
+  registry,
+  toFrontMatter,
+  typeClassifier,
+  verifySignature
+});
+//# sourceMappingURL=index.js.map