@glassflow-ai/rius 0.1.0

package/dist/index.cjs

@@ -0,0 +1,914 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config.ts
+function bool(name, raw, fallback) {
+  if (raw === void 0) return fallback;
+  const value = raw.trim().toLowerCase();
+  if (AFFIRMATIVE.has(value)) return true;
+  if (NEGATIVE.has(value)) return false;
+  console.warn(
+    `[rius] ${name}="${raw}" is not a recognised boolean; using the default (${fallback}). Accepted: 1/true/yes/on, 0/false/no/off.`
+  );
+  return fallback;
+}
+function rate(raw, fallback) {
+  if (raw === void 0) return fallback;
+  const parsed = Number.parseFloat(raw);
+  if (Number.isNaN(parsed)) return fallback;
+  return Math.min(1, Math.max(0, parsed));
+}
+function resolveConfig(options = {}, env = process.env) {
+  const endpoint = (options.endpoint ?? env.RIUS_ENDPOINT ?? DEFAULT_ENDPOINT).replace(/\/+$/, "");
+  return {
+    endpoint,
+    apiKey: options.apiKey ?? env.RIUS_API_KEY,
+    serviceName: options.serviceName ?? env.RIUS_SERVICE_NAME ?? DEFAULT_SERVICE_NAME,
+    disabled: options.disabled ?? bool("RIUS_DISABLED", env.RIUS_DISABLED, false),
+    sampleRate: options.sampleRate ?? rate(env.RIUS_SAMPLE_RATE, 1),
+    captureContent: options.captureContent ?? bool("RIUS_CAPTURE_CONTENT", env.RIUS_CAPTURE_CONTENT, true),
+    mask: options.mask
+  };
+}
+var DEFAULT_ENDPOINT, DEFAULT_SERVICE_NAME, AFFIRMATIVE, NEGATIVE;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    DEFAULT_ENDPOINT = "https://ingest.eu.console.rius-glassflow.com";
+    DEFAULT_SERVICE_NAME = "unknown_service";
+    AFFIRMATIVE = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+    NEGATIVE = /* @__PURE__ */ new Set(["0", "false", "no", "off"]);
+  }
+});
+
+// src/delegatingProcessor.ts
+var DelegatingSpanProcessor;
+var init_delegatingProcessor = __esm({
+  "src/delegatingProcessor.ts"() {
+    "use strict";
+    DelegatingSpanProcessor = class {
+      delegates = [];
+      add(processor) {
+        this.delegates.push(processor);
+      }
+      /**
+       * Insert ahead of existing delegates, for a processor that must observe a span
+       * before the exporting processor queues it.
+       *
+       * Required by attribute-transforming processors: once a span is queued for
+       * export, later mutation is not guaranteed to be seen, and attributes a
+       * transform ADDS would bypass the masking applied in the exporter chain.
+       */
+      addFirst(processor) {
+        this.delegates.unshift(processor);
+      }
+      onStart(span, parentContext) {
+        for (const delegate of this.delegates) delegate.onStart(span, parentContext);
+      }
+      onEnd(span) {
+        for (const delegate of this.delegates) delegate.onEnd(span);
+      }
+      async forceFlush() {
+        await Promise.allSettled(this.delegates.map((d) => d.forceFlush()));
+      }
+      async shutdown() {
+        await Promise.allSettled(this.delegates.map((d) => d.shutdown()));
+      }
+    };
+  }
+});
+
+// node_modules/@opentelemetry/core/build/esm/ExportResult.js
+var ExportResultCode;
+var init_ExportResult = __esm({
+  "node_modules/@opentelemetry/core/build/esm/ExportResult.js"() {
+    "use strict";
+    (function(ExportResultCode2) {
+      ExportResultCode2[ExportResultCode2["SUCCESS"] = 0] = "SUCCESS";
+      ExportResultCode2[ExportResultCode2["FAILED"] = 1] = "FAILED";
+    })(ExportResultCode || (ExportResultCode = {}));
+  }
+});
+
+// node_modules/@opentelemetry/core/build/esm/index.js
+var init_esm = __esm({
+  "node_modules/@opentelemetry/core/build/esm/index.js"() {
+    "use strict";
+    init_ExportResult();
+  }
+});
+
+// src/exportHealth.ts
+var ExportOutcomeExporter;
+var init_exportHealth = __esm({
+  "src/exportHealth.ts"() {
+    "use strict";
+    init_esm();
+    ExportOutcomeExporter = class {
+      constructor(inner, onFirstFailure = (m) => console.warn(m)) {
+        this.inner = inner;
+        this.onFirstFailure = onFirstFailure;
+      }
+      inner;
+      onFirstFailure;
+      failed = false;
+      warned = false;
+      get lastExportFailed() {
+        return this.failed;
+      }
+      export(spans, resultCallback) {
+        this.inner.export(spans, (result) => {
+          if (result.code === ExportResultCode.FAILED) {
+            this.failed = true;
+            if (!this.warned) {
+              this.warned = true;
+              try {
+                this.onFirstFailure(
+                  `[rius] span export failed: ${result.error?.message ?? "unknown error"}. Check RIUS_API_KEY and RIUS_ENDPOINT. Further failures will not be logged.`
+                );
+              } catch {
+              }
+            }
+          } else {
+            this.failed = false;
+          }
+          resultCallback(result);
+        });
+      }
+      shutdown() {
+        return this.inner.shutdown();
+      }
+      forceFlush() {
+        return this.inner.forceFlush?.() ?? Promise.resolve();
+      }
+    };
+  }
+});
+
+// src/semconv.ts
+function kindAttributes(kind) {
+  const attributes = { [OPENINFERENCE_SPAN_KIND]: kind };
+  const operation = OPERATION_BY_KIND[kind];
+  if (operation !== void 0) attributes[GEN_AI_OPERATION_NAME] = operation;
+  return attributes;
+}
+var TRACER_NAME, OPENINFERENCE_SPAN_KIND, INPUT_VALUE, OUTPUT_VALUE, GEN_AI_OPERATION_NAME, GEN_AI_PROVIDER_NAME, GEN_AI_REQUEST_MODEL, GEN_AI_RESPONSE_MODEL, GEN_AI_USAGE_INPUT_TOKENS, GEN_AI_USAGE_OUTPUT_TOKENS, GEN_AI_INPUT_MESSAGES, GEN_AI_OUTPUT_MESSAGES, GEN_AI_RESPONSE_FINISH_REASONS, GEN_AI_TOOL_NAME, GEN_AI_REQUEST_PREFIX, MCP_RESULT_TYPE, GEN_AI_FIRST_TOKEN_EVENT, SpanKind, OPERATION_BY_KIND, CONTENT_ATTRIBUTES, CONTENT_ATTRIBUTE_PREFIXES, CONTENT_ATTRIBUTE_SUFFIXES;
+var init_semconv = __esm({
+  "src/semconv.ts"() {
+    "use strict";
+    TRACER_NAME = "glassflow";
+    OPENINFERENCE_SPAN_KIND = "openinference.span.kind";
+    INPUT_VALUE = "input.value";
+    OUTPUT_VALUE = "output.value";
+    GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
+    GEN_AI_PROVIDER_NAME = "gen_ai.provider.name";
+    GEN_AI_REQUEST_MODEL = "gen_ai.request.model";
+    GEN_AI_RESPONSE_MODEL = "gen_ai.response.model";
+    GEN_AI_USAGE_INPUT_TOKENS = "gen_ai.usage.input_tokens";
+    GEN_AI_USAGE_OUTPUT_TOKENS = "gen_ai.usage.output_tokens";
+    GEN_AI_INPUT_MESSAGES = "gen_ai.input.messages";
+    GEN_AI_OUTPUT_MESSAGES = "gen_ai.output.messages";
+    GEN_AI_RESPONSE_FINISH_REASONS = "gen_ai.response.finish_reasons";
+    GEN_AI_TOOL_NAME = "gen_ai.tool.name";
+    GEN_AI_REQUEST_PREFIX = "gen_ai.request.";
+    MCP_RESULT_TYPE = "mcp.result_type";
+    GEN_AI_FIRST_TOKEN_EVENT = "gen_ai.first_token";
+    SpanKind = /* @__PURE__ */ ((SpanKind2) => {
+      SpanKind2["AGENT"] = "AGENT";
+      SpanKind2["LLM"] = "LLM";
+      SpanKind2["TOOL"] = "TOOL";
+      SpanKind2["RETRIEVER"] = "RETRIEVER";
+      SpanKind2["EMBEDDING"] = "EMBEDDING";
+      SpanKind2["CHAIN"] = "CHAIN";
+      return SpanKind2;
+    })(SpanKind || {});
+    OPERATION_BY_KIND = {
+      ["LLM" /* LLM */]: "chat",
+      ["TOOL" /* TOOL */]: "execute_tool",
+      ["EMBEDDING" /* EMBEDDING */]: "embeddings",
+      ["AGENT" /* AGENT */]: "invoke_agent"
+    };
+    CONTENT_ATTRIBUTES = /* @__PURE__ */ new Set([
+      INPUT_VALUE,
+      OUTPUT_VALUE,
+      GEN_AI_INPUT_MESSAGES,
+      GEN_AI_OUTPUT_MESSAGES,
+      "gen_ai.prompt",
+      "gen_ai.completion",
+      "llm.input_messages",
+      "llm.output_messages",
+      // The prefix list below covers the flattened "llm.prompts." and
+      // "llm.prompt_template." forms, but an instrumentation may emit either as a
+      // single unflattened array attribute under the bare key, which no prefix
+      // matches. Both bare keys are therefore listed here as well.
+      "llm.prompts",
+      "llm.prompt_template",
+      "mlflow.spanInputs",
+      "mlflow.spanOutputs",
+      "traceloop.entity.input",
+      "traceloop.entity.output"
+    ]);
+    CONTENT_ATTRIBUTE_PREFIXES = [
+      "llm.input_messages.",
+      "llm.output_messages.",
+      "gen_ai.prompt.",
+      "gen_ai.completion.",
+      "llm.prompts.",
+      "llm.prompt_template."
+    ];
+    CONTENT_ATTRIBUTE_SUFFIXES = [
+      ".document.content",
+      ".embedding.text"
+    ];
+  }
+});
+
+// src/serde.ts
+function toAttributeValue(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (value === null || value === void 0) return "";
+  const ancestors = [];
+  try {
+    return JSON.stringify(value, function(_key, v) {
+      if (typeof v === "object" && v !== null) {
+        while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) {
+          ancestors.pop();
+        }
+        if (ancestors.includes(v)) return "[Circular]";
+        ancestors.push(v);
+      }
+      return v;
+    }) ?? String(value);
+  } catch {
+    return "[unserializable]";
+  }
+}
+var init_serde = __esm({
+  "src/serde.ts"() {
+    "use strict";
+  }
+});
+
+// src/spans.ts
+function configure(observation, options) {
+  if (options.input !== void 0) observation.setInput(options.input);
+  return observation;
+}
+function startSpan(name, options = {}) {
+  const span = getTracer().startSpan(name, {
+    attributes: kindAttributes(options.kind ?? "CHAIN" /* CHAIN */)
+  });
+  return configure(new Observation(span), options);
+}
+function startAsCurrentSpan(name, optionsOrFn, maybeFn) {
+  const [options, fn] = typeof optionsOrFn === "function" ? [{}, optionsOrFn] : [optionsOrFn, maybeFn];
+  return getTracer().startActiveSpan(
+    name,
+    { attributes: kindAttributes(options.kind ?? "CHAIN" /* CHAIN */) },
+    async (span) => {
+      const observation = configure(new Observation(span), options);
+      try {
+        return await fn(observation);
+      } catch (error) {
+        observation.recordException(error);
+        throw error;
+      } finally {
+        observation.end();
+      }
+    }
+  );
+}
+var import_api, Observation;
+var init_spans = __esm({
+  "src/spans.ts"() {
+    "use strict";
+    import_api = require("@opentelemetry/api");
+    init_client();
+    init_semconv();
+    init_serde();
+    Observation = class {
+      constructor(span) {
+        this.span = span;
+      }
+      span;
+      ended = false;
+      setInput(value) {
+        this.span.setAttribute(INPUT_VALUE, toAttributeValue(value));
+        return this;
+      }
+      setOutput(value) {
+        this.span.setAttribute(OUTPUT_VALUE, toAttributeValue(value));
+        return this;
+      }
+      setAttribute(key, value) {
+        this.span.setAttribute(key, toAttributeValue(value));
+        return this;
+      }
+      /**
+       * Record an error on the span and set ERROR status. This is exactly what the
+       * `startAsCurrent*` helpers do on a thrown error, exposed so the manual
+       * `start*` path does not have to reach through `.span` to match it.
+       *
+       * Accepts `unknown` because that is what a `catch` binding is; a non-Error
+       * throwable is wrapped so `recordException` still gets a real Error.
+       */
+      recordException(error) {
+        const wrapped = error instanceof Error ? error : new Error(String(error));
+        this.span.recordException(wrapped);
+        this.span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: wrapped.message });
+        return this;
+      }
+      end() {
+        if (this.ended) return;
+        this.ended = true;
+        this.span.end();
+      }
+      /** Lets callers write `using obs = startSpan(...)`. Sugar over end(). */
+      [Symbol.dispose]() {
+        this.end();
+      }
+    };
+  }
+});
+
+// src/instrumentationMcp.ts
+var instrumentationMcp_exports = {};
+__export(instrumentationMcp_exports, {
+  instrumentMcpClient: () => instrumentMcpClient
+});
+function recordResult(observation, result) {
+  const resultType = typeof result === "object" && result !== null ? result.result_type ?? result.resultType : void 0;
+  if (resultType === INPUT_REQUIRED) {
+    observation.setAttribute(MCP_RESULT_TYPE, INPUT_REQUIRED);
+    return;
+  }
+  observation.setOutput(result);
+}
+function instrumentMcpClient(ClientClass) {
+  const current = ClientClass.prototype.callTool;
+  const alreadyWrapped = current.riusOriginal;
+  if (alreadyWrapped !== void 0) {
+    return () => {
+      ClientClass.prototype.callTool = alreadyWrapped;
+    };
+  }
+  const original = ClientClass.prototype.callTool;
+  const instrumented = function instrumentedCallTool(params, ...rest) {
+    return startAsCurrentSpan(
+      params.name,
+      { kind: "TOOL" /* TOOL */, input: params.arguments },
+      async (observation) => {
+        observation.setAttribute(GEN_AI_TOOL_NAME, params.name);
+        const result = await original.call(this, params, ...rest);
+        recordResult(observation, result);
+        return result;
+      }
+    );
+  };
+  instrumented.riusOriginal = original;
+  ClientClass.prototype.callTool = instrumented;
+  return () => {
+    ClientClass.prototype.callTool = original;
+  };
+}
+var INPUT_REQUIRED;
+var init_instrumentationMcp = __esm({
+  "src/instrumentationMcp.ts"() {
+    "use strict";
+    init_semconv();
+    init_spans();
+    INPUT_REQUIRED = "input_required";
+  }
+});
+
+// src/instrumentation.ts
+function packageOf(specifier) {
+  const segments = specifier.split("/");
+  const take = specifier.startsWith("@") ? 2 : 1;
+  return segments.slice(0, take).join("/");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isUnresolved(error, specifier) {
+  if (typeof error !== "object" || error === null) return false;
+  const message = error.message;
+  if (typeof message !== "string") return false;
+  const alternatives = [specifier, packageOf(specifier)].map(escapeRegExp).join("|");
+  return new RegExp(
+    `(?:cannot find (?:module|package)|could not resolve|failed to load url)\\s*['"\`]?(?:${alternatives})['"\`]?(?![\\w./@-])`,
+    "i"
+  ).test(message);
+}
+async function optional(specifier) {
+  try {
+    return await dynamicImport(specifier);
+  } catch (error) {
+    if (isUnresolved(error, specifier)) return void 0;
+    if (error.code === "ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING") {
+      try {
+        return await import(specifier);
+      } catch (fallbackError) {
+        if (isUnresolved(fallbackError, specifier)) return void 0;
+        warnBroken(specifier, fallbackError);
+        return void 0;
+      }
+    }
+    warnBroken(specifier, error);
+    return void 0;
+  }
+}
+function warnBroken(subject, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn(`[rius] integration "${subject}" is installed but failed to load: ${message}`);
+}
+function cachedCjsExports(pkg, toPatchable) {
+  let cache;
+  try {
+    cache = (0, import_node_module.createRequire)((0, import_node_path.join)(process.cwd(), "noop.js")).cache;
+  } catch {
+    return void 0;
+  }
+  if (cache === void 0 || cache === null) return void 0;
+  const needle = `${import_node_path.sep}node_modules${import_node_path.sep}${pkg.split("/").join(import_node_path.sep)}${import_node_path.sep}`;
+  for (const key of Object.keys(cache)) {
+    if (!key.includes(needle)) continue;
+    const exports2 = cache[key]?.exports;
+    if (typeof exports2 !== "object" || exports2 === null) continue;
+    const patchable = toPatchable(exports2);
+    if (patchable !== void 0) return patchable;
+  }
+  return void 0;
+}
+async function patchActiveBuild(instrumentation, pkg, toPatchable) {
+  const cached = cachedCjsExports(pkg, toPatchable);
+  if (cached !== void 0) {
+    instrumentation.manuallyInstrument(cached);
+    return;
+  }
+  const ns = await optional(pkg);
+  if (ns === void 0) return;
+  const patchable = toPatchable(ns);
+  if (patchable === void 0) {
+    warnBroken(pkg, new Error("unrecognised module shape, instrumentation not applied"));
+    return;
+  }
+  instrumentation.manuallyInstrument(patchable);
+}
+function openaiPatchable(exports2) {
+  const cls = exports2.OpenAI ?? exports2.default;
+  return cls?.Chat?.Completions?.prototype?.create ? { OpenAI: cls } : void 0;
+}
+function anthropicPatchable(exports2) {
+  const cls = exports2.default ?? exports2.Anthropic;
+  return cls?.Messages?.prototype?.create ? { default: cls } : void 0;
+}
+function mcpClientPatchable(exports2) {
+  const cls = exports2.Client;
+  return typeof cls?.prototype?.callTool === "function" ? { Client: cls } : void 0;
+}
+async function enableInstrumentations(sink, tracerProvider, names) {
+  const wanted = names ? REGISTRY.filter((e) => names.includes(e.name)) : REGISTRY;
+  const enabled = [];
+  for (const entry of wanted) {
+    try {
+      const loaded = await entry.load();
+      if (loaded === void 0) continue;
+      if (entry.kind === "processor") {
+        if (entry.insert === "first") sink.addFirst(loaded);
+        else sink.add(loaded);
+      } else if (entry.kind === "instrumentation") {
+        (0, import_instrumentation.registerInstrumentations)({
+          instrumentations: [loaded],
+          tracerProvider
+        });
+      }
+      enabled.push(entry.name);
+    } catch (error) {
+      warnBroken(entry.name, error);
+    }
+  }
+  return enabled;
+}
+var import_node_module, import_node_path, import_instrumentation, dynamicImport, REGISTRY;
+var init_instrumentation = __esm({
+  "src/instrumentation.ts"() {
+    "use strict";
+    import_node_module = require("module");
+    import_node_path = require("path");
+    import_instrumentation = require("@opentelemetry/instrumentation");
+    dynamicImport = new Function("s", "return import(s)");
+    REGISTRY = [
+      {
+        name: "vercel-ai",
+        kind: "processor",
+        // The transform can ADD content attributes such as input.value. Masking
+        // runs in the exporter chain, which executes after a span is queued, so the
+        // transform has to run before the exporting processor sees the span or the
+        // attributes it added would never be sanitised.
+        insert: "first",
+        async load() {
+          const utils = await optional("@arizeai/openinference-vercel/utils");
+          const add = utils?.addOpenInferenceAttributesToSpan;
+          if (add === void 0) return void 0;
+          return {
+            onStart() {
+            },
+            onEnd(span) {
+              add(span);
+            },
+            async forceFlush() {
+            },
+            async shutdown() {
+            }
+          };
+        }
+      },
+      {
+        name: "openai",
+        kind: "instrumentation",
+        async load() {
+          const mod = await optional("@arizeai/openinference-instrumentation-openai");
+          const Ctor = mod?.OpenAIInstrumentation;
+          if (Ctor === void 0) return void 0;
+          const instrumentation = new Ctor();
+          await patchActiveBuild(instrumentation, "openai", openaiPatchable);
+          return instrumentation;
+        }
+      },
+      {
+        name: "anthropic",
+        kind: "instrumentation",
+        async load() {
+          const mod = await optional("@arizeai/openinference-instrumentation-anthropic");
+          const Ctor = mod?.AnthropicInstrumentation;
+          if (Ctor === void 0) return void 0;
+          const instrumentation = new Ctor();
+          await patchActiveBuild(instrumentation, "@anthropic-ai/sdk", anthropicPatchable);
+          return instrumentation;
+        }
+      },
+      {
+        name: "langchain",
+        kind: "instrumentation",
+        async load() {
+          const mod = await optional("@arizeai/openinference-instrumentation-langchain");
+          const Ctor = mod?.LangChainInstrumentation;
+          if (Ctor === void 0) return void 0;
+          const callbacks = await optional("@langchain/core/callbacks/manager");
+          if (callbacks?.CallbackManager === void 0) return void 0;
+          const instrumentation = new Ctor();
+          instrumentation.manuallyInstrument(callbacks);
+          return instrumentation;
+        }
+      },
+      {
+        name: "mcp",
+        kind: "self-applying",
+        async load() {
+          const mod = await optional("@modelcontextprotocol/sdk/client/index.js");
+          const ClientClass = mod?.Client;
+          if (ClientClass === void 0) return void 0;
+          const { instrumentMcpClient: instrumentMcpClient2 } = await Promise.resolve().then(() => (init_instrumentationMcp(), instrumentationMcp_exports));
+          instrumentMcpClient2(ClientClass);
+          const cjs = cachedCjsExports("@modelcontextprotocol/sdk", mcpClientPatchable);
+          if (cjs !== void 0) instrumentMcpClient2(cjs.Client);
+          return true;
+        }
+      }
+    ];
+  }
+});
+
+// src/masking.ts
+function isContentKey(key) {
+  if (CONTENT_ATTRIBUTES.has(key)) return true;
+  if (CONTENT_ATTRIBUTE_PREFIXES.some((p) => key.startsWith(p))) return true;
+  return CONTENT_ATTRIBUTE_SUFFIXES.some((s) => key.endsWith(s));
+}
+var import_api2, EXCEPTION_EVENT_NAME, EXCEPTION_CONTENT_KEYS, MaskingSpanExporter;
+var init_masking = __esm({
+  "src/masking.ts"() {
+    "use strict";
+    import_api2 = require("@opentelemetry/api");
+    init_semconv();
+    init_serde();
+    EXCEPTION_EVENT_NAME = "exception";
+    EXCEPTION_CONTENT_KEYS = ["exception.message", "exception.stacktrace"];
+    MaskingSpanExporter = class {
+      constructor(inner, opts) {
+        this.inner = inner;
+        this.opts = opts;
+      }
+      inner;
+      opts;
+      export(spans, resultCallback) {
+        this.inner.export(
+          spans.map((s) => this.sanitized(s)),
+          resultCallback
+        );
+      }
+      sanitized(span) {
+        this.sanitizeAttributes(span.attributes);
+        for (const event of span.events ?? []) {
+          const attributes = event.attributes;
+          this.sanitizeAttributes(attributes);
+          if (this.opts.captureContent || attributes === void 0) continue;
+          if (event.name !== EXCEPTION_EVENT_NAME) continue;
+          for (const key of EXCEPTION_CONTENT_KEYS) delete attributes[key];
+        }
+        for (const link of span.links ?? []) {
+          this.sanitizeAttributes(link.attributes);
+        }
+        if (!this.opts.captureContent && span.status?.code === import_api2.SpanStatusCode.ERROR) {
+          span.status.message = void 0;
+        }
+        return span;
+      }
+      /** Strips or masks the content keys of one attribute bag, in place. */
+      sanitizeAttributes(attributes) {
+        if (attributes === void 0) return;
+        for (const key of Object.keys(attributes)) {
+          if (!isContentKey(key)) continue;
+          if (!this.opts.captureContent) {
+            delete attributes[key];
+            continue;
+          }
+          if (this.opts.mask === void 0) continue;
+          try {
+            attributes[key] = toAttributeValue(this.opts.mask(attributes[key], { key }));
+          } catch {
+            attributes[key] = "[mask error]";
+          }
+        }
+      }
+      shutdown() {
+        return this.inner.shutdown();
+      }
+      forceFlush() {
+        return this.inner.forceFlush?.() ?? Promise.resolve();
+      }
+    };
+  }
+});
+
+// src/client.ts
+function init(options = {}) {
+  if (globalClient !== void 0) {
+    console.warn(
+      "[rius] init() called twice; returning the existing client. Call shutdown() first to reconfigure."
+    );
+    return globalClient;
+  }
+  const config = resolveConfig(options);
+  const processors = new DelegatingSpanProcessor();
+  let health;
+  if (!config.disabled) {
+    const base = options.spanExporter ?? new import_exporter_trace_otlp_http.OTLPTraceExporter({
+      url: `${config.endpoint}/v1/traces`,
+      headers: config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : void 0
+    });
+    health = new ExportOutcomeExporter(base);
+    const exporter = !config.captureContent || config.mask !== void 0 ? new MaskingSpanExporter(health, {
+      captureContent: config.captureContent,
+      mask: config.mask
+    }) : health;
+    processors.add(new import_sdk_trace_base.BatchSpanProcessor(exporter));
+  }
+  const provider = new import_sdk_trace_node.NodeTracerProvider({
+    resource: (0, import_resources.resourceFromAttributes)({ [import_semantic_conventions.ATTR_SERVICE_NAME]: config.serviceName }),
+    // Always ParentBased, with no AlwaysOn shortcut at rate 1. They are not
+    // equivalent: ParentBased honours a remote UNSAMPLED parent and drops,
+    // while AlwaysOn records regardless, producing children of a span the
+    // upstream service dropped. Rate 1 is the default, so the shortcut would
+    // have been the default path for every user.
+    sampler: new import_sdk_trace_base.ParentBasedSampler({ root: new import_sdk_trace_base.TraceIdRatioBasedSampler(config.sampleRate) }),
+    spanProcessors: [processors]
+  });
+  const ready = config.disabled ? Promise.resolve([]) : enableInstrumentations(processors, provider).catch(() => []);
+  provider.register();
+  globalClient = createClient({ provider, processors, health, ready });
+  return globalClient;
+}
+function getTracer() {
+  return import_api3.trace.getTracer(TRACER_NAME);
+}
+var import_api3, import_exporter_trace_otlp_http, import_resources, import_sdk_trace_base, import_sdk_trace_node, import_semantic_conventions, sinks, createClient, RiusClient, globalClient;
+var init_client = __esm({
+  "src/client.ts"() {
+    "use strict";
+    import_api3 = require("@opentelemetry/api");
+    import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+    import_resources = require("@opentelemetry/resources");
+    import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+    import_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
+    import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+    init_config();
+    init_delegatingProcessor();
+    init_exportHealth();
+    init_instrumentation();
+    init_masking();
+    init_semconv();
+    sinks = /* @__PURE__ */ new WeakMap();
+    RiusClient = class _RiusClient {
+      provider;
+      health;
+      /** Resolves with the names of the auto-instrumentations that attached. */
+      ready;
+      constructor(parts) {
+        this.provider = parts.provider;
+        this.health = parts.health;
+        this.ready = parts.ready;
+        sinks.set(this, parts.processors);
+      }
+      static {
+        createClient = (parts) => new _RiusClient(parts);
+      }
+      /** Drains the queue. Resolves false if the most recent export failed. */
+      async flush() {
+        await this.provider.forceFlush();
+        return this.health?.lastExportFailed !== true;
+      }
+      /**
+       * Drains and tears down the provider, then releases the global registration
+       * so a later init() can reconfigure the SDK.
+       */
+      async shutdown() {
+        try {
+          await this.provider.shutdown();
+        } finally {
+          if (globalClient === this) {
+            globalClient = void 0;
+            import_api3.trace.disable();
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Generation: () => Generation,
+  Observation: () => Observation,
+  RiusClient: () => RiusClient,
+  SpanKind: () => SpanKind,
+  VERSION: () => VERSION,
+  getTracer: () => getTracer,
+  init: () => init,
+  observe: () => observe,
+  startAsCurrentGeneration: () => startAsCurrentGeneration,
+  startAsCurrentSpan: () => startAsCurrentSpan,
+  startGeneration: () => startGeneration,
+  startSpan: () => startSpan
+});
+module.exports = __toCommonJS(index_exports);
+init_client();
+
+// src/generation.ts
+init_client();
+init_semconv();
+init_serde();
+init_spans();
+var Generation = class extends Observation {
+  firstTokenRecorded = false;
+  setInput(value) {
+    this.span.setAttribute(GEN_AI_INPUT_MESSAGES, toAttributeValue(value));
+    return this;
+  }
+  setOutput(value) {
+    this.span.setAttribute(GEN_AI_OUTPUT_MESSAGES, toAttributeValue(value));
+    return this;
+  }
+  setModel(model) {
+    this.span.setAttribute(GEN_AI_RESPONSE_MODEL, model);
+    return this;
+  }
+  setUsage(usage) {
+    if (usage.inputTokens !== void 0) {
+      this.span.setAttribute(GEN_AI_USAGE_INPUT_TOKENS, usage.inputTokens);
+    }
+    if (usage.outputTokens !== void 0) {
+      this.span.setAttribute(GEN_AI_USAGE_OUTPUT_TOKENS, usage.outputTokens);
+    }
+    return this;
+  }
+  /**
+   * Why generation stopped (`gen_ai.response.finish_reasons`), e.g. `"stop"`,
+   * `"length"`, `"tool_calls"`. The convention is a list; a single reason is
+   * wrapped so callers do not have to.
+   */
+  setFinishReasons(reasons) {
+    this.span.setAttribute(
+      GEN_AI_RESPONSE_FINISH_REASONS,
+      typeof reasons === "string" ? [reasons] : reasons
+    );
+    return this;
+  }
+  /**
+   * The TTFT anchor: event time minus span start. Idempotent: only the
+   * first call records the event, so a streaming loop can call this
+   * unconditionally on every chunk without inflating the span. A no-op
+   * after the span has ended.
+   */
+  recordFirstToken() {
+    if (this.firstTokenRecorded || !this.span.isRecording()) {
+      return this;
+    }
+    this.span.addEvent(GEN_AI_FIRST_TOKEN_EVENT);
+    this.firstTokenRecorded = true;
+    return this;
+  }
+};
+function attributesFor(options) {
+  const attributes = { ...kindAttributes("LLM" /* LLM */) };
+  if (options.model !== void 0) attributes[GEN_AI_REQUEST_MODEL] = options.model;
+  if (options.provider !== void 0) attributes[GEN_AI_PROVIDER_NAME] = options.provider;
+  return attributes;
+}
+function configure2(generation, options) {
+  for (const [key, value] of Object.entries(options.modelParameters ?? {})) {
+    generation.setAttribute(`${GEN_AI_REQUEST_PREFIX}${key}`, value);
+  }
+  if (options.input !== void 0) generation.setInput(options.input);
+  return generation;
+}
+function startGeneration(name, options = {}) {
+  const span = getTracer().startSpan(name, { attributes: attributesFor(options) });
+  return configure2(new Generation(span), options);
+}
+function startAsCurrentGeneration(name, optionsOrFn, maybeFn) {
+  const [options, fn] = typeof optionsOrFn === "function" ? [{}, optionsOrFn] : [optionsOrFn, maybeFn];
+  return getTracer().startActiveSpan(name, { attributes: attributesFor(options) }, async (span) => {
+    const generation = configure2(new Generation(span), options);
+    try {
+      return await fn(generation);
+    } catch (error) {
+      generation.recordException(error);
+      throw error;
+    } finally {
+      generation.end();
+    }
+  });
+}
+
+// src/observe.ts
+init_spans();
+function observe(fn, options = {}) {
+  const name = options.name ?? (fn.name || "anonymous");
+  const captureInput = options.captureInput ?? true;
+  const captureOutput = options.captureOutput ?? true;
+  const wrapped = (...args) => startAsCurrentSpan(
+    name,
+    { kind: options.kind, input: captureInput ? args : void 0 },
+    async (observation) => {
+      const result = await fn(...args);
+      if (captureOutput && result !== void 0) observation.setOutput(result);
+      return result;
+    }
+  );
+  Object.defineProperty(wrapped, "name", { value: name, configurable: true });
+  return wrapped;
+}
+
+// src/index.ts
+init_semconv();
+init_spans();
+var VERSION = "0.1.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Generation,
+  Observation,
+  RiusClient,
+  SpanKind,
+  VERSION,
+  getTracer,
+  init,
+  observe,
+  startAsCurrentGeneration,
+  startAsCurrentSpan,
+  startGeneration,
+  startSpan
+});