@morsehq-dev/sdk 0.4.0-rc.1

package/dist/index.cjs

@@ -0,0 +1,843 @@
+'use strict';
+
+var chunk7YCENA54_cjs = require('./chunk-7YCENA54.cjs');
+var chunkPVHDEPRE_cjs = require('./chunk-PVHDEPRE.cjs');
+var chunk7EO7MQBA_cjs = require('./chunk-7EO7MQBA.cjs');
+require('./chunk-KBWPNIH4.cjs');
+var chunkFJUNILZT_cjs = require('./chunk-FJUNILZT.cjs');
+var module$1 = require('module');
+var instrumentationPg = require('@opentelemetry/instrumentation-pg');
+var instrumentationMysql2 = require('@opentelemetry/instrumentation-mysql2');
+var instrumentation = require('@opentelemetry/instrumentation');
+var api = require('@opentelemetry/api');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+chunkFJUNILZT_cjs.init_env();
+var FULL_INSTALL_TARGETS = {
+  "@anthropic-ai/sdk": {
+    install: (mod) => chunk7YCENA54_cjs.instrumentAnthropic({ anthropicModule: mod })
+  }
+};
+var DETECT_ONLY_TARGETS = {
+  "@openai/agents": "wrapRunnerWithFullInstrumentation(runner) from '@morsehq-dev/sdk/openai-agents'",
+  "@langchain/langgraph": "new MorseCallbackHandler() from '@morsehq-dev/sdk/langgraph', passed via { callbacks: [...] }",
+  "@anthropic-ai/claude-agent-sdk": "wrapClaudeAgentSDKWithFullInstrumentation(client) from '@morsehq-dev/sdk/anthropic-agent-sdk'",
+  // MHQ-758: `ai`'s exports can't be patched in place (frozen ESM getters,
+  // no prototype to patch) — createTracedVercelAI() returns replacement
+  // functions instead. See `../vercel-ai/index.ts`'s module doc.
+  ai: "createTracedVercelAI() from '@morsehq-dev/sdk/vercel-ai' \u2014 use its returned streamText/generateText/generateObject in place of ai's own"
+};
+function isNodeRuntime() {
+  return typeof process !== "undefined" && !!process.versions?.node;
+}
+function getNodeRequire() {
+  if (!isNodeRuntime()) return null;
+  try {
+    return module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+  } catch {
+    return null;
+  }
+}
+var firedFullInstall = /* @__PURE__ */ new Set();
+var loggedDetectOnly = /* @__PURE__ */ new Set();
+var lazyTargets = /* @__PURE__ */ new Set();
+var hookInstalled = false;
+var originalRequire = null;
+function logger(message) {
+  console.info(message);
+}
+async function installFullTarget(name, mod) {
+  if (firedFullInstall.has(name)) return;
+  firedFullInstall.add(name);
+  const target = FULL_INSTALL_TARGETS[name];
+  if (!target) return;
+  try {
+    await target.install(mod);
+  } catch {
+  }
+}
+function logDetectOnlyIfPresent(nodeRequire, name) {
+  if (loggedDetectOnly.has(name)) return;
+  try {
+    nodeRequire.resolve(name);
+  } catch {
+    return;
+  }
+  loggedDetectOnly.add(name);
+  logger(
+    `morse: detected "${name}" \u2014 no zero-config path for this SDK yet. Call ${DETECT_ONLY_TARGETS[name]} to instrument it.`
+  );
+}
+function installLazyHook() {
+  if (hookInstalled) return;
+  originalRequire = module$1.Module.prototype.require;
+  const original = originalRequire;
+  module$1.Module.prototype.require = function patchedRequire(id) {
+    const result = original.call(this, id);
+    if (lazyTargets.has(id) && !firedFullInstall.has(id)) {
+      void installFullTarget(id, result);
+    }
+    return result;
+  };
+  hookInstalled = true;
+}
+function uninstallLazyHook() {
+  if (hookInstalled && originalRequire) {
+    module$1.Module.prototype.require = originalRequire;
+  }
+  hookInstalled = false;
+  originalRequire = null;
+}
+async function installAdapters() {
+  if (chunkFJUNILZT_cjs.isAutoDetectDisabled()) return;
+  const nodeRequire = getNodeRequire();
+  if (!nodeRequire) return;
+  const installPromises = [];
+  for (const name of Object.keys(FULL_INSTALL_TARGETS)) {
+    if (firedFullInstall.has(name)) continue;
+    let resolvedPath;
+    try {
+      resolvedPath = nodeRequire.resolve(name);
+    } catch {
+      continue;
+    }
+    if (resolvedPath in nodeRequire.cache) {
+      try {
+        const mod = nodeRequire(name);
+        installPromises.push(installFullTarget(name, mod));
+      } catch {
+      }
+    } else {
+      lazyTargets.add(name);
+    }
+  }
+  if (lazyTargets.size > 0) {
+    installLazyHook();
+  }
+  for (const name of Object.keys(DETECT_ONLY_TARGETS)) {
+    logDetectOnlyIfPresent(nodeRequire, name);
+  }
+  await Promise.all(installPromises);
+}
+function _resetForTesting3() {
+  uninstallLazyHook();
+  firedFullInstall.clear();
+  loggedDetectOnly.clear();
+  lazyTargets.clear();
+}
+
+// src/index.ts
+chunkFJUNILZT_cjs.init_env();
+
+// src/_internal/db-capture.ts
+chunkFJUNILZT_cjs.init_env();
+chunkFJUNILZT_cjs.init_otel_provider();
+var SEMCONV_DB_SYSTEM_NAME = "db.system.name";
+var SEMCONV_DB_QUERY_TEXT = "db.query.text";
+var DB_SYSTEM_NAME_SQLITE = "sqlite";
+var MAX_STATEMENT_CHARS = 2048;
+var TRUNCATION_MARKER = "\u2026[truncated]";
+function sqlVerb(sql) {
+  try {
+    const first = String(sql).trim().split(/\s+/, 1)[0];
+    return first ? first.toUpperCase() : "QUERY";
+  } catch {
+    return "QUERY";
+  }
+}
+function safeStatement(sql) {
+  let text;
+  try {
+    text = String(sql).trim();
+  } catch {
+    return void 0;
+  }
+  if (!text) return void 0;
+  if (text.length > MAX_STATEMENT_CHARS) {
+    return text.slice(0, MAX_STATEMENT_CHARS) + " " + TRUNCATION_MARKER;
+  }
+  return text;
+}
+var SYNC_STATEMENT_METHODS = ["run", "get", "all", "iterate"];
+var BetterSqlite3Instrumentation = class extends instrumentation.InstrumentationBase {
+  constructor(config = {}) {
+    super("@morsehq/instrumentation-better-sqlite3", "0.1.0", config);
+  }
+  init() {
+    return [
+      new instrumentation.InstrumentationNodeModuleDefinition(
+        "better-sqlite3",
+        [">=7.0.0 <14"],
+        (moduleExports) => this._patch(moduleExports),
+        (moduleExports) => this._unpatch(moduleExports)
+      )
+    ];
+  }
+  _withSpan(sql, fn) {
+    const span2 = this.tracer.startSpan(sqlVerb(sql), { kind: api.SpanKind.CLIENT });
+    const stmt = safeStatement(sql);
+    span2.setAttribute(SEMCONV_DB_SYSTEM_NAME, DB_SYSTEM_NAME_SQLITE);
+    if (stmt) span2.setAttribute(SEMCONV_DB_QUERY_TEXT, stmt);
+    return api.context.with(api.trace.setSpan(api.context.active(), span2), () => {
+      try {
+        const result = fn();
+        span2.end();
+        return result;
+      } catch (err) {
+        span2.recordException(err);
+        span2.setStatus({ code: api.SpanStatusCode.ERROR, message: err?.message });
+        span2.end();
+        throw err;
+      }
+    });
+  }
+  /** Wrap one already-`prepare()`d statement's sync execution methods. */
+  _wrapStatementInstance(stmt) {
+    const sql = stmt?.source;
+    for (const method of SYNC_STATEMENT_METHODS) {
+      const original = stmt[method];
+      if (typeof original !== "function") continue;
+      const bound = original.bind(stmt);
+      stmt[method] = (...args) => this._withSpan(sql, () => bound(...args));
+    }
+    return stmt;
+  }
+  _patch(moduleExports) {
+    const DatabaseCtor = moduleExports;
+    const proto = DatabaseCtor?.prototype;
+    if (!proto) return moduleExports;
+    if (instrumentation.isWrapped(proto.prepare)) this._unwrap(proto, "prepare");
+    this._wrap(proto, "prepare", (original) => {
+      const wrapStatement = (stmt) => this._wrapStatementInstance(stmt);
+      return function(...args) {
+        const stmt = original.apply(this, args);
+        return wrapStatement(stmt);
+      };
+    });
+    if (instrumentation.isWrapped(proto.exec)) this._unwrap(proto, "exec");
+    this._wrap(proto, "exec", (original) => {
+      const withSpan = (sql, fn) => this._withSpan(sql, fn);
+      return function(...args) {
+        return withSpan(args[0], () => original.apply(this, args));
+      };
+    });
+    return moduleExports;
+  }
+  _unpatch(moduleExports) {
+    const proto = moduleExports?.prototype;
+    if (!proto) return;
+    if (instrumentation.isWrapped(proto.prepare)) this._unwrap(proto, "prepare");
+    if (instrumentation.isWrapped(proto.exec)) this._unwrap(proto, "exec");
+  }
+};
+
+// src/_internal/db-capture.ts
+var unregister = null;
+var registeredInstrumentations = null;
+function buildDbInstrumentations() {
+  return [
+    new instrumentationPg.PgInstrumentation(),
+    new instrumentationMysql2.MySQL2Instrumentation(),
+    new BetterSqlite3Instrumentation()
+  ];
+}
+function registerDbInstrumentation() {
+  disableDbCapture();
+  try {
+    const instrumentations = buildDbInstrumentations();
+    const off = chunkFJUNILZT_cjs.getEngine().registerInstrumentations(instrumentations);
+    if (off === null) return false;
+    unregister = off;
+    registeredInstrumentations = instrumentations;
+    return true;
+  } catch {
+    unregister = null;
+    registeredInstrumentations = null;
+    return false;
+  }
+}
+function disableDbCapture() {
+  if (unregister !== null) {
+    try {
+      unregister();
+    } catch {
+    }
+  }
+  unregister = null;
+  registeredInstrumentations = null;
+}
+function maybeEnableDbCaptureFromEnv() {
+  if (chunkFJUNILZT_cjs.isDbCaptureEnabled()) {
+    registerDbInstrumentation();
+  }
+}
+
+// src/index.ts
+chunkFJUNILZT_cjs.init_otel_provider();
+chunkFJUNILZT_cjs.init_redaction();
+
+// src/_internal/transport.ts
+var SDK_VERSION = "0.4.0-rc.1" ;
+var RETRY_AFTER_CAP_SECONDS = 30;
+function parseRetryAfter(value) {
+  if (!value) return null;
+  const seconds = Number(value);
+  if (!Number.isFinite(seconds) || seconds < 0) return null;
+  return Math.min(seconds, RETRY_AFTER_CAP_SECONDS);
+}
+var quotaState = null;
+function getQuotaState() {
+  return quotaState ? { ...quotaState } : null;
+}
+function _resetQuotaStateForTesting() {
+  quotaState = null;
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function numberFromHeader(raw) {
+  if (raw === null) return void 0;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : void 0;
+}
+async function recordQuotaState(resp) {
+  try {
+    const state = {
+      kind: "unknown",
+      status: 429,
+      receivedAt: Date.now() / 1e3
+    };
+    let data = null;
+    try {
+      data = await resp.clone().json();
+    } catch {
+      data = null;
+    }
+    if (data !== null && typeof data === "object") {
+      const body = data;
+      const err = body.error;
+      if (err === "event_limit_exceeded") {
+        state.kind = "event_limit";
+        state.message = asString(body.message);
+        state.currentCount = asNumber(body.current_count);
+        state.limitCount = asNumber(body.limit_count);
+        state.planId = asString(body.plan_id);
+        state.periodStart = asString(body.period_start);
+        state.upgradeUrl = asString(body.upgrade_url);
+        state.sampleRateUrl = asString(body.sample_rate_url);
+      } else if (err !== null && typeof err === "object" && err.code === "RATE_LIMIT_INGEST") {
+        const errObj = err;
+        const details = errObj.details !== null && typeof errObj.details === "object" ? errObj.details : {};
+        state.kind = "rate_limit";
+        state.message = asString(errObj.message);
+        state.limitCount = asNumber(details.limit);
+        state.planId = asString(details.plan);
+      }
+    }
+    const quotaLimit = numberFromHeader(resp.headers.get("X-Morse-Quota-Limit"));
+    if (quotaLimit !== void 0) state.quotaLimit = quotaLimit;
+    const quotaRemaining = numberFromHeader(resp.headers.get("X-Morse-Quota-Remaining"));
+    if (quotaRemaining !== void 0) state.quotaRemaining = quotaRemaining;
+    const quotaReset = numberFromHeader(resp.headers.get("X-Morse-Quota-Reset"));
+    if (quotaReset !== void 0) state.quotaReset = quotaReset;
+    const retryAfter = parseRetryAfter(resp.headers.get("Retry-After"));
+    if (retryAfter !== null) state.retryAfterSeconds = retryAfter;
+    quotaState = state;
+  } catch {
+  }
+}
+var BatchTransport = class {
+  endpoint;
+  apiKey;
+  flushIntervalSeconds;
+  maxBatchSize;
+  maxQueueSize;
+  fetchTimeoutMs;
+  fetchImpl;
+  queue = [];
+  timer = null;
+  flushing = false;
+  closed = false;
+  inflight = null;
+  constructor(opts) {
+    this.endpoint = opts.endpoint;
+    this.apiKey = opts.apiKey;
+    this.flushIntervalSeconds = opts.flushIntervalSeconds ?? 2;
+    this.maxBatchSize = opts.maxBatchSize ?? 100;
+    this.maxQueueSize = opts.maxQueueSize ?? 1e4;
+    this.fetchTimeoutMs = opts.fetchTimeoutMs ?? 5e3;
+    this.fetchImpl = opts.fetchImpl ?? globalThis.fetch.bind(globalThis);
+    const intervalMs = Math.max(50, Math.round(this.flushIntervalSeconds * 1e3));
+    this.timer = setInterval(() => {
+      void this.tick();
+    }, intervalMs);
+    const t = this.timer;
+    if (typeof t?.unref === "function") {
+      t.unref();
+    }
+  }
+  /** Enqueue an event. Non-blocking. Returns false if the queue is full. */
+  track(event) {
+    if (this.closed) return false;
+    if (this.queue.length >= this.maxQueueSize) return false;
+    this.queue.push(event);
+    if (this.queue.length >= this.maxBatchSize) {
+      void this.tick();
+    }
+    return true;
+  }
+  /** Block until all currently-queued events have been sent. */
+  async flush() {
+    while (this.queue.length > 0) {
+      await this.tick();
+    }
+    if (this.inflight) {
+      try {
+        await this.inflight;
+      } catch {
+      }
+    }
+  }
+  /** Stop the background timer. After this call, `track()` is a no-op. */
+  async shutdown() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    await this.flush();
+  }
+  async tick() {
+    if (this.flushing) return;
+    if (this.queue.length === 0) return;
+    this.flushing = true;
+    try {
+      const batch = this.queue.splice(0, this.maxBatchSize);
+      this.inflight = this.sendBatch(batch);
+      await this.inflight;
+      this.inflight = null;
+    } finally {
+      this.flushing = false;
+    }
+  }
+  async sendBatch(batch) {
+    const traceEntries = [];
+    const runEntries = [];
+    const logEntries = [];
+    for (const event of batch) {
+      if (typeof event === "object" && event !== null && "traces" in event) {
+        const e = event;
+        if (Array.isArray(e.traces)) {
+          traceEntries.push(...e.traces);
+        }
+      } else if (typeof event === "object" && event !== null && "logs" in event) {
+        const e = event;
+        if (Array.isArray(e.logs)) {
+          logEntries.push(...e.logs);
+        }
+      } else {
+        runEntries.push(event);
+      }
+    }
+    if (traceEntries.length > 0) {
+      await this.post(this.endpoint, { traces: traceEntries });
+    }
+    if (runEntries.length > 0) {
+      await this.post(this.endpoint, { runs: runEntries });
+    }
+    if (logEntries.length > 0) {
+      await this.post(deriveLogsEndpoint(this.endpoint), { logs: logEntries });
+    }
+  }
+  async post(url, payload) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.fetchTimeoutMs);
+    try {
+      const resp = await this.fetchImpl(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json",
+          "User-Agent": `morse-typescript/${SDK_VERSION}`
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+      if (resp.status === 429) {
+        await recordQuotaState(resp);
+      }
+      if (!resp.ok) {
+        let bodySnippet = "";
+        try {
+          const text = await resp.text();
+          bodySnippet = text.slice(0, 200);
+        } catch {
+        }
+        chunk7EO7MQBA_cjs.report(new Error(`morse: batch POST returned ${resp.status} ${bodySnippet}`), {
+          fingerprint: "morse.transport.post.non_2xx",
+          extra: {
+            endpoint_host: hostnameOf(url),
+            sdk_version: SDK_VERSION
+          }
+        });
+      }
+    } catch (err) {
+      chunk7EO7MQBA_cjs.report(err, {
+        fingerprint: "morse.transport.post.network",
+        extra: {
+          endpoint_host: hostnameOf(url),
+          sdk_version: SDK_VERSION
+        }
+      });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+function hostnameOf(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return "<invalid>";
+  }
+}
+function deriveLogsEndpoint(tracesEndpoint) {
+  try {
+    const u = new URL(tracesEndpoint);
+    u.pathname = "/api/v1/logs/ingest";
+    u.search = "";
+    u.hash = "";
+    return u.toString();
+  } catch {
+    return tracesEndpoint.replace(/\/api\/v1\/.*$/, "/api/v1/logs/ingest");
+  }
+}
+
+// src/index.ts
+chunkFJUNILZT_cjs.init_tracing();
+chunkFJUNILZT_cjs.init_spans();
+chunkFJUNILZT_cjs.init_propagation();
+var version = SDK_VERSION;
+var singleton = null;
+var transportFactory = (opts) => new BatchTransport(opts);
+var noApiKeyWarningEmitted = false;
+var lastLoggedEndpoint = null;
+function logger2(level, message) {
+  const out = level === "warn" ? console.warn : console.info;
+  out.call(console, message);
+}
+function logDestinationOnce(endpoint) {
+  if (endpoint === lastLoggedEndpoint) return;
+  lastLoggedEndpoint = endpoint;
+  logger2(
+    "info",
+    `morse: Morse SDK initialized \u2014 sending to ${endpoint} (sdk version ${SDK_VERSION})`
+  );
+}
+function resolveEndpoint(explicit) {
+  if (explicit && explicit.length > 0) return explicit;
+  const fromEnv = chunkFJUNILZT_cjs.getEndpoint();
+  if (fromEnv) return fromEnv;
+  return chunkFJUNILZT_cjs.DEFAULT_ENDPOINT;
+}
+var OTLP_TRACES_PATH = "/api/v1/otlp/v1/traces";
+function deriveOtlpEndpoint(tracesEndpoint) {
+  try {
+    const u = new URL(tracesEndpoint);
+    u.pathname = OTLP_TRACES_PATH;
+    u.search = "";
+    u.hash = "";
+    return u.toString();
+  } catch {
+    return tracesEndpoint.replace(/\/api\/v1\/.*$/, OTLP_TRACES_PATH);
+  }
+}
+function buildSingleton(opts, redaction) {
+  if (chunkFJUNILZT_cjs.isDisabled()) {
+    return null;
+  }
+  const apiKey = opts.apiKey ?? chunkFJUNILZT_cjs.getApiKey();
+  if (!apiKey) {
+    if (!noApiKeyWarningEmitted) {
+      logger2(
+        "warn",
+        "morse: not initialized \u2014 set MORSE_API_KEY or call morse.init({ apiKey }) (this warning prints once per process; SDK calls are silent no-ops)"
+      );
+      noApiKeyWarningEmitted = true;
+    }
+    return null;
+  }
+  const endpoint = resolveEndpoint(opts.endpoint);
+  const flushIntervalSeconds = opts.flushIntervalSeconds ?? chunkFJUNILZT_cjs.getFlushIntervalSeconds();
+  const transport = transportFactory({ apiKey, endpoint, flushIntervalSeconds });
+  chunkFJUNILZT_cjs.setTransport(transport);
+  chunkFJUNILZT_cjs.setRedactionConfig(redaction);
+  const explicitSource = chunkFJUNILZT_cjs.isValidInternalSource(opts.source) ? opts.source : void 0;
+  const resolvedSource = explicitSource ?? chunkFJUNILZT_cjs.getInternalSource() ?? null;
+  chunkFJUNILZT_cjs.setSource(resolvedSource);
+  logDestinationOnce(endpoint);
+  try {
+    chunkFJUNILZT_cjs.getEngine().configure({
+      endpoint: deriveOtlpEndpoint(endpoint),
+      apiKey,
+      sampleRate: chunkFJUNILZT_cjs.getSampleRate(),
+      scheduleDelayMillis: flushIntervalSeconds * 1e3,
+      maxQueueSize: chunkFJUNILZT_cjs.getMaxQueueSize(),
+      maxExportBatchSize: chunkFJUNILZT_cjs.getMaxBatchSize(),
+      maxFieldBytes: chunkFJUNILZT_cjs.getMaxFieldBytes(),
+      // 10s (not the exporter's un-overridden 30s ceiling): a genuine
+      // network blip still gets several retries with backoff; a fully dead
+      // endpoint fails within a bounded, shutdown-friendly window instead
+      // of the library's full 30s ceiling. Mirrors the Python SDK.
+      timeoutMillis: 1e4,
+      redactionConfig: redaction
+    });
+  } catch (err) {
+    chunk7EO7MQBA_cjs.report(err, { fingerprint: "morse.otel_provider.configure" });
+  }
+  void installAdapters().catch(() => {
+  });
+  try {
+    maybeEnableDbCaptureFromEnv();
+  } catch (err) {
+    chunk7EO7MQBA_cjs.report(err, { fingerprint: "morse.db_capture.register" });
+  }
+  return { apiKey, endpoint, transport, redaction };
+}
+function ensureInitialized() {
+  if (chunkFJUNILZT_cjs.isDisabled()) return null;
+  if (singleton !== null) return singleton;
+  singleton = buildSingleton({}, chunkFJUNILZT_cjs.buildRedactionConfig());
+  return singleton;
+}
+chunkPVHDEPRE_cjs._setEnsureInitialized(() => {
+  ensureInitialized();
+});
+function init(options = {}) {
+  if (chunkFJUNILZT_cjs.isDisabled()) {
+    logger2("info", "morse: MORSE_DISABLED=1 \u2014 SDK is a no-op");
+    return;
+  }
+  const redaction = chunkFJUNILZT_cjs.buildRedactionConfig(options.redaction);
+  try {
+    if (singleton !== null) {
+      void singleton.transport.shutdown();
+      singleton = null;
+    }
+    singleton = buildSingleton(options, redaction);
+  } catch (err) {
+    chunk7EO7MQBA_cjs.report(err, { fingerprint: "morse.init" });
+  }
+}
+var track = chunk7EO7MQBA_cjs.absorbErrorsSync(
+  (options) => {
+    const state = ensureInitialized();
+    if (!state) return;
+    const payload = {
+      agent_id: options.agentId,
+      ...options.runData
+    };
+    const redacted = chunkFJUNILZT_cjs.redactValue(payload, state.redaction);
+    state.transport.track(redacted);
+  },
+  { fingerprint: "morse.track" }
+);
+var batchTrack = chunk7EO7MQBA_cjs.absorbErrorsSync(
+  (runs) => {
+    const state = ensureInitialized();
+    if (!state) return;
+    for (const run2 of runs) {
+      const redacted = chunkFJUNILZT_cjs.redactValue(run2, state.redaction);
+      state.transport.track(redacted);
+    }
+  },
+  { fingerprint: "morse.batch_track" }
+);
+var record = chunk7EO7MQBA_cjs.absorbErrorsSync(
+  (rec) => {
+    const state = ensureInitialized();
+    if (!state) return;
+    const traceId = chunkFJUNILZT_cjs.generateTraceId();
+    const now = chunkFJUNILZT_cjs.nowIso();
+    const resolvedStatus = rec.errorMessage ? "failed" : rec.status ?? "completed";
+    const span2 = {
+      trace_id: traceId,
+      span_id: chunkFJUNILZT_cjs.generateSpanId(),
+      type: chunkFJUNILZT_cjs.SpanType.AGENT,
+      name: rec.agent,
+      started_at: now,
+      ended_at: now,
+      status: resolvedStatus,
+      duration_ms: rec.durationMs,
+      model: rec.model,
+      input_tokens: rec.inputTokens,
+      output_tokens: rec.outputTokens,
+      total_tokens: rec.totalTokens,
+      cost_usd: rec.cost,
+      error_message: rec.errorMessage,
+      metadata: rec.metadata
+    };
+    const traceFields = {
+      trace_id: traceId,
+      agent: rec.agent,
+      status: resolvedStatus,
+      started_at: now,
+      ended_at: now,
+      duration_ms: rec.durationMs,
+      error_message: rec.errorMessage,
+      success: rec.success,
+      outcome: rec.outcome
+    };
+    const entry = chunkFJUNILZT_cjs.buildTraceEntry(traceFields, [span2]);
+    const redacted = chunkFJUNILZT_cjs.redactValue(entry, state.redaction);
+    chunkFJUNILZT_cjs.sendTrace(redacted);
+  },
+  { fingerprint: "morse.record" }
+);
+function run(nameOrOpts, fn) {
+  const opts = typeof nameOrOpts === "string" ? { agentName: nameOrOpts } : nameOrOpts;
+  ensureInitialized();
+  return chunkFJUNILZT_cjs.runSync(opts, fn);
+}
+function runTraced(options, fn) {
+  ensureInitialized();
+  return chunkFJUNILZT_cjs.runAsync(options, fn);
+}
+function setContext2(dims) {
+  chunkFJUNILZT_cjs.setContext(dims);
+}
+function startSpan2(options) {
+  return chunkFJUNILZT_cjs.startSpan(options);
+}
+function span(options, fn) {
+  return chunkFJUNILZT_cjs.spanSync(options, fn);
+}
+function spanAsync2(options, fn) {
+  return chunkFJUNILZT_cjs.spanAsync(options, fn);
+}
+var flush = chunk7EO7MQBA_cjs.absorbErrorsAsync(
+  async () => {
+    if (singleton !== null) {
+      await singleton.transport.flush();
+      await chunkFJUNILZT_cjs.getEngine().flush();
+    }
+  },
+  { fingerprint: "morse.flush" }
+);
+var quotaState2 = chunk7EO7MQBA_cjs.absorbErrorsSync(
+  () => {
+    if (singleton === null) return null;
+    return getQuotaState();
+  },
+  { fingerprint: "morse.quota_state" }
+);
+var shutdown = chunk7EO7MQBA_cjs.absorbErrorsAsync(
+  async () => {
+    if (singleton !== null) {
+      await singleton.transport.shutdown();
+      await chunkFJUNILZT_cjs.getEngine().flush();
+      chunkFJUNILZT_cjs.getEngine().shutdown();
+      singleton = null;
+      chunkFJUNILZT_cjs.setTransport(null);
+    }
+  },
+  { fingerprint: "morse.shutdown" }
+);
+function _resetForTesting4() {
+  if (singleton !== null) {
+    void singleton.transport.shutdown();
+    singleton = null;
+    chunkFJUNILZT_cjs.setTransport(null);
+  }
+  chunkFJUNILZT_cjs.getEngine().resetForTesting();
+  noApiKeyWarningEmitted = false;
+  lastLoggedEndpoint = null;
+  chunkFJUNILZT_cjs.setSource(null);
+  chunkFJUNILZT_cjs._resetForTesting();
+  chunk7EO7MQBA_cjs._resetForTesting();
+  _resetForTesting3();
+  _resetQuotaStateForTesting();
+  transportFactory = (opts) => new BatchTransport(opts);
+}
+function _setTransportFactoryForTesting(factory) {
+  transportFactory = factory;
+}
+function _getLastTraceForTesting() {
+  return chunkFJUNILZT_cjs.getLastTrace();
+}
+function _getActiveTraceStateForTesting() {
+  return chunkFJUNILZT_cjs.getActiveTraceState();
+}
+
+Object.defineProperty(exports, "MAX_SEGMENT_CONTENT_BYTES", {
+  enumerable: true,
+  get: function () { return chunk7YCENA54_cjs.MAX_SEGMENT_CONTENT_BYTES; }
+});
+Object.defineProperty(exports, "extractAnthropicSegments", {
+  enumerable: true,
+  get: function () { return chunk7YCENA54_cjs.extractAnthropicSegments; }
+});
+Object.defineProperty(exports, "instrumentAnthropic", {
+  enumerable: true,
+  get: function () { return chunk7YCENA54_cjs.instrumentAnthropic; }
+});
+Object.defineProperty(exports, "isAnthropicWrapped", {
+  enumerable: true,
+  get: function () { return chunk7YCENA54_cjs.isAnthropicWrapped; }
+});
+Object.defineProperty(exports, "uninstallAnthropic", {
+  enumerable: true,
+  get: function () { return chunk7YCENA54_cjs.uninstallAnthropic; }
+});
+Object.defineProperty(exports, "wrapAnthropic", {
+  enumerable: true,
+  get: function () { return chunk7YCENA54_cjs.wrapAnthropic; }
+});
+Object.defineProperty(exports, "log", {
+  enumerable: true,
+  get: function () { return chunkPVHDEPRE_cjs.log; }
+});
+Object.defineProperty(exports, "W3C_TRACEPARENT_HEADER", {
+  enumerable: true,
+  get: function () { return chunkFJUNILZT_cjs.W3C_TRACEPARENT_HEADER; }
+});
+Object.defineProperty(exports, "extractTraceparent", {
+  enumerable: true,
+  get: function () { return chunkFJUNILZT_cjs.extractTraceparent; }
+});
+Object.defineProperty(exports, "formatTraceparent", {
+  enumerable: true,
+  get: function () { return chunkFJUNILZT_cjs.formatTraceparent; }
+});
+Object.defineProperty(exports, "injectIntoRequestInit", {
+  enumerable: true,
+  get: function () { return chunkFJUNILZT_cjs.injectIntoRequestInit; }
+});
+Object.defineProperty(exports, "injectTraceparent", {
+  enumerable: true,
+  get: function () { return chunkFJUNILZT_cjs.injectTraceparent; }
+});
+exports._getActiveTraceStateForTesting = _getActiveTraceStateForTesting;
+exports._getLastTraceForTesting = _getLastTraceForTesting;
+exports._resetForTesting = _resetForTesting4;
+exports._setTransportFactoryForTesting = _setTransportFactoryForTesting;
+exports.batchTrack = batchTrack;
+exports.flush = flush;
+exports.init = init;
+exports.quotaState = quotaState2;
+exports.record = record;
+exports.run = run;
+exports.runTraced = runTraced;
+exports.setContext = setContext2;
+exports.shutdown = shutdown;
+exports.span = span;
+exports.spanAsync = spanAsync2;
+exports.startSpan = startSpan2;
+exports.track = track;
+exports.version = version;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map