@scope-analytics/node 0.1.0

package/dist/register.cjs

@@ -0,0 +1,895 @@
+"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 __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
+));
+
+// src/esm-hook.ts
+var nodeModule = __toESM(require("module"), 1);
+var import_api = require("@opentelemetry/api");
+var import_import_in_the_middle = require("import-in-the-middle");
+var import_meta = {};
+var HOOK_SPECIFIER = "@opentelemetry/instrumentation/hook.mjs";
+var _loaderRegistered = false;
+function esmHookDisabled() {
+  const v = process.env.SCOPE_DISABLE_ESM_HOOK;
+  return v === "1" || v === "true" || v === "TRUE";
+}
+function moduleUrl() {
+  try {
+    return import_meta.url;
+  } catch {
+    return void 0;
+  }
+}
+function enableEsmInstrumentation() {
+  if (esmHookDisabled()) return;
+  const parentURL = moduleUrl();
+  if (!parentURL) return;
+  const register2 = nodeModule.register;
+  if (typeof register2 !== "function") return;
+  try {
+    register2(HOOK_SPECIFIER, parentURL);
+    _loaderRegistered = true;
+    import_api.diag.debug("[scope] ESM auto-instrumentation enabled (import-in-the-middle loader registered).");
+  } catch (err) {
+    import_api.diag.debug(
+      `[scope] ESM auto-instrumentation not enabled (${err instanceof Error ? err.message : String(err)}); CJS apps are still captured via the require-hook.`
+    );
+  }
+}
+function registerEsmManualInstrument(entries) {
+  if (!_loaderRegistered) return;
+  const byModule = /* @__PURE__ */ new Map();
+  for (const { modules, instrumentation } of entries) {
+    for (const m of modules) byModule.set(m, instrumentation);
+  }
+  if (byModule.size === 0) return;
+  try {
+    new import_import_in_the_middle.Hook([...byModule.keys()], (exported, name) => {
+      const instrumentation = byModule.get(name);
+      if (!instrumentation) return exported;
+      try {
+        instrumentation.manuallyInstrument(exported);
+      } catch (err) {
+        import_api.diag.debug(
+          `[scope] ESM manual instrument of '${name}' failed (${err instanceof Error ? err.message : String(err)}).`
+        );
+      }
+      return exported;
+    });
+    import_api.diag.debug(`[scope] ESM manual instrumentation registered for: ${[...byModule.keys()].join(", ")}.`);
+  } catch (err) {
+    import_api.diag.debug(
+      `[scope] ESM manual instrumentation not registered (${err instanceof Error ? err.message : String(err)}).`
+    );
+  }
+}
+
+// src/index.ts
+var import_instrumentation3 = require("@opentelemetry/instrumentation");
+var import_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
+var import_openinference_instrumentation_openai = require("@arizeai/openinference-instrumentation-openai");
+var import_openinference_instrumentation_anthropic = require("@arizeai/openinference-instrumentation-anthropic");
+var import_openinference_vercel = require("@arizeai/openinference-vercel");
+
+// src/google-genai-instrumentation.ts
+var import_api2 = require("@opentelemetry/api");
+var import_core = require("@opentelemetry/core");
+var import_instrumentation = require("@opentelemetry/instrumentation");
+var import_openinference_semantic_conventions = require("@arizeai/openinference-semantic-conventions");
+
+// src/version.ts
+var SDK_VERSION = "0.1.0";
+var SDK_SOURCE = "backend_sdk";
+var SDK_USER_AGENT = `scope-tracer-node/${SDK_VERSION}`;
+
+// src/google-genai-instrumentation.ts
+var MODULE_NAME = "@google/genai";
+var INSTRUMENTATION_NAME = "@scope-analytics/node/instrumentation-google-genai";
+var _isPatched = false;
+function asFiniteNumber(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string" && v.trim() !== "" && Number.isFinite(Number(v))) return Number(v);
+  return void 0;
+}
+function safeJsonStringify(v) {
+  try {
+    return JSON.stringify(v) ?? String(v);
+  } catch {
+    return "[unserializable]";
+  }
+}
+function errMessage(err) {
+  const m = err?.message;
+  return m != null ? String(m) : "error";
+}
+function isPromiseLike(v) {
+  return v != null && typeof v.then === "function";
+}
+function modelName(params) {
+  const m = typeof params.model === "string" ? params.model : "gemini";
+  return m.startsWith("models/") ? m.slice("models/".length) : m;
+}
+function normalizeContents(contents) {
+  if (typeof contents === "string") return [{ role: "user", content: contents }];
+  if (Array.isArray(contents)) {
+    const msgs = [];
+    for (const item of contents) {
+      if (typeof item === "string") {
+        msgs.push({ role: "user", content: item });
+      } else if (item && typeof item === "object") {
+        const obj = item;
+        if ("content" in obj) {
+          msgs.push({
+            role: typeof obj.role === "string" ? obj.role : "user",
+            content: typeof obj.content === "string" ? obj.content : safeJsonStringify(obj.content)
+          });
+        } else if ("parts" in obj) {
+          const parts = Array.isArray(obj.parts) ? obj.parts : [];
+          const content = parts.filter((p) => p && typeof p.text === "string").map((p) => p.text).join("");
+          msgs.push({ role: typeof obj.role === "string" ? obj.role : "user", content });
+        } else if (typeof obj.text === "string") {
+          msgs.push({ role: "user", content: obj.text });
+        }
+      }
+    }
+    return msgs.length ? msgs : [{ role: "user", content: safeJsonStringify(contents) }];
+  }
+  if (contents == null) return [];
+  return [{ role: "user", content: safeJsonStringify(contents) }];
+}
+function responseText(resp) {
+  let text;
+  try {
+    text = resp?.text;
+  } catch {
+    text = void 0;
+  }
+  if (typeof text === "string" && text) return text;
+  let out = "";
+  const candidates = Array.isArray(resp?.candidates) ? resp?.candidates : [];
+  for (const cand of candidates) {
+    const parts = Array.isArray(cand?.content?.parts) ? cand?.content?.parts : [];
+    for (const part of parts) {
+      if (typeof part?.text === "string") out += part.text;
+    }
+  }
+  return out;
+}
+function inputAttributes(params) {
+  const attrs = {
+    [import_openinference_semantic_conventions.SemanticConventions.OPENINFERENCE_SPAN_KIND]: import_openinference_semantic_conventions.OpenInferenceSpanKind.LLM,
+    [import_openinference_semantic_conventions.SemanticConventions.LLM_PROVIDER]: import_openinference_semantic_conventions.LLMProvider.GOOGLE,
+    [import_openinference_semantic_conventions.SemanticConventions.LLM_MODEL_NAME]: modelName(params),
+    [import_openinference_semantic_conventions.SemanticConventions.INPUT_VALUE]: safeJsonStringify(params),
+    [import_openinference_semantic_conventions.SemanticConventions.INPUT_MIME_TYPE]: import_openinference_semantic_conventions.MimeType.JSON
+  };
+  normalizeContents(params.contents).forEach((msg, i) => {
+    const prefix = `${import_openinference_semantic_conventions.SemanticConventions.LLM_INPUT_MESSAGES}.${i}.`;
+    if (msg.role !== void 0) attrs[`${prefix}${import_openinference_semantic_conventions.SemanticConventions.MESSAGE_ROLE}`] = msg.role;
+    if (msg.content !== void 0) attrs[`${prefix}${import_openinference_semantic_conventions.SemanticConventions.MESSAGE_CONTENT}`] = msg.content;
+  });
+  return attrs;
+}
+function setOutputAttributes(span, text, usage) {
+  const attrs = {
+    [import_openinference_semantic_conventions.SemanticConventions.OUTPUT_VALUE]: text,
+    [import_openinference_semantic_conventions.SemanticConventions.OUTPUT_MIME_TYPE]: import_openinference_semantic_conventions.MimeType.TEXT,
+    [`${import_openinference_semantic_conventions.SemanticConventions.LLM_OUTPUT_MESSAGES}.0.${import_openinference_semantic_conventions.SemanticConventions.MESSAGE_ROLE}`]: "model",
+    [`${import_openinference_semantic_conventions.SemanticConventions.LLM_OUTPUT_MESSAGES}.0.${import_openinference_semantic_conventions.SemanticConventions.MESSAGE_CONTENT}`]: text
+  };
+  if (usage) {
+    attrs[import_openinference_semantic_conventions.SemanticConventions.LLM_TOKEN_COUNT_PROMPT] = asFiniteNumber(usage.promptTokenCount) ?? 0;
+    attrs[import_openinference_semantic_conventions.SemanticConventions.LLM_TOKEN_COUNT_COMPLETION] = asFiniteNumber(usage.candidatesTokenCount) ?? 0;
+    attrs[import_openinference_semantic_conventions.SemanticConventions.LLM_TOKEN_COUNT_TOTAL] = asFiniteNumber(usage.totalTokenCount) ?? 0;
+  }
+  span.setAttributes(attrs);
+}
+function endOk(span, resp) {
+  try {
+    setOutputAttributes(span, responseText(resp), resp?.usageMetadata);
+    span.setStatus({ code: import_api2.SpanStatusCode.OK });
+  } catch {
+  }
+  try {
+    span.end();
+  } catch {
+  }
+}
+function endWithError(span, err) {
+  try {
+    span.recordException(err);
+    span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message: errMessage(err) });
+  } catch {
+  }
+  try {
+    span.end();
+  } catch {
+  }
+}
+var GoogleGenAIInstrumentation = class extends import_instrumentation.InstrumentationBase {
+  constructor(config = {}) {
+    super(INSTRUMENTATION_NAME, SDK_VERSION, config);
+  }
+  init() {
+    return new import_instrumentation.InstrumentationNodeModuleDefinition(
+      MODULE_NAME,
+      ["*"],
+      (moduleExports) => this.patch(moduleExports),
+      (moduleExports) => this.unpatch(moduleExports)
+    );
+  }
+  /** ESM escape hatch — the require-hook doesn't fire for `import` (mirrors the Arize instrumentations). */
+  manuallyInstrument(moduleExports) {
+    import_api2.diag.debug(`Manually instrumenting ${MODULE_NAME}`);
+    this.patch(moduleExports);
+  }
+  patch(moduleExports) {
+    if (!moduleExports || moduleExports.scopePatched || _isPatched) return moduleExports;
+    const m = moduleExports.default || moduleExports;
+    const proto = m?.Models?.prototype;
+    if (!proto || typeof proto.generateContentInternal !== "function") {
+      import_api2.diag.warn(`[scope] cannot find Models.prototype.generateContentInternal in ${MODULE_NAME}`);
+      return moduleExports;
+    }
+    const wrappable = proto;
+    this._wrap(wrappable, "generateContentInternal", this._wrapGenerate(false));
+    if (typeof proto.generateContentStreamInternal === "function") {
+      this._wrap(wrappable, "generateContentStreamInternal", this._wrapGenerate(true));
+    }
+    _isPatched = true;
+    try {
+      moduleExports.scopePatched = true;
+    } catch {
+    }
+    return moduleExports;
+  }
+  unpatch(moduleExports) {
+    const m = moduleExports?.default || moduleExports;
+    const proto = m?.Models?.prototype;
+    if (proto) {
+      if ((0, import_instrumentation.isWrapped)(proto.generateContentInternal)) {
+        this._unwrap(proto, "generateContentInternal");
+      }
+      if ((0, import_instrumentation.isWrapped)(proto.generateContentStreamInternal)) {
+        this._unwrap(proto, "generateContentStreamInternal");
+      }
+    }
+    _isPatched = false;
+    try {
+      if (moduleExports) moduleExports.scopePatched = false;
+    } catch {
+    }
+  }
+  _wrapGenerate(streaming) {
+    const instrumentation = this;
+    return (original) => function patched(...args) {
+      if ((0, import_core.isTracingSuppressed)(import_api2.context.active())) {
+        return original.apply(this, args);
+      }
+      let span;
+      try {
+        const params = args[0] ?? {};
+        span = instrumentation.tracer.startSpan("GoogleGenAI.generateContent", {
+          kind: import_api2.SpanKind.INTERNAL,
+          attributes: inputAttributes(params)
+        });
+      } catch {
+        span = void 0;
+      }
+      if (!span) return original.apply(this, args);
+      const activeSpan = span;
+      const activeContext = import_api2.trace.setSpan(import_api2.context.active(), activeSpan);
+      let result;
+      try {
+        result = import_api2.context.with(activeContext, () => original.apply(this, args));
+      } catch (err) {
+        endWithError(activeSpan, err);
+        throw err;
+      }
+      if (!isPromiseLike(result)) {
+        endOk(activeSpan, void 0);
+        return result;
+      }
+      if (streaming) {
+        return result.then(
+          (gen) => instrumentation._wrapStream(gen, activeSpan),
+          (err) => {
+            endWithError(activeSpan, err);
+            throw err;
+          }
+        );
+      }
+      return result.then(
+        (resp) => {
+          endOk(activeSpan, resp);
+          return resp;
+        },
+        (err) => {
+          endWithError(activeSpan, err);
+          throw err;
+        }
+      );
+    };
+  }
+  /**
+   * Wrap the streaming async-generator: yield every chunk through to the caller while accumulating the
+   * full text + final usage, then end the span. Capture is fully isolated from the caller's stream:
+   *   - per-chunk extraction is swallowed, so a malformed chunk never aborts the user's iteration;
+   *   - the catch handles ONLY a real error thrown by the underlying stream (records it, rethrows);
+   *   - the finally ends the span exactly once, even on early abandonment (the generator's .return()
+   *     runs `finally`) — capturing whatever text/usage arrived so far.
+   * Mirrors the Python _wrap_stream_iter + _capture_streaming_response (chunks carry text; the final
+   * chunk carries usage).
+   */
+  async *_wrapStream(gen, span) {
+    const texts = [];
+    let usage;
+    let errored = false;
+    try {
+      for await (const chunk of gen) {
+        try {
+          texts.push(responseText(chunk));
+          if (chunk?.usageMetadata) usage = chunk.usageMetadata;
+        } catch {
+        }
+        yield chunk;
+      }
+    } catch (err) {
+      errored = true;
+      try {
+        span.recordException(err);
+        span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message: errMessage(err) });
+      } catch {
+      }
+      throw err;
+    } finally {
+      if (!errored) {
+        try {
+          setOutputAttributes(span, texts.join(""), usage);
+          span.setStatus({ code: import_api2.SpanStatusCode.OK });
+        } catch {
+        }
+      }
+      try {
+        span.end();
+      } catch {
+      }
+    }
+  }
+};
+
+// src/vercel-ai-instrumentation.ts
+var import_api3 = require("@opentelemetry/api");
+var import_instrumentation2 = require("@opentelemetry/instrumentation");
+var MODULE_NAME2 = "ai";
+var INSTRUMENTATION_NAME2 = "@scope-analytics/node/instrumentation-vercel-ai";
+var TARGET_FUNCTIONS = ["generateText", "streamText", "generateObject", "streamObject"];
+var _isPatched2 = false;
+function injectTelemetryArgs(args) {
+  try {
+    const opts = args[0];
+    if (!opts || typeof opts !== "object" || Array.isArray(opts)) return args;
+    const o = opts;
+    const existing = o.experimental_telemetry;
+    const hasExisting = !!existing && typeof existing === "object" && !Array.isArray(existing);
+    if (hasExisting && existing.isEnabled === false) return args;
+    if (hasExisting && existing.isEnabled === true) return args;
+    const mergedTelemetry = {
+      ...hasExisting ? existing : {},
+      isEnabled: true
+    };
+    return [{ ...o, experimental_telemetry: mergedTelemetry }, ...args.slice(1)];
+  } catch {
+    return args;
+  }
+}
+function makeTelemetryWrapper(original) {
+  return function scopeVercelTelemetryWrapper(...args) {
+    return original.apply(this, injectTelemetryArgs(args));
+  };
+}
+function settableInPlace(obj, name) {
+  const d = Object.getOwnPropertyDescriptor(obj, name);
+  if (!d) return false;
+  if (typeof d.set === "function") return true;
+  if (d.writable === true) return true;
+  if (d.configurable === true) return true;
+  return false;
+}
+var VercelAIInstrumentation = class extends import_instrumentation2.InstrumentationBase {
+  // Same original-exports → Proxy, so repeated patch() calls (re-entrancy) return one stable Proxy.
+  _proxyCache = /* @__PURE__ */ new WeakMap();
+  constructor(config = {}) {
+    super(INSTRUMENTATION_NAME2, SDK_VERSION, config);
+  }
+  init() {
+    return new import_instrumentation2.InstrumentationNodeModuleDefinition(
+      MODULE_NAME2,
+      ["*"],
+      (moduleExports) => this.patch(moduleExports),
+      (moduleExports) => this.unpatch(moduleExports)
+    );
+  }
+  /** ESM escape hatch — the require-hook doesn't fire for `import` (mirrors the Arize instrumentations). */
+  manuallyInstrument(moduleExports) {
+    import_api3.diag.debug(`Manually instrumenting ${MODULE_NAME2}`);
+    return this.patch(moduleExports);
+  }
+  patch(moduleExports) {
+    if (!moduleExports) return moduleExports;
+    const present = TARGET_FUNCTIONS.filter((n) => typeof moduleExports[n] === "function");
+    if (present.length === 0) {
+      import_api3.diag.warn(`[scope] no target functions found in '${MODULE_NAME2}'; AI SDK telemetry not auto-enabled`);
+      return moduleExports;
+    }
+    if (present.every((n) => settableInPlace(moduleExports, n))) {
+      for (const n of present) {
+        if (!(0, import_instrumentation2.isWrapped)(moduleExports[n])) {
+          this._wrap(moduleExports, n, (original) => makeTelemetryWrapper(original));
+        }
+      }
+      _isPatched2 = true;
+      return moduleExports;
+    }
+    const cached = this._proxyCache.get(moduleExports);
+    if (cached) {
+      _isPatched2 = true;
+      return cached;
+    }
+    const targets = new Set(present);
+    const fnCache = /* @__PURE__ */ new Map();
+    const proxy = new Proxy(moduleExports, {
+      get(target, prop, receiver) {
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof prop === "string" && targets.has(prop) && typeof value === "function") {
+          let wrapped = fnCache.get(prop);
+          if (!wrapped) {
+            wrapped = makeTelemetryWrapper(value);
+            fnCache.set(prop, wrapped);
+          }
+          return wrapped;
+        }
+        return value;
+      }
+    });
+    this._proxyCache.set(moduleExports, proxy);
+    _isPatched2 = true;
+    return proxy;
+  }
+  unpatch(moduleExports) {
+    if (moduleExports) {
+      for (const n of TARGET_FUNCTIONS) {
+        if (typeof moduleExports[n] === "function" && (0, import_instrumentation2.isWrapped)(moduleExports[n])) {
+          this._unwrap(moduleExports, n);
+        }
+      }
+      this._proxyCache.delete(moduleExports);
+    }
+    _isPatched2 = false;
+    return moduleExports;
+  }
+};
+
+// src/config.ts
+var ScopeConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ScopeConfigError";
+  }
+};
+var DEFAULT_ENDPOINT = "https://api.scopeai.dev";
+function resolveConfig(options = {}, env = process.env) {
+  const apiKey = (options.apiKey ?? env.SCOPE_API_KEY ?? "").trim();
+  if (!apiKey) {
+    throw new ScopeConfigError(
+      "Scope: missing API key. Set SCOPE_API_KEY (your project secret key, sk_live_\u2026 or sk_test_\u2026) or pass { apiKey } to init()."
+    );
+  }
+  if (!(apiKey.startsWith("sk_live_") || apiKey.startsWith("sk_test_"))) {
+    throw new ScopeConfigError(
+      'Scope: invalid API key. The backend SDK needs a project SECRET key starting with "sk_live_" or "sk_test_" (a public "pk_\u2026" key will not work for server-side ingest).'
+    );
+  }
+  const rawEndpoint = (options.endpoint ?? env.SCOPE_ENDPOINT ?? DEFAULT_ENDPOINT).trim();
+  const endpoint = (rawEndpoint || DEFAULT_ENDPOINT).replace(/\/+$/, "");
+  const environment = (options.environment ?? env.SCOPE_ENVIRONMENT ?? "production").trim() || "production";
+  const debug = options.debug ?? (env.SCOPE_DEBUG ?? "").toLowerCase() === "true";
+  const serviceName = (options.serviceName ?? env.SCOPE_SERVICE_NAME ?? env.OTEL_SERVICE_NAME ?? "scope-app").trim() || "scope-app";
+  return {
+    apiKey,
+    endpoint,
+    eventsUrl: `${endpoint}/api/events`,
+    environment,
+    debug,
+    serviceName,
+    sdkVersion: SDK_VERSION,
+    redactPatterns: options.redactPatterns ?? []
+  };
+}
+
+// src/deployment.ts
+var GIT_SHA_ENV_VARS = [
+  "RAILWAY_GIT_COMMIT_SHA",
+  // Railway
+  "VERCEL_GIT_COMMIT_SHA",
+  // Vercel
+  "RENDER_GIT_COMMIT",
+  // Render
+  "HEROKU_RELEASE_VERSION",
+  // Heroku
+  "K_REVISION",
+  // Cloud Run / Cloud Functions / Firebase
+  "AWS_LAMBDA_FUNCTION_VERSION",
+  // AWS Lambda
+  "GIT_COMMIT_SHA"
+  // Generic fallback
+];
+function detectGitSha(env = process.env) {
+  for (const name of GIT_SHA_ENV_VARS) {
+    const value = env[name];
+    if (value && value.trim()) return value.trim();
+  }
+  return void 0;
+}
+function resolveDeployment(startedAt, env = process.env) {
+  const gitSha = detectGitSha(env);
+  if (!gitSha) return {};
+  const startIso = startedAt.toISOString().replace(/\.\d{3}Z$/, "Z");
+  return { gitSha, deploymentId: `${startIso}-${gitSha.slice(0, 7)}` };
+}
+function stampDeployment(event, deployment) {
+  if (deployment.gitSha && event.git_sha === void 0) {
+    event.git_sha = deployment.gitSha;
+    if (deployment.deploymentId && event.deployment_id === void 0) {
+      event.deployment_id = deployment.deploymentId;
+    }
+  }
+  return event;
+}
+
+// src/exporter.ts
+var import_core2 = require("@opentelemetry/core");
+
+// src/event.ts
+var import_openinference_semantic_conventions2 = require("@arizeai/openinference-semantic-conventions");
+var import_api4 = require("@opentelemetry/api");
+
+// src/attributes.ts
+var SCOPE_THREAD_ID_ATTR = "scope.thread_id";
+var SCOPE_URL_ATTR = "scope.url";
+
+// src/session.ts
+var import_node_async_hooks = require("async_hooks");
+var import_node_crypto = require("crypto");
+var storage = new import_node_async_hooks.AsyncLocalStorage();
+function getContext() {
+  return storage.getStore();
+}
+function generateTempSessionId() {
+  return `temp_${(0, import_node_crypto.randomBytes)(8).toString("hex")}`;
+}
+
+// src/event.ts
+function asString(v) {
+  if (typeof v === "string") return v;
+  if (v === void 0 || v === null) return void 0;
+  return String(v);
+}
+function asNumber(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string" && v.trim() !== "" && Number.isFinite(Number(v))) return Number(v);
+  return void 0;
+}
+var GEN_AI_SYSTEM_ATTR = "gen_ai.system";
+var VERCEL_MODEL_PROVIDER_ATTR = "ai.model.provider";
+function redactText(text, patterns) {
+  if (text === void 0 || patterns.length === 0) return text;
+  let out = text;
+  for (const re of patterns) out = out.replace(re, "$1***REDACTED***");
+  return out;
+}
+function hrTimeToMs(t) {
+  return t[0] * 1e3 + t[1] / 1e6;
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function collectMessages(attrs, prefix) {
+  const p = escapeRe(prefix);
+  const roleRe = new RegExp(`^${p}\\.(\\d+)\\.${escapeRe(import_openinference_semantic_conventions2.SemanticConventions.MESSAGE_ROLE)}$`);
+  const contentRe = new RegExp(`^${p}\\.(\\d+)\\.${escapeRe(import_openinference_semantic_conventions2.SemanticConventions.MESSAGE_CONTENT)}$`);
+  const partRe = new RegExp(
+    `^${p}\\.(\\d+)\\.${escapeRe(import_openinference_semantic_conventions2.SemanticConventions.MESSAGE_CONTENTS)}\\.(\\d+)\\.${escapeRe(import_openinference_semantic_conventions2.SemanticConventions.MESSAGE_CONTENT_TEXT)}$`
+  );
+  const roles = /* @__PURE__ */ new Map();
+  const scalarContent = /* @__PURE__ */ new Map();
+  const parts = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(attrs)) {
+    let m;
+    if (m = roleRe.exec(key)) {
+      roles.set(Number(m[1]), asString(value));
+    } else if (m = contentRe.exec(key)) {
+      scalarContent.set(Number(m[1]), asString(value));
+    } else if (m = partRe.exec(key)) {
+      const i = Number(m[1]);
+      const text = asString(value);
+      if (text !== void 0) {
+        const byPart = parts.get(i) ?? /* @__PURE__ */ new Map();
+        byPart.set(Number(m[2]), text);
+        parts.set(i, byPart);
+      }
+    }
+  }
+  const indices = [.../* @__PURE__ */ new Set([...roles.keys(), ...scalarContent.keys(), ...parts.keys()])].sort(
+    (a, b) => a - b
+  );
+  return indices.map((i) => {
+    const message = {};
+    const role = roles.get(i);
+    if (role !== void 0) message.role = role;
+    let content = scalarContent.get(i);
+    if (content === void 0 && parts.has(i)) {
+      const byPart = parts.get(i);
+      content = [...byPart.keys()].sort((a, b) => a - b).map((j) => byPart.get(j)).join("");
+    }
+    if (content !== void 0) message.content = content;
+    return message;
+  });
+}
+function isLlmSpan(span) {
+  return span.attributes[import_openinference_semantic_conventions2.SemanticConventions.OPENINFERENCE_SPAN_KIND] === import_openinference_semantic_conventions2.OpenInferenceSpanKind.LLM;
+}
+function spanToScopeEvent(span, ctx) {
+  if (!isLlmSpan(span)) return null;
+  const a = span.attributes;
+  const inputMessages = collectMessages(a, import_openinference_semantic_conventions2.SemanticConventions.LLM_INPUT_MESSAGES);
+  const outputMessages = collectMessages(a, import_openinference_semantic_conventions2.SemanticConventions.LLM_OUTPUT_MESSAGES);
+  const lastUser = [...inputMessages].reverse().find((m) => (m.role ?? "").toLowerCase() === "user");
+  const patterns = ctx.config.redactPatterns ?? [];
+  const prompt = redactText(
+    lastUser?.content ?? inputMessages.at(-1)?.content ?? asString(a[import_openinference_semantic_conventions2.SemanticConventions.INPUT_VALUE]),
+    patterns
+  );
+  const response = redactText(outputMessages[0]?.content ?? asString(a[import_openinference_semantic_conventions2.SemanticConventions.OUTPUT_VALUE]), patterns);
+  const tokens = {};
+  const promptTokens = asNumber(a[import_openinference_semantic_conventions2.SemanticConventions.LLM_TOKEN_COUNT_PROMPT]);
+  if (promptTokens !== void 0) tokens.prompt_tokens = promptTokens;
+  const completionTokens = asNumber(a[import_openinference_semantic_conventions2.SemanticConventions.LLM_TOKEN_COUNT_COMPLETION]);
+  if (completionTokens !== void 0) tokens.completion_tokens = completionTokens;
+  const totalTokens = asNumber(a[import_openinference_semantic_conventions2.SemanticConventions.LLM_TOKEN_COUNT_TOTAL]);
+  if (totalTokens !== void 0) tokens.total_tokens = totalTokens;
+  const sessionId = asString(a[import_openinference_semantic_conventions2.SemanticConventions.SESSION_ID]) ?? generateTempSessionId();
+  const userId = asString(a[import_openinference_semantic_conventions2.SemanticConventions.USER_ID]) ?? null;
+  const isError = span.status?.code === import_api4.SpanStatusCode.ERROR;
+  const now = ctx.now ?? /* @__PURE__ */ new Date();
+  const nowIso = now.toISOString();
+  const event = {
+    event_type: "llm_call",
+    source: SDK_SOURCE,
+    timestamp: nowIso,
+    session_id: sessionId,
+    user_id: userId,
+    is_user_facing: !sessionId.startsWith("temp_"),
+    provider: asString(a[import_openinference_semantic_conventions2.SemanticConventions.LLM_PROVIDER]) ?? asString(a[import_openinference_semantic_conventions2.SemanticConventions.LLM_SYSTEM]) ?? asString(a[GEN_AI_SYSTEM_ATTR]) ?? asString(a[VERCEL_MODEL_PROVIDER_ATTR]),
+    model: asString(a[import_openinference_semantic_conventions2.SemanticConventions.LLM_MODEL_NAME]),
+    prompt,
+    response,
+    messages: patterns.length ? inputMessages.map(
+      (m) => m.content !== void 0 ? { ...m, content: redactText(m.content, patterns) } : m
+    ) : inputMessages,
+    tokens,
+    latency_ms: Math.max(0, hrTimeToMs(span.endTime) - hrTimeToMs(span.startTime)),
+    error: isError ? span.status?.message ?? "error" : null,
+    success: !isError,
+    environment: ctx.config.environment,
+    sdk_version: ctx.config.sdkVersion,
+    server_timestamp: nowIso
+  };
+  const threadId = asString(a[SCOPE_THREAD_ID_ATTR]);
+  if (threadId !== void 0) event.thread_id = threadId;
+  const url = asString(a[SCOPE_URL_ATTR]);
+  if (url !== void 0) event.url = url;
+  return stampDeployment(event, ctx.deployment);
+}
+
+// src/transport.ts
+async function shipEvents(events, config) {
+  if (events.length === 0) return true;
+  try {
+    const response = await fetch(config.eventsUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "Content-Type": "application/json",
+        "User-Agent": SDK_USER_AGENT
+      },
+      body: JSON.stringify({ events, source: SDK_SOURCE })
+    });
+    if (response.ok) {
+      if (config.debug) console.log(`[scope] shipped ${events.length} event(s)`);
+      return true;
+    }
+    if (config.debug) console.warn(`[scope] ship failed: HTTP ${response.status}`);
+    return false;
+  } catch (err) {
+    if (config.debug) {
+      console.warn(`[scope] ship error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return false;
+  }
+}
+
+// src/exporter.ts
+var ScopeSpanExporter = class {
+  constructor(config, deployment) {
+    this.config = config;
+    this.deployment = deployment;
+  }
+  config;
+  deployment;
+  export(spans, resultCallback) {
+    const events = [];
+    for (const span of spans) {
+      const event = spanToScopeEvent(span, { config: this.config, deployment: this.deployment });
+      if (event) events.push(event);
+    }
+    if (events.length === 0) {
+      resultCallback({ code: import_core2.ExportResultCode.SUCCESS });
+      return;
+    }
+    shipEvents(events, this.config).then((ok) => resultCallback({ code: ok ? import_core2.ExportResultCode.SUCCESS : import_core2.ExportResultCode.FAILED })).catch(() => resultCallback({ code: import_core2.ExportResultCode.FAILED }));
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+};
+
+// src/processor.ts
+var import_openinference_semantic_conventions3 = require("@arizeai/openinference-semantic-conventions");
+var ScopeContextSpanProcessor = class {
+  onStart(span, _parentContext) {
+    const ctx = getContext();
+    if (!ctx) return;
+    if (ctx.sessionId && span.attributes[import_openinference_semantic_conventions3.SemanticConventions.SESSION_ID] === void 0) {
+      span.setAttribute(import_openinference_semantic_conventions3.SemanticConventions.SESSION_ID, ctx.sessionId);
+    }
+    if (ctx.userId && span.attributes[import_openinference_semantic_conventions3.SemanticConventions.USER_ID] === void 0) {
+      span.setAttribute(import_openinference_semantic_conventions3.SemanticConventions.USER_ID, ctx.userId);
+    }
+    if (ctx.threadId && span.attributes[SCOPE_THREAD_ID_ATTR] === void 0) {
+      span.setAttribute(SCOPE_THREAD_ID_ATTR, ctx.threadId);
+    }
+    if (ctx.url && span.attributes[SCOPE_URL_ATTR] === void 0) {
+      span.setAttribute(SCOPE_URL_ATTR, ctx.url);
+    }
+  }
+  onEnd(_span) {
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+};
+
+// src/index.ts
+var STARTED_AT = /* @__PURE__ */ new Date();
+var active = null;
+function init(options = {}) {
+  if (active) {
+    if (active.config.debug) console.warn("[scope] init() called again; reusing the running tracer.");
+    return active;
+  }
+  const config = resolveConfig(options);
+  const deployment = resolveDeployment(STARTED_AT);
+  const provider = new import_sdk_trace_node.NodeTracerProvider({
+    spanProcessors: [
+      // Stamp session/user from AsyncLocalStorage onto each span before it's read at export.
+      new ScopeContextSpanProcessor(),
+      // Batch spans, then translate + ship them to Scope. We route through the OpenInference Vercel
+      // span processor (rather than a plain BatchSpanProcessor) so the Vercel AI SDK's own
+      // `ai.*`/`gen_ai.*` spans are translated to OpenInference `llm.*` attributes before our exporter
+      // reads them — the only way to capture the Vercel AI SDK, which emits its own spans instead of
+      // calling a provider SDK we instrument. On spans that are ALREADY OpenInference
+      // (OpenAI/Anthropic/Gemini) the translation is additive-only (it just re-affirms their span
+      // kind), so those keep flowing through unchanged. NB: the adapter tags EVERY span the process
+      // ends (a non-LLM span just gets an OpenInference span-kind attribute), but ScopeSpanExporter
+      // stays the single gate for which spans become events (LLM only) — so no spanFilter is needed,
+      // and any non-LLM span (Vercel's AGENT/TOOL spans, or a host's own HTTP/DB spans) is dropped
+      // there. Vercel emits a parent (AGENT) + child (LLM) span per call; the AGENT span is dropped,
+      // leaving exactly one llm_call per call.
+      new import_openinference_vercel.OpenInferenceBatchSpanProcessor({ exporter: new ScopeSpanExporter(config, deployment) })
+    ]
+  });
+  provider.register();
+  const openaiInstrumentation = new import_openinference_instrumentation_openai.OpenAIInstrumentation();
+  const anthropicInstrumentation = new import_openinference_instrumentation_anthropic.AnthropicInstrumentation();
+  const googleGenAIInstrumentation = new GoogleGenAIInstrumentation();
+  const vercelAIInstrumentation = new VercelAIInstrumentation();
+  (0, import_instrumentation3.registerInstrumentations)({
+    tracerProvider: provider,
+    instrumentations: [
+      openaiInstrumentation,
+      anthropicInstrumentation,
+      googleGenAIInstrumentation,
+      vercelAIInstrumentation
+    ]
+  });
+  registerEsmManualInstrument([
+    { modules: ["openai"], instrumentation: openaiInstrumentation },
+    { modules: ["@anthropic-ai/sdk"], instrumentation: anthropicInstrumentation },
+    { modules: ["@google/genai"], instrumentation: googleGenAIInstrumentation }
+  ]);
+  active = {
+    config,
+    deployment,
+    shutdown: async () => {
+      try {
+        await provider.shutdown();
+      } finally {
+        active = null;
+      }
+    }
+  };
+  if (deployment.gitSha) void emitDeploymentDetected(config, deployment);
+  if (config.debug) {
+    console.log(
+      `[scope] tracer started (endpoint=${config.endpoint}, env=${config.environment}` + (deployment.gitSha ? `, git_sha=${deployment.gitSha.slice(0, 7)}` : "") + ")."
+    );
+  }
+  return active;
+}
+async function emitDeploymentDetected(config, deployment) {
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  await shipEvents(
+    [
+      {
+        event_type: "deployment_detected",
+        source: SDK_SOURCE,
+        timestamp: nowIso,
+        server_timestamp: nowIso,
+        session_id: `deploy_${deployment.deploymentId}`,
+        git_sha: deployment.gitSha,
+        deployment_id: deployment.deploymentId,
+        is_user_facing: false,
+        success: true,
+        environment: config.environment,
+        sdk_version: config.sdkVersion
+      }
+    ],
+    config
+  );
+}
+
+// src/register.ts
+enableEsmInstrumentation();
+try {
+  init();
+} catch (err) {
+  console.warn(`[scope] tracer not started: ${err instanceof Error ? err.message : String(err)}`);
+}
+//# sourceMappingURL=register.cjs.map