@glassflow-ai/rius 0.8.0 → 1.0.0

package/dist/index.cjs

@@ -30,7 +30,74 @@ var init_cjs_shims = __esm({
   }
 });
 
+// node_modules/@opentelemetry/core/build/esm/platform/node/environment.js
+function getNumberFromEnv(key) {
+  const raw = process.env[key];
+  if (raw == null || raw.trim() === "") {
+    return void 0;
+  }
+  const value = Number(raw);
+  if (isNaN(value)) {
+    import_api.diag.warn(`Unknown value ${(0, import_util.inspect)(raw)} for ${key}, expected a number, using defaults`);
+    return void 0;
+  }
+  return value;
+}
+var import_api, import_util;
+var init_environment = __esm({
+  "node_modules/@opentelemetry/core/build/esm/platform/node/environment.js"() {
+    "use strict";
+    init_cjs_shims();
+    import_api = require("@opentelemetry/api");
+    import_util = require("util");
+  }
+});
+
+// node_modules/@opentelemetry/core/build/esm/platform/node/index.js
+var init_node = __esm({
+  "node_modules/@opentelemetry/core/build/esm/platform/node/index.js"() {
+    "use strict";
+    init_cjs_shims();
+    init_environment();
+  }
+});
+
+// node_modules/@opentelemetry/core/build/esm/platform/index.js
+var init_platform = __esm({
+  "node_modules/@opentelemetry/core/build/esm/platform/index.js"() {
+    "use strict";
+    init_cjs_shims();
+    init_node();
+  }
+});
+
+// node_modules/@opentelemetry/core/build/esm/ExportResult.js
+var ExportResultCode;
+var init_ExportResult = __esm({
+  "node_modules/@opentelemetry/core/build/esm/ExportResult.js"() {
+    "use strict";
+    init_cjs_shims();
+    (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_cjs_shims();
+    init_ExportResult();
+    init_platform();
+  }
+});
+
 // src/config.ts
+function namedAgent(agentName) {
+  return agentName === void 0 || agentName === DEFAULT_SERVICE_NAME ? void 0 : agentName;
+}
 function bool(name, raw, fallback) {
   if (raw === void 0) return fallback;
   const value = raw.trim().toLowerCase();
@@ -63,6 +130,21 @@ function clamp(name, value, min, max, fallback) {
   console.warn(`[rius] ${name}=${value} is outside [${min}, ${max}]; clamped to ${clamped}.`);
   return clamped;
 }
+function serviceVersionFromOtelEnv(raw) {
+  if (raw === void 0) return void 0;
+  for (const pair of raw.split(",")) {
+    const separator = pair.indexOf("=");
+    if (separator === -1) continue;
+    if (pair.slice(0, separator).trim() !== "service.version") continue;
+    const value = pair.slice(separator + 1).trim();
+    try {
+      return decodeURIComponent(value) || void 0;
+    } catch {
+      return value || void 0;
+    }
+  }
+  return void 0;
+}
 function resolveConfig(options = {}, env = process.env) {
   const endpoint = (options.endpoint ?? env.RIUS_ENDPOINT ?? DEFAULT_ENDPOINT).replace(/\/+$/, "");
   const serviceName = options.serviceName ?? env.RIUS_SERVICE_NAME ?? DEFAULT_SERVICE_NAME;
@@ -84,6 +166,11 @@ function resolveConfig(options = {}, env = process.env) {
     endpoint,
     apiKey: options.apiKey ?? env.RIUS_API_KEY,
     serviceName,
+    // Empty is unset, as it is for the agent name and the session id: a blank
+    // version would stamp `service.version=""` on every span, which reads as
+    // a real (and wrong) answer rather than as no answer. Falls through to
+    // the OTel environment last, and to nothing after that.
+    serviceVersion: options.serviceVersion || env.RIUS_SERVICE_VERSION || serviceVersionFromOtelEnv(env.OTEL_RESOURCE_ATTRIBUTES) || void 0,
     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),
@@ -94,11 +181,22 @@ function resolveConfig(options = {}, env = process.env) {
     // Empty falls through to serviceName rather than shipping a blank identity
     // on every heartbeat payload, so `??` would be wrong here.
     agentName: options.agentName || env.RIUS_AGENT_NAME || serviceName,
+    // Derived from the SAME value, not resolved a second time: the
+    // main-agent name is a move of the existing agent name into our
+    // namespace, so a new option here would let the two disagree.
+    mainAgentName: namedAgent(options.agentName || env.RIUS_AGENT_NAME || serviceName),
+    // Empty is unset, as everywhere above. None of the three has a fallback:
+    // there is no service-level id, description or agent version to borrow,
+    // and inventing one would repeat the `unknown_service` mistake.
+    mainAgentId: options.mainAgentId || env.RIUS_MAIN_AGENT_ID || void 0,
+    mainAgentDescription: options.mainAgentDescription || env.RIUS_MAIN_AGENT_DESCRIPTION || void 0,
+    mainAgentVersion: options.mainAgentVersion || env.RIUS_MAIN_AGENT_VERSION || void 0,
     partialSpans: options.partialSpans ?? bool("RIUS_PARTIAL_SPANS", env.RIUS_PARTIAL_SPANS, false),
     partialSpansDelayMs: partialSpansDelaySeconds * 1e3,
     // Empty is unset, like agentName: a blank session id would group every
     // span under the meaningless session "".
-    sessionId: options.sessionId || env.RIUS_SESSION_ID || void 0
+    sessionId: options.sessionId || env.RIUS_SESSION_ID || void 0,
+    bridgeForeignProvider: options.bridgeForeignProvider ?? bool("RIUS_BRIDGE_FOREIGN_PROVIDER", env.RIUS_BRIDGE_FOREIGN_PROVIDER, false)
   };
 }
 var DEFAULT_ENDPOINT, DEFAULT_SERVICE_NAME, HEARTBEAT_INTERVAL_MIN, HEARTBEAT_INTERVAL_MAX, DEFAULT_HEARTBEAT_INTERVAL, PARTIAL_SPANS_DELAY_MIN, PARTIAL_SPANS_DELAY_MAX, DEFAULT_PARTIAL_SPANS_DELAY, AFFIRMATIVE, NEGATIVE;
@@ -119,6 +217,511 @@ var init_config = __esm({
   }
 });
 
+// src/semconv.ts
+function requestAttributeKey(parameter) {
+  return Object.hasOwn(GEN_AI_REQUEST_PARAMETERS, parameter) ? GEN_AI_REQUEST_PARAMETERS[parameter] : `${RIUS_REQUEST_PREFIX}${parameter}`;
+}
+function operationForKind(kind) {
+  return Object.hasOwn(OPERATION_BY_KIND, kind) ? OPERATION_BY_KIND[kind] : void 0;
+}
+function kindForOperation(operation) {
+  return Object.hasOwn(KIND_BY_OPERATION, operation) ? KIND_BY_OPERATION[operation] : void 0;
+}
+function otelSpanKind(kind) {
+  return OTEL_KIND_BY_KIND[kind];
+}
+function kindAttributes(kind, toolName2) {
+  const attributes = { [OPENINFERENCE_SPAN_KIND]: kind };
+  const operation = OPERATION_BY_KIND[kind];
+  if (operation !== void 0) attributes[GEN_AI_OPERATION_NAME] = operation;
+  if (kind === "TOOL" /* TOOL */ && toolName2 !== void 0) attributes[GEN_AI_TOOL_NAME] = toolName2;
+  return attributes;
+}
+function composeSpanName(kind, attributes) {
+  const operation = attributes[GEN_AI_OPERATION_NAME];
+  if (typeof operation !== "string") return CHAIN_SPAN_NAME;
+  const targetKey = NAME_TARGET_BY_KIND[kind];
+  const target = targetKey === void 0 ? void 0 : attributes[targetKey];
+  return typeof target === "string" && target !== "" ? `${operation} ${target}` : operation;
+}
+var import_api2, import_semantic_conventions, TRACER_NAME, SERVICE_INSTANCE_ID, OPENINFERENCE_SPAN_KIND, INPUT_VALUE, OUTPUT_VALUE, SESSION_ID, USER_ID, WORKSPACE_ROUTE, GEN_AI_OPERATION_NAME, GEN_AI_PROVIDER_NAME, GEN_AI_REQUEST_MODEL, GEN_AI_REQUEST_REASONING_LEVEL, GEN_AI_RESPONSE_MODEL, GEN_AI_RESPONSE_ID, GEN_AI_OUTPUT_TYPE, GEN_AI_REQUEST_STREAM, GEN_AI_RESPONSE_TIME_TO_FIRST_CHUNK, GEN_AI_REQUEST_TEMPERATURE, GEN_AI_REQUEST_TOP_P, GEN_AI_REQUEST_TOP_K, GEN_AI_REQUEST_MAX_TOKENS, GEN_AI_REQUEST_FREQUENCY_PENALTY, GEN_AI_REQUEST_PRESENCE_PENALTY, GEN_AI_REQUEST_SEED, GEN_AI_REQUEST_STOP_SEQUENCES, GEN_AI_REQUEST_CHOICE_COUNT, GEN_AI_REQUEST_ENCODING_FORMATS, GEN_AI_REQUEST_PREVIOUS_RESPONSE_ID, GEN_AI_REQUEST_STREAM_CURSOR, GEN_AI_USAGE_INPUT_TOKENS, GEN_AI_USAGE_OUTPUT_TOKENS, GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS, GEN_AI_USAGE_CACHE_WRITE_INPUT_TOKENS, GEN_AI_USAGE_REASONING_OUTPUT_TOKENS, GEN_AI_INPUT_MESSAGES, GEN_AI_OUTPUT_MESSAGES, GEN_AI_RESPONSE_FINISH_REASONS, GEN_AI_TOOL_NAME, GEN_AI_TOOL_CALL_ID, GEN_AI_TOOL_TYPE, GEN_AI_DATA_SOURCE_ID, GEN_AI_RETRIEVAL_TOP_K, GEN_AI_RETRIEVAL_DOCUMENTS, GEN_AI_AGENT_NAME, GEN_AI_AGENT_ID, GEN_AI_AGENT_VERSION, RIUS_MAIN_AGENT_NAME, RIUS_MAIN_AGENT_ID, RIUS_MAIN_AGENT_DESCRIPTION, RIUS_MAIN_AGENT_VERSION, GEN_AI_TOOL_DEFINITIONS, GEN_AI_REQUEST_PREFIX, RIUS_REQUEST_PREFIX, RIUS_REQUEST_TOOL_CHOICE, GEN_AI_REQUEST_PARAMETERS, MCP_METHOD_NAME, MCP_METHOD_TOOLS_CALL, MCP_PROTOCOL_VERSION, ERROR_TYPE, ERROR_TYPE_TOOL_ERROR, EXCEPTION_EVENT, EXCEPTION_TYPE, MCP_RESULT_TYPE, RIUS_CONTEXT_SIZES, GEN_AI_FIRST_TOKEN_EVENT, SpanKind, OPERATION_BY_KIND, KIND_BY_OPERATION, OTEL_KIND_BY_KIND, NAME_TARGET_BY_KIND, CHAIN_SPAN_NAME, LLM_INPUT_MESSAGES_PREFIX, LLM_OUTPUT_MESSAGES_PREFIX, LLM_MESSAGE_ROLE, LLM_MESSAGE_CONTENT, LLM_MESSAGE_TOOL_CALL_ID, LLM_MESSAGE_TOOL_CALLS_PREFIX, LLM_TOOL_CALL_PREFIX, LLM_TOOL_CALL_ID, LLM_TOOL_CALL_FUNCTION_NAME, LLM_TOOL_CALL_FUNCTION_ARGUMENTS, LLM_MESSAGE_CONTENTS_PREFIX, LLM_MESSAGE_CONTENT_PREFIX, LLM_INVOCATION_PARAMETERS, INVOCATION_PARAMETERS_CONTENT_MEMBERS, THIRD_PARTY_CONTENT_ATTRIBUTES, CONTENT_ATTRIBUTES, CONTENT_ATTRIBUTE_PREFIXES, CONTENT_PREFIX_IDENTITY_ATTRIBUTES, CONTENT_ATTRIBUTE_SUFFIXES, CONTENT_ATTRIBUTE_PREFIXED_SUFFIXES, RIUS_SPAN_PENDING, RIUS_PARENT_FOREIGN, RIUS_SDK_GLOBAL_PROVIDER, PENDING_IDENTITY_ATTRIBUTES, PENDING_IDENTITY_PREFIXES;
+var init_semconv = __esm({
+  "src/semconv.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_api2 = require("@opentelemetry/api");
+    import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+    TRACER_NAME = "rius";
+    SERVICE_INSTANCE_ID = "service.instance.id";
+    OPENINFERENCE_SPAN_KIND = "openinference.span.kind";
+    INPUT_VALUE = "input.value";
+    OUTPUT_VALUE = "output.value";
+    SESSION_ID = "session.id";
+    USER_ID = "user.id";
+    WORKSPACE_ROUTE = "rius.workspace";
+    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_REQUEST_REASONING_LEVEL = "gen_ai.request.reasoning.level";
+    GEN_AI_RESPONSE_MODEL = "gen_ai.response.model";
+    GEN_AI_RESPONSE_ID = "gen_ai.response.id";
+    GEN_AI_OUTPUT_TYPE = "gen_ai.output.type";
+    GEN_AI_REQUEST_STREAM = "gen_ai.request.stream";
+    GEN_AI_RESPONSE_TIME_TO_FIRST_CHUNK = "gen_ai.response.time_to_first_chunk";
+    GEN_AI_REQUEST_TEMPERATURE = "gen_ai.request.temperature";
+    GEN_AI_REQUEST_TOP_P = "gen_ai.request.top_p";
+    GEN_AI_REQUEST_TOP_K = "gen_ai.request.top_k";
+    GEN_AI_REQUEST_MAX_TOKENS = "gen_ai.request.max_tokens";
+    GEN_AI_REQUEST_FREQUENCY_PENALTY = "gen_ai.request.frequency_penalty";
+    GEN_AI_REQUEST_PRESENCE_PENALTY = "gen_ai.request.presence_penalty";
+    GEN_AI_REQUEST_SEED = "gen_ai.request.seed";
+    GEN_AI_REQUEST_STOP_SEQUENCES = "gen_ai.request.stop_sequences";
+    GEN_AI_REQUEST_CHOICE_COUNT = "gen_ai.request.choice.count";
+    GEN_AI_REQUEST_ENCODING_FORMATS = "gen_ai.request.encoding_formats";
+    GEN_AI_REQUEST_PREVIOUS_RESPONSE_ID = "gen_ai.request.previous_response.id";
+    GEN_AI_REQUEST_STREAM_CURSOR = "gen_ai.request.stream_cursor";
+    GEN_AI_USAGE_INPUT_TOKENS = "gen_ai.usage.input_tokens";
+    GEN_AI_USAGE_OUTPUT_TOKENS = "gen_ai.usage.output_tokens";
+    GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS = "gen_ai.usage.cache_read.input_tokens";
+    GEN_AI_USAGE_CACHE_WRITE_INPUT_TOKENS = "gen_ai.usage.cache_write.input_tokens";
+    GEN_AI_USAGE_REASONING_OUTPUT_TOKENS = "gen_ai.usage.reasoning.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_TOOL_CALL_ID = "gen_ai.tool.call.id";
+    GEN_AI_TOOL_TYPE = "gen_ai.tool.type";
+    GEN_AI_DATA_SOURCE_ID = "gen_ai.data_source.id";
+    GEN_AI_RETRIEVAL_TOP_K = "gen_ai.retrieval.top_k";
+    GEN_AI_RETRIEVAL_DOCUMENTS = "gen_ai.retrieval.documents";
+    GEN_AI_AGENT_NAME = "gen_ai.agent.name";
+    GEN_AI_AGENT_ID = "gen_ai.agent.id";
+    GEN_AI_AGENT_VERSION = "gen_ai.agent.version";
+    RIUS_MAIN_AGENT_NAME = "rius.main_agent.name";
+    RIUS_MAIN_AGENT_ID = "rius.main_agent.id";
+    RIUS_MAIN_AGENT_DESCRIPTION = "rius.main_agent.description";
+    RIUS_MAIN_AGENT_VERSION = "rius.main_agent.version";
+    GEN_AI_TOOL_DEFINITIONS = "gen_ai.tool.definitions";
+    GEN_AI_REQUEST_PREFIX = "gen_ai.request.";
+    RIUS_REQUEST_PREFIX = "rius.request.";
+    RIUS_REQUEST_TOOL_CHOICE = "rius.request.tool_choice";
+    GEN_AI_REQUEST_PARAMETERS = {
+      // model: the request's model; also settable via the `model` option.
+      model: GEN_AI_REQUEST_MODEL,
+      // max_tokens: OpenAI Chat Completions `max_tokens`, its successor
+      // `max_completion_tokens`, the Responses API's `max_output_tokens`, and
+      // Google's `maxOutputTokens`.
+      max_tokens: GEN_AI_REQUEST_MAX_TOKENS,
+      maxTokens: GEN_AI_REQUEST_MAX_TOKENS,
+      max_completion_tokens: GEN_AI_REQUEST_MAX_TOKENS,
+      maxCompletionTokens: GEN_AI_REQUEST_MAX_TOKENS,
+      max_output_tokens: GEN_AI_REQUEST_MAX_TOKENS,
+      maxOutputTokens: GEN_AI_REQUEST_MAX_TOKENS,
+      // choice.count: "the target number of candidate completions to return":
+      // OpenAI `n`, Google `candidateCount`, Cohere `num_generations`.
+      "choice.count": GEN_AI_REQUEST_CHOICE_COUNT,
+      n: GEN_AI_REQUEST_CHOICE_COUNT,
+      candidate_count: GEN_AI_REQUEST_CHOICE_COUNT,
+      candidateCount: GEN_AI_REQUEST_CHOICE_COUNT,
+      num_generations: GEN_AI_REQUEST_CHOICE_COUNT,
+      temperature: GEN_AI_REQUEST_TEMPERATURE,
+      // top_p: Google `topP`, Cohere `p`.
+      top_p: GEN_AI_REQUEST_TOP_P,
+      topP: GEN_AI_REQUEST_TOP_P,
+      p: GEN_AI_REQUEST_TOP_P,
+      // top_k: the registry's own note names Anthropic `top_k`, Cohere `k` and
+      // Google `topK`, and says OpenAI's `top_logprobs` MUST NOT be reported here
+      // (it shapes the response, not the sampling). So top_logprobs is
+      // deliberately absent and lands in rius.request.*.
+      top_k: GEN_AI_REQUEST_TOP_K,
+      topK: GEN_AI_REQUEST_TOP_K,
+      k: GEN_AI_REQUEST_TOP_K,
+      // stop_sequences: OpenAI `stop`, Google `stopSequences`. `stop` is listed
+      // FIRST because the llm.invocation_parameters rule prefers it, and both
+      // paths must keep the same spelling when a request carries two.
+      stop: GEN_AI_REQUEST_STOP_SEQUENCES,
+      stop_sequences: GEN_AI_REQUEST_STOP_SEQUENCES,
+      stopSequences: GEN_AI_REQUEST_STOP_SEQUENCES,
+      frequency_penalty: GEN_AI_REQUEST_FREQUENCY_PENALTY,
+      frequencyPenalty: GEN_AI_REQUEST_FREQUENCY_PENALTY,
+      presence_penalty: GEN_AI_REQUEST_PRESENCE_PENALTY,
+      presencePenalty: GEN_AI_REQUEST_PRESENCE_PENALTY,
+      // encoding_formats: plural in the registry; OpenAI's embeddings endpoint
+      // sends the singular `encoding_format`, and the registry's note says some
+      // systems call these "embedding types" (Cohere `embedding_types`).
+      encoding_formats: GEN_AI_REQUEST_ENCODING_FORMATS,
+      encoding_format: GEN_AI_REQUEST_ENCODING_FORMATS,
+      encodingFormat: GEN_AI_REQUEST_ENCODING_FORMATS,
+      embedding_types: GEN_AI_REQUEST_ENCODING_FORMATS,
+      seed: GEN_AI_REQUEST_SEED,
+      stream: GEN_AI_REQUEST_STREAM,
+      // reasoning.level: "the exact string value sent to the provider"; OpenAI
+      // sends it as `reasoning_effort`.
+      "reasoning.level": GEN_AI_REQUEST_REASONING_LEVEL,
+      reasoning_level: GEN_AI_REQUEST_REASONING_LEVEL,
+      reasoning_effort: GEN_AI_REQUEST_REASONING_LEVEL,
+      reasoningEffort: GEN_AI_REQUEST_REASONING_LEVEL,
+      // previous_response.id: the registry names OpenAI's `previous_response_id`
+      // and Google's `previous_interaction_id`.
+      "previous_response.id": GEN_AI_REQUEST_PREVIOUS_RESPONSE_ID,
+      previous_response_id: GEN_AI_REQUEST_PREVIOUS_RESPONSE_ID,
+      previousResponseId: GEN_AI_REQUEST_PREVIOUS_RESPONSE_ID,
+      previous_interaction_id: GEN_AI_REQUEST_PREVIOUS_RESPONSE_ID,
+      // stream_cursor: the registry names OpenAI's `starting_after` and Google's
+      // `last_event_id`.
+      stream_cursor: GEN_AI_REQUEST_STREAM_CURSOR,
+      starting_after: GEN_AI_REQUEST_STREAM_CURSOR,
+      last_event_id: GEN_AI_REQUEST_STREAM_CURSOR
+    };
+    MCP_METHOD_NAME = "mcp.method.name";
+    MCP_METHOD_TOOLS_CALL = "tools/call";
+    MCP_PROTOCOL_VERSION = "mcp.protocol.version";
+    ERROR_TYPE = "error.type";
+    ERROR_TYPE_TOOL_ERROR = "tool_error";
+    EXCEPTION_EVENT = "exception";
+    EXCEPTION_TYPE = "exception.type";
+    MCP_RESULT_TYPE = "mcp.result_type";
+    RIUS_CONTEXT_SIZES = "rius.context.sizes";
+    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",
+      ["RETRIEVER" /* RETRIEVER */]: "retrieval"
+    };
+    KIND_BY_OPERATION = {
+      chat: "LLM" /* LLM */,
+      text_completion: "LLM" /* LLM */,
+      generate_content: "LLM" /* LLM */,
+      execute_tool: "TOOL" /* TOOL */,
+      embeddings: "EMBEDDING" /* EMBEDDING */,
+      invoke_agent: "AGENT" /* AGENT */,
+      create_agent: "AGENT" /* AGENT */,
+      retrieval: "RETRIEVER" /* RETRIEVER */,
+      invoke_workflow: "CHAIN" /* CHAIN */,
+      plan: "CHAIN" /* CHAIN */
+    };
+    OTEL_KIND_BY_KIND = {
+      ["LLM" /* LLM */]: import_api2.SpanKind.CLIENT,
+      ["EMBEDDING" /* EMBEDDING */]: import_api2.SpanKind.CLIENT,
+      ["RETRIEVER" /* RETRIEVER */]: import_api2.SpanKind.CLIENT,
+      ["TOOL" /* TOOL */]: import_api2.SpanKind.INTERNAL,
+      ["AGENT" /* AGENT */]: import_api2.SpanKind.INTERNAL,
+      ["CHAIN" /* CHAIN */]: import_api2.SpanKind.INTERNAL
+    };
+    NAME_TARGET_BY_KIND = {
+      ["LLM" /* LLM */]: GEN_AI_REQUEST_MODEL,
+      ["EMBEDDING" /* EMBEDDING */]: GEN_AI_REQUEST_MODEL,
+      ["TOOL" /* TOOL */]: GEN_AI_TOOL_NAME,
+      ["AGENT" /* AGENT */]: GEN_AI_AGENT_NAME,
+      ["RETRIEVER" /* RETRIEVER */]: GEN_AI_DATA_SOURCE_ID
+    };
+    CHAIN_SPAN_NAME = "chain";
+    LLM_INPUT_MESSAGES_PREFIX = "llm.input_messages.";
+    LLM_OUTPUT_MESSAGES_PREFIX = "llm.output_messages.";
+    LLM_MESSAGE_ROLE = "message.role";
+    LLM_MESSAGE_CONTENT = "message.content";
+    LLM_MESSAGE_TOOL_CALL_ID = "message.tool_call_id";
+    LLM_MESSAGE_TOOL_CALLS_PREFIX = "message.tool_calls.";
+    LLM_TOOL_CALL_PREFIX = "tool_call.";
+    LLM_TOOL_CALL_ID = "id";
+    LLM_TOOL_CALL_FUNCTION_NAME = "function.name";
+    LLM_TOOL_CALL_FUNCTION_ARGUMENTS = "function.arguments";
+    LLM_MESSAGE_CONTENTS_PREFIX = "message.contents.";
+    LLM_MESSAGE_CONTENT_PREFIX = "message_content.";
+    LLM_INVOCATION_PARAMETERS = "llm.invocation_parameters";
+    INVOCATION_PARAMETERS_CONTENT_MEMBERS = ["tools", "functions"];
+    THIRD_PARTY_CONTENT_ATTRIBUTES = /* @__PURE__ */ new Set([
+      // langfuse 3.15.0, langfuse/_client/attributes.py. Metadata is the caller's
+      // arbitrary payload (one key per member, see the prefixes below), and the
+      // OpenAI wrapper writes the exception's message into status_message.
+      "langfuse.observation.input",
+      "langfuse.observation.output",
+      "langfuse.trace.input",
+      "langfuse.trace.output",
+      "langfuse.observation.metadata",
+      "langfuse.trace.metadata",
+      "langfuse.observation.status_message",
+      "langfuse.experiment.metadata",
+      "langfuse.experiment.item.metadata",
+      "langfuse.experiment.item.expected_output",
+      // traceloop-sdk 0.62.3 (opentelemetry-semantic-conventions-ai 0.5.1):
+      // workflow/task I/O and the managed prompt's template and variables; the
+      // LangChain instrumentation mirrors entity I/O into gen_ai.task.*, and the
+      // MCP one writes each tool result to mcp.response.value.
+      "traceloop.entity.input",
+      "traceloop.entity.output",
+      "traceloop.prompt.template",
+      "traceloop.prompt.template_variables",
+      "gen_ai.task.input",
+      "gen_ai.task.output",
+      "mcp.response.value",
+      // logfire 5.1.1: the OpenAI/Anthropic integrations put the request and the
+      // reply in request_data/response_data and the messages in events; the OpenAI
+      // Agents one adds raw_input, the Response object, and a function span's
+      // arguments and result under bare input/output.
+      "request_data",
+      "response_data",
+      "events",
+      "all_messages_events",
+      "pydantic_ai.all_messages",
+      "raw_input",
+      "response",
+      "input",
+      "output",
+      "logfire.msg",
+      // mlflow-tracing 3.16.1, mlflow/tracing/constant.py. chunk.value is a
+      // streamed chunk, written on span events.
+      "mlflow.spanInputs",
+      "mlflow.spanOutputs",
+      "mlflow.chat.tools",
+      "mlflow.trace.intermediate_outputs",
+      "mlflow.chunk.value",
+      // openlit 1.45.0, openlit/semcov/__init__.py, each one written by at least
+      // one of its instrumentations. gen_ai.retrieval.query.text is also a GenAI
+      // convention key: the user's query, verbatim.
+      "gen_ai.retrieval.query.text",
+      "gen_ai.content.reasoning",
+      "gen_ai.content.revised_prompt",
+      "gen_ai.tool.args",
+      "gen_ai.response.tool_calls",
+      "gen_ai.workflow.input",
+      "gen_ai.workflow.output",
+      "gen_ai.framework.pipeline.input_data",
+      "gen_ai.framework.pipeline.output_data",
+      "gen_ai.framework.error.message",
+      "gen_ai.agent.context",
+      "gen_ai.agent.instructions",
+      "gen_ai.agent.goal",
+      "gen_ai.agent.action.tool_input",
+      "gen_ai.agent.final_result",
+      "gen_ai.agent.next_goal",
+      "gen_ai.agent.step_messages",
+      "gen_ai.memory.search.query",
+      "gen_ai.vectordb.search.query",
+      "gen_ai.extraction.instruction",
+      "mcp.tool.arguments",
+      "mcp.tool.result",
+      "mcp.result",
+      "mcp.params",
+      "mcp.sampling.messages",
+      "mcp.fastmcp.prompt.arguments",
+      "mcp.completion.argument.value",
+      "mcp.completion.context.arguments",
+      "mcp.completion.values",
+      "mcp.error.message",
+      // lmnr 0.7.64 (Laminar; the TypeScript SDK writes the same wire keys): the
+      // observed function's arguments and return value, the caller's metadata
+      // (one key per member, see the prefixes below), and the provider's whole
+      // reply its Anthropic and LiteLLM instrumentations write.
+      "lmnr.span.input",
+      "lmnr.span.output",
+      "lmnr.association.properties.metadata",
+      "lmnr.sdk.raw.response"
+    ]);
+    CONTENT_ATTRIBUTES = /* @__PURE__ */ new Set([
+      INPUT_VALUE,
+      OUTPUT_VALUE,
+      GEN_AI_INPUT_MESSAGES,
+      GEN_AI_OUTPUT_MESSAGES,
+      // Sensitive per the GenAI conventions (semconv-genai#431): tool definitions
+      // routinely embed proprietary prompt engineering, and sometimes credentials
+      // or internal URLs in parameter defaults. gen_ai.tool.name stays: it is
+      // identity, not content.
+      "gen_ai.tool.description",
+      GEN_AI_TOOL_DEFINITIONS,
+      // GenAI semconv keys emitted by OTel-native instrumentations (@ai-sdk/otel,
+      // which init() registers for ai v7, among them; pinned 2026-09-14): the
+      // system prompt and each tool call's input and output are content in the
+      // same sense messages are. gen_ai.tool.call.id stays: identity.
+      "gen_ai.system_instructions",
+      "gen_ai.tool.call.arguments",
+      "gen_ai.tool.call.result",
+      // OpenInference TOOL-kind spans carry the definition under these two bare
+      // keys, sensitive for the reason gen_ai.tool.description is.
+      "tool.description",
+      "tool.parameters",
+      "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",
+      // Every bundled OpenInference instrumentation emits tool definitions as
+      // llm.tools.{i}.tool.json_schema (pinned empirically 2026-09-14); covered
+      // by prefix below, bare key listed per the bare-key rule.
+      "llm.tools",
+      // The Vercel AI SDK's own telemetry keys survive the OpenInference
+      // transform untouched, and they carry the full prompt (messages AND tool
+      // definitions), response content, and tool-call I/O. Names, ids and models
+      // (ai.toolCall.name, ai.response.model, ...) are identity and stay.
+      "ai.prompt",
+      "ai.response.text",
+      "ai.response.object",
+      "ai.toolCall.args",
+      "ai.toolCall.result",
+      // Same family, keys enumerated from the ai v7 telemetry surface
+      // (2026-09-14): model reasoning, tool calls in the response, response
+      // files, embedding inputs, rerank documents, and the generateObject schema
+      // (a tool definition by another name).
+      "ai.response.reasoning",
+      "ai.response.toolCalls",
+      "ai.response.files",
+      "ai.value",
+      "ai.values",
+      "ai.documents",
+      "ai.schema",
+      "ai.schema.description",
+      // The OpenInference request-parameters bag, whole. Its membership is open
+      // and provider-defined (litellm and langchain put the request's tools array
+      // in it, and providers are free to add anything else), so a per-member
+      // blocklist is always one provider behind. Treating the whole bag as
+      // content is only safe because normalization runs BEFORE masking and has
+      // already promoted every member the rule table recognises onto
+      // gen_ai.request.*, so what reaches masking is exactly the set nothing has
+      // classified. A knob that matters is recovered by teaching the rule table
+      // its name, which is a reviewed decision; the default is that unclassified
+      // request data does not leave a process that asked for no content.
+      LLM_INVOCATION_PARAMETERS,
+      // The NAMED EXCEPTION to the rule that request parameters export in clear.
+      // That rule is right for scalar knobs (temperature, top_p, seed), but a
+      // parameter bag is not typed: a caller passing modelParameters: { tools }
+      // would otherwise export proprietary prompt engineering verbatim with
+      // captureContent: false explicitly set, while the very same array is
+      // stripped when it arrives as gen_ai.tool.definitions or inside
+      // llm.invocation_parameters. Per KEY, not per namespace: both namespaces
+      // stay non-content wholesale, which is what keeps their tie intact.
+      ...[GEN_AI_REQUEST_PREFIX, RIUS_REQUEST_PREFIX].flatMap(
+        (prefix) => INVOCATION_PARAMETERS_CONTENT_MEMBERS.map((member) => `${prefix}${member}`)
+      ),
+      ...THIRD_PARTY_CONTENT_ATTRIBUTES
+    ]);
+    CONTENT_ATTRIBUTE_PREFIXES = [
+      "llm.input_messages.",
+      "llm.output_messages.",
+      "gen_ai.prompt.",
+      "gen_ai.completion.",
+      "llm.prompts.",
+      "llm.prompt_template.",
+      "llm.tools.",
+      "ai.prompt.",
+      "langfuse.observation.metadata.",
+      "langfuse.trace.metadata.",
+      "traceloop.prompt.template_variables.",
+      "lmnr.association.properties.metadata."
+    ];
+    CONTENT_PREFIX_IDENTITY_ATTRIBUTES = /* @__PURE__ */ new Set([
+      "lmnr.association.properties.metadata.tool_call_id",
+      "lmnr.association.properties.metadata.agent.name",
+      "lmnr.association.properties.metadata.service.name"
+    ]);
+    CONTENT_ATTRIBUTE_SUFFIXES = [
+      ".document.content",
+      ".embedding.text"
+    ];
+    CONTENT_ATTRIBUTE_PREFIXED_SUFFIXES = [["llm.request.functions.", [".description", ".parameters", ".arguments"]]];
+    RIUS_SPAN_PENDING = "rius.span.pending";
+    RIUS_PARENT_FOREIGN = "rius.parent.foreign";
+    RIUS_SDK_GLOBAL_PROVIDER = "rius.sdk.global_provider";
+    PENDING_IDENTITY_ATTRIBUTES = /* @__PURE__ */ new Set([
+      OPENINFERENCE_SPAN_KIND,
+      GEN_AI_OPERATION_NAME,
+      GEN_AI_PROVIDER_NAME,
+      GEN_AI_TOOL_NAME,
+      // The two other halves of a tool call's identity, both caller-supplied at
+      // creation: which model tool-call this execution answers, and what kind of
+      // tool it is. A tool that hangs is exactly the span a live view needs to
+      // show attached to its call, so both must survive the snapshot.
+      GEN_AI_TOOL_CALL_ID,
+      GEN_AI_TOOL_TYPE,
+      // A property of the request, like the model parameters the prefix rule
+      // covers — but spelled outside `gen_ai.request.`, so it needs its own
+      // entry here or it would be silently dropped from every snapshot.
+      GEN_AI_OUTPUT_TYPE,
+      // The retrieval target is identity in the same sense the tool name is: a
+      // still-running retrieval must be attributable to the index it is hitting.
+      GEN_AI_DATA_SOURCE_ID,
+      // Equally a property of the request, so equally knowable at start. Its
+      // counterpart GEN_AI_RETRIEVAL_DOCUMENTS is deliberately absent: what came
+      // back cannot be known while the span is open.
+      GEN_AI_RETRIEVAL_TOP_K,
+      // Which agent a span invokes is chosen before the work starts, so a
+      // still-running agent is attributable in the live view. Distinct from the
+      // RESOURCE key of the same name, which says which PROCESS is running; these
+      // say which agent that process invoked here.
+      GEN_AI_AGENT_NAME,
+      GEN_AI_AGENT_ID,
+      // Same callee, same reason: the version of the agent being invoked is
+      // chosen before the work starts, so a still-running agent span can say
+      // which version of it is running.
+      GEN_AI_AGENT_VERSION,
+      // Protocol identity, not content: a still-running MCP call must be
+      // distinguishable from a local tool in the live view — the one place
+      // setting the marker at creation pays off.
+      MCP_METHOD_NAME,
+      MCP_PROTOCOL_VERSION,
+      // Identity, not content: a pending span must be groupable into its
+      // session while still running, that is the live view's whole point.
+      SESSION_ID,
+      // Same reason: a crashed run's partial spans must still be attributable
+      // to the user they served.
+      USER_ID,
+      // Routing, not content: a crashed run's snapshot must land in the same
+      // workspace its final span would have. Stripped at export either way.
+      WORKSPACE_ROUTE
+    ]);
+    PENDING_IDENTITY_PREFIXES = [
+      GEN_AI_REQUEST_PREFIX,
+      RIUS_REQUEST_PREFIX
+    ];
+  }
+});
+
+// src/agent.ts
+function setConfiguredAgentName(name) {
+  configured = name;
+}
+function resolveAgentName(agentName, kind) {
+  if (kind !== "AGENT" /* AGENT */) return void 0;
+  if (agentName !== void 0) return agentName;
+  return namedConfiguredAgent();
+}
+function namedConfiguredAgent() {
+  return namedAgent(configured);
+}
+function withAgentScope(agentName, fn) {
+  return import_api3.context.with(import_api3.context.active().setValue(AGENT_SCOPE_KEY, agentName), fn);
+}
+function executingAgentName() {
+  const scoped = import_api3.context.active().getValue(AGENT_SCOPE_KEY);
+  return typeof scoped === "string" ? scoped : namedConfiguredAgent();
+}
+var import_api3, configured, AGENT_SCOPE_KEY;
+var init_agent = __esm({
+  "src/agent.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_api3 = require("@opentelemetry/api");
+    init_config();
+    init_semconv();
+    AGENT_SCOPE_KEY = (0, import_api3.createContextKey)("rius-enclosing-agent-name");
+  }
+});
+
 // src/delegatingProcessor.ts
 var DelegatingSpanProcessor;
 var init_delegatingProcessor = __esm({
@@ -142,80 +745,419 @@ var init_delegatingProcessor = __esm({
         this.delegates.unshift(processor);
       }
       onStart(span, parentContext) {
-        for (const delegate of this.delegates) delegate.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()));
+      }
+    };
+  }
+});
+
+// src/exportHealth.ts
+var ExportOutcomeExporter;
+var init_exportHealth = __esm({
+  "src/exportHealth.ts"() {
+    "use strict";
+    init_cjs_shims();
+    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/foreign.ts
+function delegating(provider) {
+  return typeof provider.getDelegate === "function";
+}
+function rememberOwnProvider(provider) {
+  ownProviders.add(provider);
+}
+function globalTracerProvider() {
+  let provider = import_api4.trace.getTracerProvider();
+  for (let hop = 0; hop < 8 && delegating(provider); hop += 1) {
+    const delegate = provider.getDelegate();
+    if (delegate === provider) break;
+    provider = delegate;
+  }
+  if (provider === NOOP_PROVIDER || provider.constructor?.name === "NoopTracerProvider") {
+    return void 0;
+  }
+  return provider;
+}
+function foreignGlobalProviderName() {
+  const provider = globalTracerProvider();
+  if (provider === void 0 || ownProviders.has(provider)) return void 0;
+  return provider.constructor?.name || "unknown";
+}
+function twinOf(span) {
+  if (span === void 0 || span === null) return span;
+  return shadows.get(span)?.twin ?? span;
+}
+function riusDecision(span) {
+  if (span === void 0 || span === null) return void 0;
+  if (dropped.has(span)) return false;
+  return shadows.has(span) ? true : void 0;
+}
+function stamped(span, shadow) {
+  const attributes = { ...span.attributes };
+  for (const [key, value] of Object.entries(shadow.twin.attributes)) {
+    const started = shadow.seed[key];
+    const own = attributes[key];
+    if (value !== started && own === started) attributes[key] = value;
+  }
+  return {
+    name: span.name,
+    kind: span.kind,
+    spanContext: () => span.spanContext(),
+    parentSpanContext: span.parentSpanContext,
+    startTime: span.startTime,
+    endTime: span.endTime,
+    duration: span.duration,
+    status: { ...span.status },
+    attributes,
+    links: span.links.map((link) => ({ ...link, attributes: { ...link.attributes } })),
+    events: span.events.map((event) => ({ ...event, attributes: { ...event.attributes } })),
+    resource: span.resource,
+    instrumentationScope: span.instrumentationScope,
+    droppedAttributesCount: span.droppedAttributesCount,
+    droppedEventsCount: span.droppedEventsCount,
+    droppedLinksCount: span.droppedLinksCount,
+    ended: span.ended
+  };
+}
+function attachProcessor(provider, processor) {
+  const legacy = provider;
+  if (typeof legacy.addSpanProcessor === "function") {
+    legacy.addSpanProcessor(processor);
+    return true;
+  }
+  const list = provider._activeSpanProcessor?._spanProcessors;
+  if (Array.isArray(list)) {
+    list.push(processor);
+    return true;
+  }
+  return false;
+}
+function bridge(provider, pipeline, sampler, limits) {
+  const shadow = new ShadowPipeline(pipeline, sampler, limits);
+  let forwarder = forwarders.get(provider);
+  if (forwarder === void 0) {
+    forwarder = new Forwarder();
+    if (!attachProcessor(provider, forwarder)) return void 0;
+    forwarders.set(provider, forwarder);
+  }
+  forwarder.attach(shadow);
+  return new Bridge(forwarder, shadow);
+}
+var import_api4, import_resources, import_sdk_trace_base, ownProviders, NOOP_PROVIDER, ForeignParentDetector, shadows, dropped, ALWAYS_ON, ALWAYS_OFF, BridgeAwareSampler, TwinSpan, ShadowPipeline, Forwarder, forwarders, Bridge, ResourceAdoptingExporter;
+var init_foreign = __esm({
+  "src/foreign.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_api4 = require("@opentelemetry/api");
+    import_resources = require("@opentelemetry/resources");
+    import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+    init_semconv();
+    ownProviders = /* @__PURE__ */ new WeakSet();
+    NOOP_PROVIDER = new import_api4.ProxyTracerProvider().getDelegate();
+    ForeignParentDetector = class {
+      seen = /* @__PURE__ */ new WeakSet();
+      openIds = /* @__PURE__ */ new Set();
+      globalProvider;
+      /** Spans flagged since this detector was built. Cumulative; never reset. */
+      count = 0;
+      constructor(globalProvider) {
+        this.globalProvider = globalProvider;
+      }
+      onStart(span, parentContext) {
+        const parent = span.parentSpanContext;
+        const foreign = parent !== void 0 && (0, import_api4.isSpanContextValid)(parent) && // A remote parent belongs to another PROCESS: ordinary distributed
+        // tracing, where the parent was never expected here.
+        parent.isRemote !== true && !this.startedHere(parent, parentContext);
+        this.remember(span);
+        if (!foreign) return;
+        this.count += 1;
+        span.setAttribute(RIUS_PARENT_FOREIGN, true);
+        if (this.count === 1) this.warn(span.name);
+      }
+      startedHere(parent, parentContext) {
+        if (this.seen.has(twinOf(import_api4.trace.getSpan(parentContext)))) return true;
+        return this.openIds.has(parent.spanId);
+      }
+      remember(span) {
+        this.seen.add(span);
+        this.openIds.add(span.spanContext().spanId);
+      }
+      warn(name) {
+        const owner = this.globalProvider === void 0 ? "another OpenTelemetry provider in this process" : `another OpenTelemetry SDK (${this.globalProvider})`;
+        const first = `first: ${JSON.stringify(name)}, flagged ${RIUS_PARENT_FOREIGN}`;
+        console.warn(
+          `[rius] ${owner} owns the global tracer provider; Rius spans have parents it never receives (${first}). Set RIUS_BRIDGE_FOREIGN_PROVIDER=true or init({ bridgeForeignProvider: true }) to send them to Rius.`
+        );
+      }
+      onEnd(span) {
+        this.openIds.delete(span.spanContext().spanId);
+      }
+      async forceFlush() {
+      }
+      async shutdown() {
+      }
+    };
+    shadows = /* @__PURE__ */ new WeakMap();
+    dropped = /* @__PURE__ */ new WeakSet();
+    ALWAYS_ON = {
+      shouldSample: () => ({ decision: import_sdk_trace_base.SamplingDecision.RECORD_AND_SAMPLED }),
+      toString: () => "AlwaysOnSampler"
+    };
+    ALWAYS_OFF = {
+      shouldSample: () => ({ decision: import_sdk_trace_base.SamplingDecision.NOT_RECORD }),
+      toString: () => "AlwaysOffSampler"
+    };
+    BridgeAwareSampler = class {
+      inner;
+      constructor(inner) {
+        this.inner = inner;
+      }
+      shouldSample(context2, traceId, spanName, spanKind, attributes, links) {
+        const kept = riusDecision(import_api4.trace.getSpan(context2));
+        const sampler = kept === void 0 ? this.inner : kept ? ALWAYS_ON : ALWAYS_OFF;
+        return sampler.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
+      }
+      toString() {
+        return `BridgeAware{${this.inner.toString()}}`;
+      }
+    };
+    TwinSpan = class {
+      attributes = {};
+      links;
+      events = [];
+      startTime;
+      endTime = [0, 0];
+      duration = [0, 0];
+      resource;
+      instrumentationScope;
+      kind;
+      parentSpanContext;
+      droppedAttributesCount = 0;
+      droppedEventsCount = 0;
+      droppedLinksCount = 0;
+      name;
+      status = { code: import_api4.SpanStatusCode.UNSET };
+      ended = false;
+      context;
+      attributeCountLimit;
+      attributeValueLengthLimit;
+      constructor(span, limits) {
+        this.context = span.spanContext();
+        this.name = span.name;
+        this.kind = span.kind;
+        this.parentSpanContext = span.parentSpanContext;
+        this.startTime = span.startTime;
+        this.resource = span.resource;
+        this.instrumentationScope = span.instrumentationScope;
+        this.links = [...span.links];
+        this.attributeCountLimit = limits?.attributeCountLimit ?? Number.POSITIVE_INFINITY;
+        this.attributeValueLengthLimit = limits?.attributeValueLengthLimit ?? Number.POSITIVE_INFINITY;
+        Object.assign(this.attributes, span.attributes);
+      }
+      spanContext() {
+        return this.context;
+      }
+      setAttribute(key, value) {
+        if (value === void 0 || key.length === 0) return this;
+        if (!(key in this.attributes) && Object.keys(this.attributes).length >= this.attributeCountLimit) {
+          this.droppedAttributesCount += 1;
+          return this;
+        }
+        this.attributes[key] = this.truncate(value);
+        return this;
+      }
+      /**
+       * The value-length limit, applied as the SDK's own Span applies it: strings
+       * are cut, string arrays are cut element by element, everything else passes.
+       */
+      truncate(value) {
+        const limit = this.attributeValueLengthLimit;
+        if (limit === Number.POSITIVE_INFINITY) return value;
+        if (typeof value === "string") return value.substring(0, limit);
+        if (Array.isArray(value)) {
+          return value.map((item) => typeof item === "string" ? item.substring(0, limit) : item);
+        }
+        return value;
+      }
+      setAttributes(attributes) {
+        for (const [key, value] of Object.entries(attributes)) this.setAttribute(key, value);
+        return this;
+      }
+      addEvent(name, attributesOrStartTime, _timeStamp) {
+        const attributes = attributesOrStartTime !== void 0 && typeof attributesOrStartTime === "object" ? attributesOrStartTime : void 0;
+        this.events.push({ name, attributes, time: this.startTime, droppedAttributesCount: 0 });
+        return this;
+      }
+      addLink(link) {
+        this.links.push(link);
+        return this;
+      }
+      addLinks(links) {
+        this.links.push(...links);
+        return this;
+      }
+      setStatus(status) {
+        this.status = status;
+        return this;
+      }
+      updateName(name) {
+        this.name = name;
+        return this;
+      }
+      end(_endTime) {
+        this.ended = true;
+      }
+      isRecording() {
+        return !this.ended;
+      }
+      /**
+       * An own property rather than a prototype method on purpose: errorType.ts
+       * replaces it per span instance, which a readonly method would refuse.
+       */
+      recordException = () => {
+      };
+    };
+    ShadowPipeline = class {
+      pipeline;
+      sampler;
+      limits;
+      constructor(pipeline, sampler, limits) {
+        this.pipeline = pipeline;
+        this.sampler = sampler;
+        this.limits = limits;
+      }
+      onStart(span, parentContext) {
+        const result = this.sampler.shouldSample(
+          parentContext,
+          span.spanContext().traceId,
+          span.name,
+          span.kind,
+          span.attributes,
+          span.links
+        );
+        if (result.decision !== import_sdk_trace_base.SamplingDecision.RECORD_AND_SAMPLED) {
+          dropped.add(span);
+          return;
+        }
+        const twin = new TwinSpan(span, this.limits);
+        shadows.set(span, { twin, seed: { ...span.attributes } });
+        this.pipeline.onStart(twin, parentContext);
+      }
+      onEnd(span) {
+        const shadow = shadows.get(span);
+        if (shadow !== void 0) this.pipeline.onEnd(stamped(span, shadow));
+      }
+      async forceFlush() {
+      }
+      async shutdown() {
+      }
+    };
+    Forwarder = class {
+      target;
+      attach(target) {
+        this.target = target;
+      }
+      release(target) {
+        if (this.target === target) this.target = void 0;
+      }
+      onStart(span, parentContext) {
+        this.target?.onStart(span, parentContext);
       }
       onEnd(span) {
-        for (const delegate of this.delegates) delegate.onEnd(span);
+        this.target?.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";
-    init_cjs_shims();
-    (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_cjs_shims();
-    init_ExportResult();
-  }
-});
-
-// src/exportHealth.ts
-var ExportOutcomeExporter;
-var init_exportHealth = __esm({
-  "src/exportHealth.ts"() {
-    "use strict";
-    init_cjs_shims();
-    init_esm();
-    ExportOutcomeExporter = class {
-      constructor(inner, onFirstFailure = (m) => console.warn(m)) {
-        this.inner = inner;
-        this.onFirstFailure = onFirstFailure;
+    forwarders = /* @__PURE__ */ new WeakMap();
+    Bridge = class {
+      forwarder;
+      pipeline;
+      constructor(forwarder, pipeline) {
+        this.forwarder = forwarder;
+        this.pipeline = pipeline;
+      }
+      /** Stop feeding the other provider's spans into this pipeline. Idempotent. */
+      release() {
+        this.forwarder.release(this.pipeline);
       }
+    };
+    ResourceAdoptingExporter = class {
       inner;
-      onFirstFailure;
-      failed = false;
-      warned = false;
-      get lastExportFailed() {
-        return this.failed;
+      resource;
+      adoptedResources = /* @__PURE__ */ new WeakMap();
+      constructor(inner, resource) {
+        this.inner = inner;
+        this.resource = resource;
       }
       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);
-        });
+        this.inner.export(
+          spans.map((span) => this.adopted(span)),
+          resultCallback
+        );
+      }
+      adopted(span) {
+        if (span.resource === this.resource) return span;
+        let merged = this.adoptedResources.get(span.resource);
+        if (merged === void 0) {
+          merged = (0, import_resources.resourceFromAttributes)(
+            { ...span.resource.attributes, ...this.resource.attributes },
+            { schemaUrl: this.resource.schemaUrl ?? span.resource.schemaUrl }
+          );
+          this.adoptedResources.set(span.resource, merged);
+        }
+        return { ...span, spanContext: () => span.spanContext(), resource: merged };
       }
       shutdown() {
         return this.inner.shutdown();
@@ -308,6 +1250,7 @@ var init_heartbeat = __esm({
       pingTimeoutMs;
       finalPingTimeoutMs;
       send;
+      foreignParentSpans;
       timer;
       stopped = false;
       deliveryWarned = false;
@@ -319,6 +1262,7 @@ var init_heartbeat = __esm({
         this.pingTimeoutMs = opts.pingTimeoutMs ?? DEFAULT_PING_TIMEOUT_MS;
         this.finalPingTimeoutMs = opts.finalPingTimeoutMs ?? DEFAULT_FINAL_PING_TIMEOUT_MS;
         this.send = opts.transport ?? httpTransport(opts.url, opts.headers);
+        this.foreignParentSpans = opts.foreignParentSpans;
       }
       /** Starts pinging: an immediate first ping, then every `intervalMs`. */
       start() {
@@ -343,202 +1287,29 @@ var init_heartbeat = __esm({
           agent_name: this.agentName,
           // RFC3339 UTC with millisecond precision and a Z suffix, already.
           sent_at: (/* @__PURE__ */ new Date()).toISOString(),
-          sdk_language: "typescript",
-          sdk_version: SDK_VERSION,
-          open_traces: openIds.slice(0, OPEN_TRACES_CAP),
-          open_trace_count: openIds.length
-        };
-        if (stopped) payload.stopped = true;
-        return payload;
-      }
-      async ping(timeoutMs, stopped) {
-        try {
-          await this.send(this.buildPayload(stopped), timeoutMs);
-        } catch (error) {
-          if (!this.deliveryWarned) {
-            this.deliveryWarned = true;
-            const message = error instanceof Error ? error.message : String(error);
-            console.warn(`[rius] heartbeat delivery failed (${message}); further failures are silent.`);
-          }
-        }
-      }
-    };
-  }
-});
-
-// src/semconv.ts
-function otelSpanKind(kind) {
-  return OTEL_KIND_BY_KIND[kind];
-}
-function kindAttributes(kind, name) {
-  const attributes = { [OPENINFERENCE_SPAN_KIND]: kind };
-  const operation = OPERATION_BY_KIND[kind];
-  if (operation !== void 0) attributes[GEN_AI_OPERATION_NAME] = operation;
-  if (kind === "TOOL" /* TOOL */ && name !== void 0) attributes[GEN_AI_TOOL_NAME] = name;
-  return attributes;
-}
-var import_api, TRACER_NAME, SERVICE_INSTANCE_ID, OPENINFERENCE_SPAN_KIND, INPUT_VALUE, OUTPUT_VALUE, SESSION_ID, USER_ID, WORKSPACE_ROUTE, GEN_AI_OPERATION_NAME, GEN_AI_PROVIDER_NAME, GEN_AI_REQUEST_MODEL, GEN_AI_REQUEST_REASONING_LEVEL, GEN_AI_RESPONSE_MODEL, GEN_AI_REQUEST_STREAM, GEN_AI_RESPONSE_TIME_TO_FIRST_CHUNK, GEN_AI_USAGE_INPUT_TOKENS, GEN_AI_USAGE_OUTPUT_TOKENS, GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS, GEN_AI_USAGE_CACHE_WRITE_INPUT_TOKENS, GEN_AI_USAGE_REASONING_OUTPUT_TOKENS, GEN_AI_INPUT_MESSAGES, GEN_AI_OUTPUT_MESSAGES, GEN_AI_RESPONSE_FINISH_REASONS, GEN_AI_TOOL_NAME, GEN_AI_TOOL_DEFINITIONS, GEN_AI_REQUEST_PREFIX, MCP_METHOD_NAME, MCP_METHOD_TOOLS_CALL, MCP_PROTOCOL_VERSION, ERROR_TYPE, ERROR_TYPE_TOOL_ERROR, MCP_RESULT_TYPE, GEN_AI_FIRST_TOKEN_EVENT, SpanKind, OPERATION_BY_KIND, OTEL_KIND_BY_KIND, CONTENT_ATTRIBUTES, LLM_INVOCATION_PARAMETERS, INVOCATION_PARAMETERS_CONTENT_MEMBERS, CONTENT_ATTRIBUTE_PREFIXES, CONTENT_ATTRIBUTE_SUFFIXES, GLASSFLOW_SPAN_PENDING, PENDING_IDENTITY_ATTRIBUTES, PENDING_IDENTITY_PREFIXES;
-var init_semconv = __esm({
-  "src/semconv.ts"() {
-    "use strict";
-    init_cjs_shims();
-    import_api = require("@opentelemetry/api");
-    TRACER_NAME = "glassflow";
-    SERVICE_INSTANCE_ID = "service.instance.id";
-    OPENINFERENCE_SPAN_KIND = "openinference.span.kind";
-    INPUT_VALUE = "input.value";
-    OUTPUT_VALUE = "output.value";
-    SESSION_ID = "session.id";
-    USER_ID = "user.id";
-    WORKSPACE_ROUTE = "rius.workspace";
-    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_REQUEST_REASONING_LEVEL = "gen_ai.request.reasoning.level";
-    GEN_AI_RESPONSE_MODEL = "gen_ai.response.model";
-    GEN_AI_REQUEST_STREAM = "gen_ai.request.stream";
-    GEN_AI_RESPONSE_TIME_TO_FIRST_CHUNK = "gen_ai.response.time_to_first_chunk";
-    GEN_AI_USAGE_INPUT_TOKENS = "gen_ai.usage.input_tokens";
-    GEN_AI_USAGE_OUTPUT_TOKENS = "gen_ai.usage.output_tokens";
-    GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS = "gen_ai.usage.cache_read.input_tokens";
-    GEN_AI_USAGE_CACHE_WRITE_INPUT_TOKENS = "gen_ai.usage.cache_write.input_tokens";
-    GEN_AI_USAGE_REASONING_OUTPUT_TOKENS = "gen_ai.usage.reasoning.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_TOOL_DEFINITIONS = "gen_ai.tool.definitions";
-    GEN_AI_REQUEST_PREFIX = "gen_ai.request.";
-    MCP_METHOD_NAME = "mcp.method.name";
-    MCP_METHOD_TOOLS_CALL = "tools/call";
-    MCP_PROTOCOL_VERSION = "mcp.protocol.version";
-    ERROR_TYPE = "error.type";
-    ERROR_TYPE_TOOL_ERROR = "tool_error";
-    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"
-    };
-    OTEL_KIND_BY_KIND = {
-      ["LLM" /* LLM */]: import_api.SpanKind.CLIENT,
-      ["EMBEDDING" /* EMBEDDING */]: import_api.SpanKind.CLIENT,
-      ["RETRIEVER" /* RETRIEVER */]: import_api.SpanKind.CLIENT,
-      ["TOOL" /* TOOL */]: import_api.SpanKind.INTERNAL,
-      ["AGENT" /* AGENT */]: import_api.SpanKind.INTERNAL,
-      ["CHAIN" /* CHAIN */]: import_api.SpanKind.INTERNAL
-    };
-    CONTENT_ATTRIBUTES = /* @__PURE__ */ new Set([
-      INPUT_VALUE,
-      OUTPUT_VALUE,
-      GEN_AI_INPUT_MESSAGES,
-      GEN_AI_OUTPUT_MESSAGES,
-      // Sensitive per the GenAI conventions (semconv-genai#431): tool definitions
-      // routinely embed proprietary prompt engineering, and sometimes credentials
-      // or internal URLs in parameter defaults. gen_ai.tool.name stays: it is
-      // identity, not content.
-      "gen_ai.tool.description",
-      GEN_AI_TOOL_DEFINITIONS,
-      // GenAI semconv keys emitted by OTel-native instrumentations (@ai-sdk/otel,
-      // which init() registers for ai v7, among them; pinned 2026-09-14): the
-      // system prompt and each tool call's input and output are content in the
-      // same sense messages are. gen_ai.tool.call.id stays: identity.
-      "gen_ai.system_instructions",
-      "gen_ai.tool.call.arguments",
-      "gen_ai.tool.call.result",
-      // OpenInference TOOL-kind spans carry the definition under these two bare
-      // keys, sensitive for the reason gen_ai.tool.description is.
-      "tool.description",
-      "tool.parameters",
-      "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",
-      // Every bundled OpenInference instrumentation emits tool definitions as
-      // llm.tools.{i}.tool.json_schema (pinned empirically 2026-09-14); covered
-      // by prefix below, bare key listed per the bare-key rule.
-      "llm.tools",
-      // The Vercel AI SDK's own telemetry keys survive the OpenInference
-      // transform untouched, and they carry the full prompt (messages AND tool
-      // definitions), response content, and tool-call I/O. Names, ids and models
-      // (ai.toolCall.name, ai.response.model, ...) are identity and stay.
-      "ai.prompt",
-      "ai.response.text",
-      "ai.response.object",
-      "ai.toolCall.args",
-      "ai.toolCall.result",
-      // Same family, keys enumerated from the ai v7 telemetry surface
-      // (2026-09-14): model reasoning, tool calls in the response, response
-      // files, embedding inputs, rerank documents, and the generateObject schema
-      // (a tool definition by another name).
-      "ai.response.reasoning",
-      "ai.response.toolCalls",
-      "ai.response.files",
-      "ai.value",
-      "ai.values",
-      "ai.documents",
-      "ai.schema",
-      "ai.schema.description"
-    ]);
-    LLM_INVOCATION_PARAMETERS = "llm.invocation_parameters";
-    INVOCATION_PARAMETERS_CONTENT_MEMBERS = ["tools", "functions"];
-    CONTENT_ATTRIBUTE_PREFIXES = [
-      "llm.input_messages.",
-      "llm.output_messages.",
-      "gen_ai.prompt.",
-      "gen_ai.completion.",
-      "llm.prompts.",
-      "llm.prompt_template.",
-      "llm.tools.",
-      "ai.prompt."
-    ];
-    CONTENT_ATTRIBUTE_SUFFIXES = [
-      ".document.content",
-      ".embedding.text"
-    ];
-    GLASSFLOW_SPAN_PENDING = "glassflow.span.pending";
-    PENDING_IDENTITY_ATTRIBUTES = /* @__PURE__ */ new Set([
-      OPENINFERENCE_SPAN_KIND,
-      GEN_AI_OPERATION_NAME,
-      GEN_AI_PROVIDER_NAME,
-      GEN_AI_TOOL_NAME,
-      // Protocol identity, not content: a still-running MCP call must be
-      // distinguishable from a local tool in the live view — the one place
-      // setting the marker at creation pays off.
-      MCP_METHOD_NAME,
-      MCP_PROTOCOL_VERSION,
-      // Identity, not content: a pending span must be groupable into its
-      // session while still running, that is the live view's whole point.
-      SESSION_ID,
-      // Same reason: a crashed run's partial spans must still be attributable
-      // to the user they served.
-      USER_ID,
-      // Routing, not content: a crashed run's snapshot must land in the same
-      // workspace its final span would have. Stripped at export either way.
-      WORKSPACE_ROUTE
-    ]);
-    PENDING_IDENTITY_PREFIXES = [GEN_AI_REQUEST_PREFIX];
+          sdk_language: "typescript",
+          sdk_version: SDK_VERSION,
+          open_traces: openIds.slice(0, OPEN_TRACES_CAP),
+          open_trace_count: openIds.length
+        };
+        if (this.foreignParentSpans !== void 0) {
+          payload.foreign_parent_spans = this.foreignParentSpans();
+        }
+        if (stopped) payload.stopped = true;
+        return payload;
+      }
+      async ping(timeoutMs, stopped) {
+        try {
+          await this.send(this.buildPayload(stopped), timeoutMs);
+        } catch (error) {
+          if (!this.deliveryWarned) {
+            this.deliveryWarned = true;
+            const message = error instanceof Error ? error.message : String(error);
+            console.warn(`[rius] heartbeat delivery failed (${message}); further failures are silent.`);
+          }
+        }
+      }
+    };
   }
 });
 
@@ -583,8 +1354,14 @@ function toAttributeValue(value) {
     return "[unserializable]";
   }
 }
-function errorType(error) {
-  return error instanceof Error ? error.name : typeof error;
+function attributeValue(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (Array.isArray(value)) {
+    if (value.every((v) => typeof v === "string")) return value;
+    if (value.every((v) => typeof v === "number")) return value;
+    if (value.every((v) => typeof v === "boolean")) return value;
+  }
+  return toAttributeValue(value);
 }
 var MAX_ATTR_CHARS, TRUNCATION_MARKER;
 var init_serde = __esm({
@@ -596,18 +1373,75 @@ var init_serde = __esm({
   }
 });
 
+// src/errorType.ts
+function className(value) {
+  const ctor = Object.getPrototypeOf(value)?.constructor;
+  return typeof ctor === "function" && ctor.name !== "" ? ctor.name : void 0;
+}
+function packageOf(error) {
+  for (let proto = Object.getPrototypeOf(error); proto !== null; ) {
+    const ctor = Object.hasOwn(proto, "constructor") ? proto.constructor : void 0;
+    if (typeof ctor === "function" && Object.hasOwn(PACKAGE_OF_BASE_CLASS, ctor.name)) {
+      return PACKAGE_OF_BASE_CLASS[ctor.name];
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+  return void 0;
+}
+function errorType(error) {
+  if (!(error instanceof Error)) return typeof error;
+  try {
+    const cls = className(error);
+    const bare = error.name === "Error" && cls !== void 0 ? cls : error.name;
+    const pkg = packageOf(error);
+    return pkg === void 0 ? bare : `${pkg}.${bare}`;
+  } catch {
+    return error.name;
+  }
+}
+function exceptionForRecording(exception) {
+  if (!(exception instanceof Error)) return exception;
+  const type = errorType(exception);
+  if (type === exception.name) return exception;
+  return { name: type, message: exception.message, stack: exception.stack };
+}
+function qualifyRecordedExceptions(span) {
+  const original = span.recordException;
+  if (typeof original !== "function" || original[WRAPPED] === true) return;
+  const wrapped = Object.assign(
+    (exception, time) => original.call(span, exceptionForRecording(exception), time),
+    { [WRAPPED]: true }
+  );
+  try {
+    span.recordException = wrapped;
+  } catch {
+  }
+}
+var PACKAGE_OF_BASE_CLASS, WRAPPED;
+var init_errorType = __esm({
+  "src/errorType.ts"() {
+    "use strict";
+    init_cjs_shims();
+    PACKAGE_OF_BASE_CLASS = {
+      AnthropicError: "anthropic",
+      OpenAIError: "openai"
+    };
+    WRAPPED = /* @__PURE__ */ Symbol("rius.recordException");
+  }
+});
+
 // src/user.ts
 function withUser(userId, fn) {
-  return import_api2.context.with(import_api2.context.active().setValue(USER_KEY, userId), () => fn(userId));
+  return import_api5.context.with(import_api5.context.active().setValue(USER_KEY, userId), () => fn(userId));
 }
-var import_api2, USER_KEY, UserSpanProcessor;
+var import_api5, USER_KEY, UserSpanProcessor;
 var init_user = __esm({
   "src/user.ts"() {
     "use strict";
     init_cjs_shims();
-    import_api2 = require("@opentelemetry/api");
+    import_api5 = require("@opentelemetry/api");
     init_semconv();
-    USER_KEY = (0, import_api2.createContextKey)("rius-user-id");
+    USER_KEY = (0, import_api5.createContextKey)("rius-user-id");
     UserSpanProcessor = class {
       onStart(span, parentContext) {
         const value = parentContext.getValue(USER_KEY);
@@ -628,31 +1462,79 @@ function configure(observation, options) {
   if (options.input !== void 0) observation.setInput(options.input);
   return observation;
 }
+function resolveToolName(options, name) {
+  if (options.toolName !== void 0) return options.toolName;
+  if (name === void 0) return void 0;
+  if (options.kind === "TOOL" /* TOOL */) {
+    warnOnce(
+      `A span named "${name}" with kind TOOL is naming the tool as well as the span; gen_ai.tool.name will be "${name}". Pass toolName to set them separately. A future major release will stop deriving the tool name from the span name.`
+    );
+  }
+  return name;
+}
+function warnOnce(message) {
+  if (warned.has(message)) return;
+  warned.add(message);
+  console.warn(`[rius] ${message}`);
+}
 function creationAttributes(name, options) {
+  const kind = options.kind ?? "CHAIN" /* CHAIN */;
   const attributes = {
-    ...kindAttributes(options.kind ?? "CHAIN" /* CHAIN */, name),
+    ...kindAttributes(kind, resolveToolName(options, name)),
     ...options.attributes
   };
   if (options.userId !== void 0) attributes[USER_ID] = options.userId;
+  if (kind === "RETRIEVER" /* RETRIEVER */) {
+    if (options.dataSourceId !== void 0)
+      attributes[GEN_AI_DATA_SOURCE_ID] = options.dataSourceId;
+    if (options.topK !== void 0) attributes[GEN_AI_RETRIEVAL_TOP_K] = options.topK;
+  }
+  if (kind === "TOOL" /* TOOL */) {
+    const executedBy = executingAgentName();
+    if (executedBy !== void 0) attributes[GEN_AI_AGENT_NAME] = executedBy;
+    if (options.toolCallId !== void 0) attributes[GEN_AI_TOOL_CALL_ID] = options.toolCallId;
+    if (options.toolType !== void 0) attributes[GEN_AI_TOOL_TYPE] = options.toolType;
+  }
+  if (kind === "AGENT" /* AGENT */) {
+    const agentName = resolveAgentName(options.agentName, kind);
+    if (agentName !== void 0) attributes[GEN_AI_AGENT_NAME] = agentName;
+    if (options.agentId !== void 0) attributes[GEN_AI_AGENT_ID] = options.agentId;
+    if (options.agentVersion !== void 0) attributes[GEN_AI_AGENT_VERSION] = options.agentVersion;
+  }
   return attributes;
 }
-function startSpan(name, options = {}) {
-  const span = getTracer().startSpan(name, {
+function resolveName(name, kind, attributes) {
+  return name ?? composeSpanName(kind ?? "CHAIN" /* CHAIN */, attributes);
+}
+function splitScopedArgs(first, second, third) {
+  if (typeof first === "function") return { name: void 0, options: {}, fn: first };
+  if (typeof first === "string") {
+    return typeof second === "function" ? { name: first, options: {}, fn: second } : { name: first, options: second ?? {}, fn: third };
+  }
+  return { name: void 0, options: first, fn: second };
+}
+function startSpan(nameOrOptions, maybeOptions) {
+  const [name, options] = typeof nameOrOptions === "string" ? [nameOrOptions, maybeOptions ?? {}] : [void 0, nameOrOptions ?? {}];
+  const attributes = creationAttributes(name, options);
+  const span = getTracer().startSpan(resolveName(name, options.kind, attributes), {
     kind: options.otelKind ?? otelSpanKind(options.kind ?? "CHAIN" /* CHAIN */),
-    attributes: creationAttributes(name, options)
+    attributes
   });
   return configure(new Observation(span), options);
 }
-function startAsCurrentSpan(name, optionsOrFn, maybeFn) {
-  const [options, fn] = typeof optionsOrFn === "function" ? [{}, optionsOrFn] : [optionsOrFn, maybeFn];
-  return runActive(
-    name,
-    creationAttributes(name, options),
+function startAsCurrentSpan(first, second, third) {
+  const { name, options, fn } = splitScopedArgs(first, second, third);
+  const attributes = creationAttributes(name, options);
+  const run = () => runActive(
+    resolveName(name, options.kind, attributes),
+    attributes,
     options.userId,
     (span) => configure(new Observation(span), options),
     fn,
     options.otelKind ?? otelSpanKind(options.kind ?? "CHAIN" /* CHAIN */)
   );
+  const scopeName = (options.kind ?? "CHAIN" /* CHAIN */) === "AGENT" /* AGENT */ ? attributes[GEN_AI_AGENT_NAME] : void 0;
+  return typeof scopeName === "string" ? withAgentScope(scopeName, run) : run();
 }
 function runActive(name, attributes, userId, makeHandle, fn, otelKind) {
   const run = () => getTracer().startActiveSpan(name, { kind: otelKind, attributes }, async (span) => {
@@ -668,13 +1550,15 @@ function runActive(name, attributes, userId, makeHandle, fn, otelKind) {
   });
   return userId !== void 0 ? withUser(userId, run) : run();
 }
-var import_api3, Observation;
+var import_api6, Observation, warned;
 var init_spans = __esm({
   "src/spans.ts"() {
     "use strict";
     init_cjs_shims();
-    import_api3 = require("@opentelemetry/api");
+    import_api6 = require("@opentelemetry/api");
+    init_agent();
     init_client();
+    init_errorType();
     init_semconv();
     init_serde();
     init_user();
@@ -693,6 +1577,23 @@ var init_spans = __esm({
         this.span.setAttribute(OUTPUT_VALUE, toAttributeValue(value));
         return this;
       }
+      /**
+       * Record what a retrieval returned, as `gen_ai.retrieval.documents`.
+       *
+       * The conventions define this as an array of objects, each with an optional
+       * `id` and an optional `score`. Identifiers and relevance, never document
+       * text, which is why it is not treated as content: it survives
+       * `captureContent: false` the way token counts do. Put the retrieved text in
+       * `setOutput` if you want it captured, and masking applies to it there.
+       *
+       * Unlike `dataSourceId` and `topK`, which describe the request and are
+       * passed at span creation, this is only knowable once the search has run, so
+       * it never reaches a pending snapshot.
+       */
+      setRetrievedDocuments(documents) {
+        this.span.setAttribute(GEN_AI_RETRIEVAL_DOCUMENTS, toAttributeValue(documents));
+        return this;
+      }
       /**
        * Set an arbitrary attribute. Primitives and homogeneous primitive arrays
        * are passed through as the OTel values they are; objects are JSON-encoded
@@ -700,20 +1601,8 @@ var init_spans = __esm({
        * an empty string.
        */
       setAttribute(key, value) {
-        if (value === void 0 || value === null) return this;
-        if (Array.isArray(value) && value.every((v) => typeof v === "string")) {
-          this.span.setAttribute(key, value);
-          return this;
-        }
-        if (Array.isArray(value) && value.every((v) => typeof v === "number")) {
-          this.span.setAttribute(key, value);
-          return this;
-        }
-        if (Array.isArray(value) && value.every((v) => typeof v === "boolean")) {
-          this.span.setAttribute(key, value);
-          return this;
-        }
-        this.span.setAttribute(key, toAttributeValue(value));
+        const coerced = attributeValue(value);
+        if (coerced !== void 0) this.span.setAttribute(key, coerced);
         return this;
       }
       /**
@@ -724,16 +1613,17 @@ var init_spans = __esm({
        *
        * `error.type` is Conditionally Required by the GenAI conventions on every
        * span that ends in an error, and every helper's throw path funnels through
-       * here, so this is the one place that sets it. The error's name only, never
-       * the message: it must stay low-cardinality and free of echoed content.
+       * here, so this is the one place that sets it. The error's name or class
+       * (see errorType), never the message: it must stay low-cardinality and free
+       * of echoed content.
        *
        * 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_api3.SpanStatusCode.ERROR, message: wrapped.message });
+        this.span.recordException(exceptionForRecording(wrapped));
+        this.span.setStatus({ code: import_api6.SpanStatusCode.ERROR, message: wrapped.message });
         this.span.setAttribute(ERROR_TYPE, errorType(error));
         return this;
       }
@@ -747,6 +1637,7 @@ var init_spans = __esm({
         this.end();
       }
     };
+    warned = /* @__PURE__ */ new Set();
   }
 });
 
@@ -782,7 +1673,7 @@ function recordResult(observation, result) {
   observation.setAttribute(OUTPUT_VALUE, serializeResult(result));
   if (resultIsError(result)) {
     observation.span.setStatus({
-      code: import_api4.SpanStatusCode.ERROR,
+      code: import_api7.SpanStatusCode.ERROR,
       message: "tool returned an error result"
     });
     observation.setAttribute(ERROR_TYPE, ERROR_TYPE_TOOL_ERROR);
@@ -792,9 +1683,8 @@ function negotiatedProtocolVersion(client) {
   const version = asRecord(asRecord(client)?.transport)?.protocolVersion;
   return typeof version === "string" ? version : void 0;
 }
-function callAttributes(toolName, protocolVersion) {
+function callAttributes(protocolVersion) {
   const attributes = {
-    [GEN_AI_TOOL_NAME]: toolName,
     [MCP_METHOD_NAME]: MCP_METHOD_TOOLS_CALL
   };
   if (protocolVersion !== void 0) attributes[MCP_PROTOCOL_VERSION] = protocolVersion;
@@ -811,15 +1701,15 @@ function instrumentMcpClient(ClientClass) {
   const original = ClientClass.prototype.callTool;
   const instrumented = function instrumentedCallTool(params, ...rest) {
     return startAsCurrentSpan(
-      `execute_tool ${params.name}`,
       {
         kind: "TOOL" /* TOOL */,
         // The OTel SpanKind FIELD (orthogonal to our taxonomy attribute above):
         // a remote tool call is CLIENT under both the MCP and the GenAI
         // execute-tool conventions.
-        otelKind: import_api4.SpanKind.CLIENT,
+        otelKind: import_api7.SpanKind.CLIENT,
+        toolName: params.name,
         input: params.arguments,
-        attributes: callAttributes(params.name, negotiatedProtocolVersion(this))
+        attributes: callAttributes(negotiatedProtocolVersion(this))
       },
       async (observation) => {
         const result = await original.call(this, params, ...rest);
@@ -834,12 +1724,12 @@ function instrumentMcpClient(ClientClass) {
     ClientClass.prototype.callTool = original;
   };
 }
-var import_api4, INPUT_REQUIRED;
+var import_api7, INPUT_REQUIRED;
 var init_instrumentationMcp = __esm({
   "src/instrumentationMcp.ts"() {
     "use strict";
     init_cjs_shims();
-    import_api4 = require("@opentelemetry/api");
+    import_api7 = require("@opentelemetry/api");
     init_semconv();
     init_serde();
     init_spans();
@@ -848,7 +1738,7 @@ var init_instrumentationMcp = __esm({
 });
 
 // src/instrumentation.ts
-function packageOf(specifier) {
+function packageOf2(specifier) {
   const segments = specifier.split("/");
   const take = specifier.startsWith("@") ? 2 : 1;
   return segments.slice(0, take).join("/");
@@ -860,7 +1750,7 @@ 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("|");
+  const alternatives = [specifier, packageOf2(specifier)].map(escapeRegExp).join("|");
   return new RegExp(
     `(?:cannot find (?:module|package)|could not resolve|failed to load url)\\s*['"\`]?(?:${alternatives})['"\`]?(?![\\w./@-])`,
     "i"
@@ -929,6 +1819,73 @@ function anthropicPatchable(exports2) {
   const cls = exports2.default ?? exports2.Anthropic;
   return cls?.Messages?.prototype?.create ? { default: cls } : void 0;
 }
+function openaiPrototypes(moduleExports) {
+  const cls = moduleExports?.OpenAI;
+  const prototypes = [];
+  for (const path of OPENAI_INSTRUMENTED_RESOURCES) {
+    let resource = cls;
+    for (const segment of path) {
+      resource = resource?.[segment];
+    }
+    const proto = resource?.prototype;
+    if (typeof proto?.create === "function") prototypes.push(proto);
+  }
+  return prototypes;
+}
+function settlementOf(result) {
+  const raw = result?.responsePromise;
+  if (typeof raw?.then === "function") {
+    return raw;
+  }
+  return result instanceof Promise ? result : void 0;
+}
+function failSpan(span, error) {
+  if (!span.isRecording()) return;
+  span.recordException(error instanceof Error ? error : String(error));
+  span.setStatus({
+    code: import_api8.SpanStatusCode.ERROR,
+    message: error instanceof Error ? error.message : String(error)
+  });
+  span.end();
+}
+function guardRejections(original) {
+  const guarded = function(...args) {
+    const span = import_api8.trace.getActiveSpan();
+    const result = original.apply(this, args);
+    if (span?.isRecording()) {
+      settlementOf(result)?.then(void 0, (error) => failSpan(span, error));
+    }
+    return result;
+  };
+  guarded[GUARDED_ORIGINAL] = original;
+  return guarded;
+}
+function withRejectedCallsEnded(Base) {
+  return class extends Base {
+    patch(moduleExports, moduleVersion) {
+      const installed = [];
+      for (const proto of openaiPrototypes(moduleExports)) {
+        const create = proto.create;
+        if (create[GUARDED_ORIGINAL] !== void 0) continue;
+        const guarded = guardRejections(create);
+        proto.create = guarded;
+        installed.push([proto, guarded]);
+      }
+      const patched = super.patch(moduleExports, moduleVersion);
+      for (const [proto, guarded] of installed) {
+        if (proto.create === guarded) proto.create = guarded[GUARDED_ORIGINAL];
+      }
+      return patched;
+    }
+    unpatch(moduleExports, moduleVersion) {
+      super.unpatch(moduleExports, moduleVersion);
+      for (const proto of openaiPrototypes(moduleExports)) {
+        const original = proto.create[GUARDED_ORIGINAL];
+        if (original !== void 0) proto.create = original;
+      }
+    }
+  };
+}
 function mcpClientPatchable(exports2) {
   const cls = exports2.Client;
   return typeof cls?.prototype?.callTool === "function" ? { Client: cls } : void 0;
@@ -966,6 +1923,10 @@ async function registerVercelTelemetry(tracerProvider, teardown) {
   });
   return true;
 }
+function isVercelDialectSpan(span) {
+  const operationId = span.attributes[VERCEL_OPERATION_ID];
+  return typeof operationId === "string" && operationId.startsWith("ai.");
+}
 async function enableInstrumentations(sink, tracerProvider, names, teardown) {
   const wanted = names ? REGISTRY.filter((e) => names.includes(e.name)) : REGISTRY;
   const enabled = [];
@@ -990,17 +1951,26 @@ async function enableInstrumentations(sink, tracerProvider, names, teardown) {
   }
   return enabled;
 }
-var import_node_module2, import_node_path, import_instrumentation, dynamicImport, vercelTelemetryIntegration, REGISTRY;
+var import_node_module2, import_node_path, import_api8, import_instrumentation, dynamicImport, OPENAI_INSTRUMENTED_RESOURCES, GUARDED_ORIGINAL, vercelTelemetryIntegration, VERCEL_OPERATION_ID, REGISTRY;
 var init_instrumentation = __esm({
   "src/instrumentation.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_module2 = require("module");
     import_node_path = require("path");
+    import_api8 = require("@opentelemetry/api");
     import_instrumentation = require("@opentelemetry/instrumentation");
     init_semconv();
     init_version();
     dynamicImport = new Function("s", "return import(s)");
+    OPENAI_INSTRUMENTED_RESOURCES = [
+      ["Chat", "Completions"],
+      ["Completions"],
+      ["Embeddings"],
+      ["Responses"]
+    ];
+    GUARDED_ORIGINAL = /* @__PURE__ */ Symbol("rius.openai.guardedOriginal");
+    VERCEL_OPERATION_ID = "ai.operationId";
     REGISTRY = [
       {
         name: "vercel-ai",
@@ -1019,7 +1989,7 @@ var init_instrumentation = __esm({
             onStart() {
             },
             onEnd(span) {
-              add?.(span);
+              if (add !== void 0 && isVercelDialectSpan(span)) add(span);
             },
             async forceFlush() {
             },
@@ -1035,7 +2005,7 @@ var init_instrumentation = __esm({
           const mod = await optional("@arizeai/openinference-instrumentation-openai");
           const Ctor = mod?.OpenAIInstrumentation;
           if (Ctor === void 0) return void 0;
-          const instrumentation = new Ctor();
+          const instrumentation = new (withRejectedCallsEnded(Ctor))();
           await patchActiveBuild(instrumentation, "openai", openaiPatchable);
           return instrumentation;
         }
@@ -1084,127 +2054,862 @@ var init_instrumentation = __esm({
           return true;
         }
       }
-    ];
+    ];
+  }
+});
+
+// src/masking.ts
+function isContentKey(key) {
+  if (CONTENT_ATTRIBUTES.has(key)) return true;
+  if (CONTENT_ATTRIBUTE_PREFIXES.some((p) => key.startsWith(p)) && !CONTENT_PREFIX_IDENTITY_ATTRIBUTES.has(key))
+    return true;
+  if (CONTENT_ATTRIBUTE_SUFFIXES.some((s) => key.endsWith(s))) return true;
+  if (CONTENT_ATTRIBUTE_PREFIXED_SUFFIXES.some(
+    ([prefix, leaves]) => key.startsWith(prefix) && leaves.some((leaf) => key.endsWith(leaf))
+  ))
+    return true;
+  return key.startsWith(METADATA_PREFIX) && isContentKey(key.slice(METADATA_PREFIX.length));
+}
+var import_api9, METADATA_PREFIX, EXCEPTION_CONTENT_KEYS, STATUS_DESCRIPTION_KEY, MaskingSpanExporter;
+var init_masking = __esm({
+  "src/masking.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_api9 = require("@opentelemetry/api");
+    init_semconv();
+    init_serde();
+    METADATA_PREFIX = "metadata.";
+    EXCEPTION_CONTENT_KEYS = ["exception.message", "exception.stacktrace"];
+    STATUS_DESCRIPTION_KEY = "status.description";
+    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) continue;
+          for (const key of EXCEPTION_CONTENT_KEYS) delete attributes[key];
+        }
+        for (const link of span.links ?? []) {
+          this.sanitizeAttributes(link.attributes);
+        }
+        this.sanitizeStatus(span);
+        return span;
+      }
+      /**
+       * Drops or masks the status description, in place. `status` is mutable and
+       * exposed by reference on the SDK span, same as `attributes`, so mutating it
+       * here reaches the span about to be handed to the inner exporter. The ERROR
+       * code itself is left alone so the failure stays visible and classifiable,
+       * the same policy as `exception.type`.
+       */
+      sanitizeStatus(span) {
+        const status = span.status;
+        if (status?.code !== import_api9.SpanStatusCode.ERROR || !status.message) return;
+        if (!this.opts.captureContent) {
+          status.message = void 0;
+          return;
+        }
+        if (this.opts.mask === void 0) return;
+        try {
+          const masked = toAttributeValue(
+            this.opts.mask(status.message, { key: STATUS_DESCRIPTION_KEY })
+          );
+          status.message = typeof masked === "string" ? masked : String(masked);
+        } catch {
+          status.message = "[mask error]";
+        }
+      }
+      /** 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/normalize.ts
+function isExpanding(rule) {
+  return "expand" in rule;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asCount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.trunc(value) : void 0;
+}
+function asText(value) {
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function asFlag(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function asTextList(value) {
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value) && value.every((v) => typeof v === "string")) return [...value];
+  return void 0;
+}
+function wellFormed(text) {
+  return text.replace(LONE_SURROGATE, "\uFFFD");
+}
+function jsonString(text) {
+  return JSON.stringify(wellFormed(text));
+}
+function compactJson(value) {
+  if (typeof value === "string") return jsonString(value);
+  if (Array.isArray(value)) return `[${value.map(compactJson).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const members = Object.entries(value).map(([k, v]) => `${jsonString(k)}:${compactJson(v)}`);
+    return `{${members.join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function asToolChoice(value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    return compactJson(value);
+  }
+  return typeof value === "string" ? asText(wellFormed(value)) : void 0;
+}
+function invocationParameters(raw) {
+  if (typeof raw !== "string") return { [LLM_INVOCATION_PARAMETERS]: raw };
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch {
+    return { [LLM_INVOCATION_PARAMETERS]: raw };
+  }
+  if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+    return { [LLM_INVOCATION_PARAMETERS]: raw };
+  }
+  const leftover = { ...payload };
+  const produced = {};
+  for (const [member, target, convert] of INVOCATION_PARAMETER_MEMBERS) {
+    if (!Object.hasOwn(leftover, member) || produced[target] !== void 0) continue;
+    const value = convert(leftover[member]);
+    if (value === void 0) continue;
+    produced[target] = value;
+    delete leftover[member];
+  }
+  if (Object.keys(produced).length === 0) return { [LLM_INVOCATION_PARAMETERS]: raw };
+  const expansion = { ...produced };
+  if (Object.keys(leftover).length > 0) {
+    expansion[LLM_INVOCATION_PARAMETERS] = toAttributeValue(leftover);
+  }
+  return expansion;
+}
+function taxonomyFromKind(raw) {
+  if (typeof raw !== "string") return {};
+  const operation = operationForKind(raw);
+  const produced = { [OPENINFERENCE_SPAN_KIND]: raw };
+  if (operation !== void 0) produced[GEN_AI_OPERATION_NAME] = operation;
+  return produced;
+}
+function taxonomyFromOperation(raw) {
+  if (typeof raw !== "string") return {};
+  const kind = kindForOperation(raw);
+  const produced = { [GEN_AI_OPERATION_NAME]: raw };
+  if (kind !== void 0) produced[OPENINFERENCE_SPAN_KIND] = kind;
+  return produced;
+}
+function sourceKeys(rule) {
+  return typeof rule.source === "string" ? [rule.source] : rule.source;
+}
+function sourcePrefixes(rules) {
+  const prefixes = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    for (const key of sourceKeys(rule)) {
+      const dot = key.indexOf(".");
+      prefixes.add(dot === -1 ? key : key.slice(0, dot + 1));
+    }
+  }
+  return [...prefixes];
+}
+function applyRules(attributes, rules) {
+  const mapped = [];
+  const rewritten = [];
+  for (const rule of rules) {
+    const keys = sourceKeys(rule);
+    const present = keys.filter((key) => attributes[key] !== void 0);
+    if (present.length === 0) continue;
+    if (isExpanding(rule)) {
+      let expansion;
+      try {
+        expansion = rule.expand(attributes[rule.source]);
+      } catch {
+        continue;
+      }
+      for (const [key, value2] of Object.entries(expansion)) {
+        if (value2 === void 0) continue;
+        const ownSource = key === rule.source;
+        if (!ownSource && attributes[key] !== void 0) continue;
+        attributes[key] = value2;
+        if (ownSource) rewritten.push(key);
+      }
+      if (expansion[rule.source] === void 0) {
+        const targets = Object.keys(expansion).filter((key) => expansion[key] !== void 0);
+        mapped.push({ sources: [rule.source], targets });
+      }
+      continue;
+    }
+    if (attributes[rule.target] !== void 0) {
+      mapped.push({ sources: present, targets: [rule.target] });
+      continue;
+    }
+    const value = rule.convert(present.map((key) => attributes[key]));
+    if (value === void 0) continue;
+    attributes[rule.target] = value;
+    mapped.push({ sources: present, targets: [rule.target] });
+  }
+  return { mapped, rewritten };
+}
+function normalizeFirstTokenEvent(span) {
+  const events = span.events;
+  if (events === void 0 || events.length === 0) return {};
+  if (!events.some((event) => event.name === OPENINFERENCE_FIRST_TOKEN_EVENT)) return {};
+  const attributes = span.attributes ?? {};
+  let canonicalSeen = events.some((event) => event.name === GEN_AI_FIRST_TOKEN_EVENT);
+  let firstTokenTime;
+  const rebuilt = [];
+  for (const event of events) {
+    if (event.name !== OPENINFERENCE_FIRST_TOKEN_EVENT) {
+      rebuilt.push(event);
+      continue;
+    }
+    firstTokenTime ??= event.time;
+    if (canonicalSeen) continue;
+    canonicalSeen = true;
+    rebuilt.push({ ...event, name: GEN_AI_FIRST_TOKEN_EVENT });
+  }
+  span.events.splice(0, events.length, ...rebuilt);
+  const added = {};
+  if (attributes[GEN_AI_REQUEST_STREAM] === void 0) added[GEN_AI_REQUEST_STREAM] = true;
+  if (attributes[GEN_AI_RESPONSE_TIME_TO_FIRST_CHUNK] === void 0 && firstTokenTime) {
+    const elapsedNanos = hrTimeToNanos(firstTokenTime) - hrTimeToNanos(span.startTime);
+    added[GEN_AI_RESPONSE_TIME_TO_FIRST_CHUNK] = Math.max(elapsedNanos, 0) / 1e9;
+  }
+  return added;
+}
+function hrTimeToNanos(time) {
+  return time[0] * 1e9 + time[1];
+}
+function errorTypeFromExceptionEvent(span) {
+  if (span.status?.code !== import_api10.SpanStatusCode.ERROR) return {};
+  if (span.attributes?.[ERROR_TYPE] !== void 0) return {};
+  for (const event of span.events ?? []) {
+    if (event.name !== EXCEPTION_EVENT) continue;
+    const type = event.attributes?.[EXCEPTION_TYPE];
+    if (typeof type === "string" && type !== "") return { [ERROR_TYPE]: type };
+  }
+  return {};
+}
+function parseIndex(text) {
+  if (!INDEX.test(text)) return void 0;
+  const value = BigInt(text.startsWith("+") ? text.slice(1) : text);
+  return value >= 0n && value < INT64_LIMIT ? value : void 0;
+}
+function byIndex(entries) {
+  return [...entries].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([, value]) => value);
+}
+function byCodePoint(a, b) {
+  const x = [...a];
+  const y = [...b];
+  for (let i = 0; i < Math.min(x.length, y.length); i++) {
+    const diff = (x[i].codePointAt(0) ?? 0) - (y[i].codePointAt(0) ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return x.length - y.length;
+}
+function cutIndexed(text) {
+  const dot = text.indexOf(".");
+  if (dot < 0) return void 0;
+  const index = parseIndex(text.slice(0, dot));
+  return index === void 0 ? void 0 : [index, text.slice(dot + 1)];
+}
+function fieldRecord() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function contentPart(item, toolCalls) {
+  const names = Object.keys(item).sort(byCodePoint);
+  if (names.length === 2 && item.type === "text" && Object.hasOwn(item, "text")) {
+    return { type: "text", content: item.text };
+  }
+  if (item.type === "tool_use" && repeatsToolCall(item, toolCalls)) return void 0;
+  const sorted = fieldRecord();
+  for (const name of names) sorted[name] = item[name];
+  return { type: "text", content: toAttributeValue(sorted) };
+}
+function repeatsToolCall(item, toolCalls) {
+  const fields = Object.keys(item).filter((name) => name !== "type");
+  if (!fields.every((name) => TOOL_USE_ITEM_FIELDS.has(name))) return false;
+  return [...toolCalls.values()].some(
+    (call) => fields.every((name) => {
+      const field = TOOL_USE_ITEM_FIELDS.get(name);
+      return (Object.hasOwn(call, field) ? call[field] : "") === item[name];
+    })
+  );
+}
+function encodeMessage(message) {
+  const parts = [];
+  if (message.content !== void 0) {
+    parts.push(
+      message.toolCallId ? { type: "tool_call_response", id: message.toolCallId, response: message.content } : { type: "text", content: message.content }
+    );
+  }
+  for (const item of byIndex(message.contents)) {
+    const part = contentPart(item, message.toolCalls);
+    if (part !== void 0) parts.push(part);
+  }
+  for (const call of byIndex(message.toolCalls)) {
+    const part = { type: "tool_call" };
+    for (const [field, name] of TOOL_CALL_FIELDS) {
+      if (Object.hasOwn(call, field) && call[field]) part[name] = call[field];
+    }
+    parts.push(part);
+  }
+  return message.role ? { role: message.role, parts } : { parts };
+}
+function reassembleFamily(attributes, prefix) {
+  const messages = /* @__PURE__ */ new Map();
+  const consumed = [];
+  for (const key of Object.keys(attributes)) {
+    if (!key.startsWith(prefix)) continue;
+    const indexed = cutIndexed(key.slice(prefix.length));
+    if (indexed === void 0) continue;
+    const [index, field] = indexed;
+    let call;
+    let item;
+    if (field.startsWith(LLM_MESSAGE_TOOL_CALLS_PREFIX)) {
+      const sub = cutIndexed(field.slice(LLM_MESSAGE_TOOL_CALLS_PREFIX.length));
+      if (sub?.[1].startsWith(LLM_TOOL_CALL_PREFIX)) {
+        call = [sub[0], sub[1].slice(LLM_TOOL_CALL_PREFIX.length)];
+      }
+    } else if (field.startsWith(LLM_MESSAGE_CONTENTS_PREFIX)) {
+      const sub = cutIndexed(field.slice(LLM_MESSAGE_CONTENTS_PREFIX.length));
+      if (sub?.[1].startsWith(LLM_MESSAGE_CONTENT_PREFIX)) {
+        item = [sub[0], sub[1].slice(LLM_MESSAGE_CONTENT_PREFIX.length)];
+      } else if (sub?.[1].startsWith(LLM_TOOL_CALL_PREFIX)) {
+        item = [sub[0], sub[1]];
+      }
+    }
+    if (call === void 0 && item === void 0 && field !== LLM_MESSAGE_ROLE && field !== LLM_MESSAGE_CONTENT && field !== LLM_MESSAGE_TOOL_CALL_ID) {
+      continue;
+    }
+    const value = attributes[key];
+    if (typeof value !== "string") return void 0;
+    let message = messages.get(index);
+    if (message === void 0) {
+      message = {
+        role: "",
+        content: void 0,
+        toolCallId: "",
+        toolCalls: /* @__PURE__ */ new Map(),
+        contents: /* @__PURE__ */ new Map()
+      };
+      messages.set(index, message);
+    }
+    if (call !== void 0) {
+      const fields = message.toolCalls.get(call[0]) ?? fieldRecord();
+      fields[call[1]] = value;
+      message.toolCalls.set(call[0], fields);
+    } else if (item !== void 0) {
+      const fields = message.contents.get(item[0]) ?? fieldRecord();
+      fields[item[1]] = value;
+      message.contents.set(item[0], fields);
+    } else if (field === LLM_MESSAGE_ROLE) {
+      message.role = value;
+    } else if (field === LLM_MESSAGE_TOOL_CALL_ID) {
+      message.toolCallId = value;
+    } else {
+      message.content = value;
+    }
+    consumed.push(key);
+  }
+  if (messages.size === 0) return void 0;
+  return { messages: byIndex(messages).map(encodeMessage), consumed };
+}
+function reassembleOpenInferenceMessages(attributes) {
+  const keys = Object.keys(attributes);
+  if (!keys.some((key) => MESSAGE_FAMILIES.some(([prefix]) => key.startsWith(prefix)))) {
+    return false;
+  }
+  const writes = [];
+  for (const [prefix, target] of MESSAGE_FAMILIES) {
+    if (Object.hasOwn(attributes, target) && attributes[target] !== void 0) continue;
+    const family = reassembleFamily(attributes, prefix);
+    if (family === void 0) continue;
+    writes.push({ target, value: toAttributeValue(family.messages), consumed: family.consumed });
+  }
+  for (const { target, value, consumed } of writes) {
+    for (const key of consumed) delete attributes[key];
+    attributes[target] = value;
+  }
+  return writes.length > 0;
+}
+function normalizeToolDefinitions(attributes) {
+  const native = attributes[GEN_AI_TOOL_DEFINITIONS] !== void 0;
+  const indexed = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(attributes)) {
+    if (!key.startsWith("llm.tools.")) continue;
+    const match = LLM_TOOL_SCHEMA.exec(key);
+    if (match !== null) indexed.set(Number(match[1]), key);
+  }
+  if (indexed.size > 0) {
+    const schemas = [];
+    for (const index of [...indexed.keys()].sort((a, b) => a - b)) {
+      const raw = attributes[indexed.get(index)];
+      if (typeof raw !== "string") return;
+      try {
+        schemas.push(JSON.parse(raw));
+      } catch {
+        return;
+      }
+    }
+    for (const key of indexed.values()) delete attributes[key];
+    if (!native) attributes[GEN_AI_TOOL_DEFINITIONS] = toAttributeValue(schemas);
+    return;
   }
-});
-
-// src/masking.ts
-function isContentKey(key) {
-  if (CONTENT_ATTRIBUTES.has(key)) return true;
-  if (CONTENT_ATTRIBUTE_PREFIXES.some((p) => key.startsWith(p))) return true;
-  if (CONTENT_ATTRIBUTE_SUFFIXES.some((s) => key.endsWith(s))) return true;
-  return key.startsWith(METADATA_PREFIX) && isContentKey(key.slice(METADATA_PREFIX.length));
+  const bag = attributes[LLM_INVOCATION_PARAMETERS];
+  if (typeof bag !== "string") return;
+  let payload;
+  try {
+    payload = JSON.parse(bag);
+  } catch {
+    return;
+  }
+  if (payload === null || typeof payload !== "object" || Array.isArray(payload)) return;
+  const members = payload;
+  const present = INVOCATION_PARAMETERS_CONTENT_MEMBERS.filter((m) => Object.hasOwn(members, m));
+  if (present.length === 0 || !present.every((m) => Array.isArray(members[m]))) return;
+  const definitions = present.flatMap((m) => members[m]);
+  const leftover = Object.fromEntries(
+    Object.entries(members).filter(([key]) => !present.includes(key))
+  );
+  if (Object.keys(leftover).length > 0) {
+    attributes[LLM_INVOCATION_PARAMETERS] = toAttributeValue(leftover);
+  } else {
+    delete attributes[LLM_INVOCATION_PARAMETERS];
+  }
+  if (!native) attributes[GEN_AI_TOOL_DEFINITIONS] = toAttributeValue(definitions);
+}
+function sortedCompactJson(value) {
+  if (typeof value === "string") return jsonString(value);
+  if (Array.isArray(value)) return `[${value.map(sortedCompactJson).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const record = value;
+    const members = Object.keys(record).sort(byCodePoint).map((k) => `${jsonString(k)}:${sortedCompactJson(record[k])}`);
+    return `{${members.join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function systemPart(block) {
+  if (block !== null && typeof block === "object" && !Array.isArray(block)) {
+    const record = block;
+    if (record.type === "text" && typeof record.text === "string") {
+      return { type: "text", content: record.text };
+    }
+  }
+  return { type: "text", content: sortedCompactJson(block) };
 }
-function redactInvocationParameters(value) {
-  if (typeof value !== "string") return void 0;
-  let parameters;
+function promoteSystemInstruction(attributes) {
+  const bag = attributes[LLM_INVOCATION_PARAMETERS];
+  if (typeof bag !== "string") return false;
+  let payload;
   try {
-    parameters = JSON.parse(value);
+    payload = JSON.parse(bag);
   } catch {
-    return void 0;
+    return false;
   }
-  if (parameters === null || typeof parameters !== "object" || Array.isArray(parameters)) {
-    return void 0;
+  if (payload === null || typeof payload !== "object" || Array.isArray(payload)) return false;
+  const members = payload;
+  if (!Object.hasOwn(members, "system")) return false;
+  const system = members.system;
+  let parts;
+  if (typeof system === "string" && system !== "") {
+    parts = [{ type: "text", content: system }];
+  } else if (Array.isArray(system) && system.length > 0) {
+    parts = system.map(systemPart);
+  } else {
+    return false;
+  }
+  let messages = [];
+  const existing = attributes[GEN_AI_INPUT_MESSAGES];
+  if (existing !== void 0) {
+    if (typeof existing !== "string") return false;
+    try {
+      const parsed = JSON.parse(existing);
+      if (!Array.isArray(parsed)) return false;
+      messages = parsed;
+    } catch {
+      return false;
+    }
+  }
+  if (messages.some((m) => m?.role === "system")) return false;
+  attributes[GEN_AI_INPUT_MESSAGES] = toAttributeValue([{ role: "system", parts }, ...messages]);
+  const leftover = Object.fromEntries(Object.entries(members).filter(([key]) => key !== "system"));
+  if (Object.keys(leftover).length > 0) {
+    attributes[LLM_INVOCATION_PARAMETERS] = toAttributeValue(leftover);
+  } else {
+    delete attributes[LLM_INVOCATION_PARAMETERS];
   }
-  const bag = parameters;
-  if (!INVOCATION_PARAMETERS_CONTENT_MEMBERS.some((member) => member in bag)) {
-    return value;
+  return true;
+}
+function dropEmbeddingVectors(attributes) {
+  const doomed = Object.keys(attributes).filter(
+    (key) => key.startsWith("embedding.") && EMBEDDING_VECTOR.test(key)
+  );
+  for (const key of doomed) delete attributes[key];
+}
+function responseIdFromOutput(attributes) {
+  if (attributes[OPENINFERENCE_SPAN_KIND] !== "LLM" /* LLM */) return {};
+  if (attributes[GEN_AI_RESPONSE_ID] !== void 0) return {};
+  const mime = attributes["output.mime_type"];
+  if (mime !== void 0 && mime !== "application/json") return {};
+  const output = attributes[OUTPUT_VALUE];
+  if (typeof output !== "string" || !output.startsWith("{")) return {};
+  let payload;
+  try {
+    payload = JSON.parse(output);
+  } catch {
+    return {};
   }
-  for (const member of INVOCATION_PARAMETERS_CONTENT_MEMBERS) delete bag[member];
-  return JSON.stringify(bag);
+  const id = payload.id;
+  return typeof id === "string" && id !== "" ? { [GEN_AI_RESPONSE_ID]: id } : {};
 }
-var import_api5, METADATA_PREFIX, EXCEPTION_EVENT_NAME, EXCEPTION_CONTENT_KEYS, STATUS_DESCRIPTION_KEY, MaskingSpanExporter;
-var init_masking = __esm({
-  "src/masking.ts"() {
+var import_api10, copy, toInt, wrapInList, PROVIDER_NAME_ALIASES, providerName, textValue, LONE_SURROGATE, INVOCATION_PARAMETER_MEMBERS, REQUEST_PARAMETER_GUARDS, TAXONOMY_RULES, OPENINFERENCE_RULES, NORMALIZATION_RULES, OPENINFERENCE_FIRST_TOKEN_EVENT, MESSAGE_FAMILIES, TOOL_CALL_FIELDS, INDEX, INT64_LIMIT, TOOL_USE_ITEM_FIELDS, LLM_TOOL_SCHEMA, EMBEDDING_VECTOR, NormalizingSpanProcessor;
+var init_normalize = __esm({
+  "src/normalize.ts"() {
     "use strict";
     init_cjs_shims();
-    import_api5 = require("@opentelemetry/api");
+    import_api10 = require("@opentelemetry/api");
+    init_errorType();
     init_semconv();
     init_serde();
-    METADATA_PREFIX = "metadata.";
-    EXCEPTION_EVENT_NAME = "exception";
-    EXCEPTION_CONTENT_KEYS = ["exception.message", "exception.stacktrace"];
-    STATUS_DESCRIPTION_KEY = "status.description";
-    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
-        );
+    copy = (values) => values[0];
+    toInt = (values) => {
+      const value = values[0];
+      if (typeof value === "number") return Number.isFinite(value) ? Math.trunc(value) : void 0;
+      if (typeof value !== "string") return void 0;
+      const parsed = Number.parseInt(value.trim(), 10);
+      return Number.isNaN(parsed) ? void 0 : parsed;
+    };
+    wrapInList = (values) => {
+      const value = values[0];
+      if (Array.isArray(value)) return value;
+      if (typeof value === "string") return [value];
+      if (typeof value === "number") return [value];
+      if (typeof value === "boolean") return [value];
+      return void 0;
+    };
+    PROVIDER_NAME_ALIASES = {
+      // OpenInference enum values
+      mistralai: "mistral_ai",
+      xai: "x_ai",
+      // legacy gen_ai.system values
+      vertex_ai: "gcp.vertex_ai",
+      gemini: "gcp.gemini",
+      "az.ai.inference": "azure.ai.inference",
+      "az.ai.openai": "azure.ai.openai"
+    };
+    providerName = (values) => {
+      const value = values[0];
+      if (typeof value !== "string") return void 0;
+      const key = value.trim().toLowerCase();
+      return Object.hasOwn(PROVIDER_NAME_ALIASES, key) ? PROVIDER_NAME_ALIASES[key] : value;
+    };
+    textValue = (values) => asText(values[0]);
+    LONE_SURROGATE = /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/g;
+    INVOCATION_PARAMETER_MEMBERS = [
+      // Every instrumentation but the anthropic one keeps `model` in the bag, and
+      // it is the literal request field — unlike llm.model_name, see the
+      // omissions below.
+      ["model", GEN_AI_REQUEST_MODEL, asText],
+      ["temperature", GEN_AI_REQUEST_TEMPERATURE, asNumber],
+      ["top_p", GEN_AI_REQUEST_TOP_P, asNumber],
+      ["top_k", GEN_AI_REQUEST_TOP_K, asCount],
+      ["max_tokens", GEN_AI_REQUEST_MAX_TOKENS, asCount],
+      // OpenAI's replacement for max_tokens on the reasoning models: "an upper
+      // bound for the number of tokens that can be generated for a completion",
+      // which is what gen_ai.request.max_tokens means. Listed second so a request
+      // carrying both keeps the one the provider would honour.
+      ["max_completion_tokens", GEN_AI_REQUEST_MAX_TOKENS, asCount],
+      ["frequency_penalty", GEN_AI_REQUEST_FREQUENCY_PENALTY, asNumber],
+      ["presence_penalty", GEN_AI_REQUEST_PRESENCE_PENALTY, asNumber],
+      ["seed", GEN_AI_REQUEST_SEED, asCount],
+      ["n", GEN_AI_REQUEST_CHOICE_COUNT, asCount],
+      ["stop", GEN_AI_REQUEST_STOP_SEQUENCES, asTextList],
+      ["stop_sequences", GEN_AI_REQUEST_STOP_SEQUENCES, asTextList],
+      ["stream", GEN_AI_REQUEST_STREAM, asFlag],
+      // Not a convention key: the GenAI conventions define no tool_choice, so it
+      // goes where an unnamed request parameter goes, rius.request.*. Promoted
+      // because context attribution reads it to tell a forced tool call from an
+      // automatic one, and the bag is content: left inside, it goes wherever
+      // masking sends the bag. It is a routing parameter, not content, and this
+      // runs before masking.
+      ["tool_choice", RIUS_REQUEST_TOOL_CHOICE, asToolChoice]
+    ];
+    REQUEST_PARAMETER_GUARDS = {
+      [GEN_AI_REQUEST_MODEL]: asText,
+      // string
+      [GEN_AI_REQUEST_MAX_TOKENS]: asCount,
+      // int
+      [GEN_AI_REQUEST_CHOICE_COUNT]: asCount,
+      // int
+      [GEN_AI_REQUEST_TEMPERATURE]: asNumber,
+      // double
+      [GEN_AI_REQUEST_TOP_P]: asNumber,
+      // double
+      [GEN_AI_REQUEST_TOP_K]: asCount,
+      // int
+      [GEN_AI_REQUEST_STOP_SEQUENCES]: asTextList,
+      // string[]
+      [GEN_AI_REQUEST_FREQUENCY_PENALTY]: asNumber,
+      // double
+      [GEN_AI_REQUEST_PRESENCE_PENALTY]: asNumber,
+      // double
+      [GEN_AI_REQUEST_ENCODING_FORMATS]: asTextList,
+      // string[]
+      [GEN_AI_REQUEST_SEED]: asCount,
+      // int
+      [GEN_AI_REQUEST_STREAM]: asFlag,
+      // boolean
+      [GEN_AI_REQUEST_REASONING_LEVEL]: asText,
+      // string
+      [GEN_AI_REQUEST_PREVIOUS_RESPONSE_ID]: asText,
+      // string
+      [GEN_AI_REQUEST_STREAM_CURSOR]: asText
+      // string
+    };
+    TAXONOMY_RULES = [
+      { source: OPENINFERENCE_SPAN_KIND, expand: taxonomyFromKind, identity: true },
+      { source: GEN_AI_OPERATION_NAME, expand: taxonomyFromOperation, identity: true }
+    ];
+    OPENINFERENCE_RULES = [
+      // Provider. One rule, two spellings, first present wins: llm.provider is
+      // OpenInference's and the more specific (azure/aws/google rather than the
+      // product), gen_ai.system is the deprecated GenAI key, which is mapped here
+      // and never emitted. That is why gen_ai.system is spelled inline rather
+      // than in semconv.ts: that module is the set of keys we EMIT.
+      {
+        source: ["llm.provider", "gen_ai.system"],
+        target: GEN_AI_PROVIDER_NAME,
+        convert: providerName,
+        identity: true
+      },
+      // Model. Only the anthropic instrumentation emits this unambiguous pair;
+      // see the omission note on llm.model_name.
+      {
+        source: "llm.request.model_name",
+        target: GEN_AI_REQUEST_MODEL,
+        convert: copy,
+        identity: true
+      },
+      { source: "llm.response.model_name", target: GEN_AI_RESPONSE_MODEL, convert: copy },
+      // Tool identity. OpenInference writes the bare key only on TOOL spans (on an
+      // LLM span the same name sits under llm.tools.N.tool.name instead), so the
+      // rule needs no kind guard. Identity, so it also runs at start and a
+      // still-running third-party tool call is named on its pending snapshot, as
+      // a native one is.
+      //
+      // Deliberately NO fallback to the span name. The native path stopped
+      // deriving the tool name from the span name because a span name is not a
+      // tool name, and a wrong name silently groups unrelated calls, which is
+      // worse than an absent one. A third-party span offers no better guarantee.
+      { source: "tool.name", target: GEN_AI_TOOL_NAME, convert: textValue, identity: true },
+      // Why the model stopped. The source is a SCALAR and the canonical key is an
+      // array (one entry per generation), so wrap rather than copy.
+      //
+      // Known limit: the source only ever holds ONE generation's reason. The
+      // OpenInference OpenAI instrumentation reads choices[0].finish_reason on a
+      // completed response, and whichever choice finished last on a stream. With
+      // n > 1 the array therefore has one entry, not n: a request whose choices
+      // finish ["stop", "length", "stop"] records ["stop"], and nothing on the span
+      // says the list is short. Accepted rather than skipped: n > 1 is rare in
+      // agent code, and the first reason is still the most useful single fact.
+      //
+      // The VALUE is passed through untouched, deliberately. The registry defines
+      // this key as a free-form string array with no enum, and says
+      // instrumentations report whatever the provider supplied. The JS
+      // instrumentations already do: they emit the provider's value verbatim.
+      // OpenInference's PYTHON conversion layer is what lowercases and folds
+      // tool_calls/function_call into tool_call; following it would replace the
+      // string OpenAI actually returned with one neither the provider nor the
+      // conventions use, while leaving Anthropic's end_turn and tool_use alone, so
+      // it would cost fidelity and unify nothing. Grouping "stop" with "end_turn"
+      // is a question for a reader who still has both, not for the SDK that would
+      // destroy one of them. The native path (Generation.setFinishReasons) records
+      // verbatim too, so both paths agree.
+      { source: "llm.finish_reason", target: GEN_AI_RESPONSE_FINISH_REASONS, convert: wrapInList },
+      // Usage. toInt rather than copy: a count under a canonical key must be a
+      // count, and a converter that yields nothing is how a wrongly-shaped value
+      // stays off the wire.
+      { source: "llm.token_count.prompt", target: GEN_AI_USAGE_INPUT_TOKENS, convert: toInt },
+      { source: "llm.token_count.completion", target: GEN_AI_USAGE_OUTPUT_TOKENS, convert: toInt },
+      {
+        source: "llm.token_count.prompt_details.cache_read",
+        target: GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS,
+        convert: toInt
+      },
+      {
+        source: "llm.token_count.prompt_details.cache_write",
+        target: GEN_AI_USAGE_CACHE_WRITE_INPUT_TOKENS,
+        convert: toInt
+      },
+      {
+        source: "llm.token_count.completion_details.reasoning",
+        target: GEN_AI_USAGE_REASONING_OUTPUT_TOKENS,
+        convert: toInt
+      },
+      // Two GenAI-shaped spellings of the same counts, each its own rule AFTER
+      // the OpenInference one for its target: the OpenInference count keeps the
+      // target where a span somehow carries both, and a separate rule rather than
+      // a second source means an OpenInference count that won't parse still lets
+      // a usable alternate through (a rule converts only its first present
+      // source). Spelled inline for the reason gen_ai.system is: source spellings
+      // we map and never emit.
+      //
+      // cache_creation is the cache-write count's name before the upstream rename
+      // to cache_write. Permanent, not a transition aid: current third-party
+      // releases still emit it (@ai-sdk/otel for every Vercel AI SDK app, and
+      // pydantic-ai), and the backend prices cache writes from the canonical key
+      // alone. The rename is exact, so nothing is lost.
+      {
+        source: "gen_ai.usage.cache_creation.input_tokens",
+        target: GEN_AI_USAGE_CACHE_WRITE_INPUT_TOKENS,
+        convert: toInt
+      },
+      // pydantic-ai writes OpenAI's reasoning count as one entry of its usage
+      // details namespace. The other providers' names there for the same split
+      // (Anthropic's thinking_tokens, Google's thoughts_tokens) are not mapped,
+      // matching the sink; the rest of the namespace has no canonical key.
+      {
+        source: "gen_ai.usage.details.reasoning_tokens",
+        target: GEN_AI_USAGE_REASONING_OUTPUT_TOKENS,
+        convert: toInt
+      },
+      // The request bag, last: the dedicated model rules above take precedence
+      // over its `model` member. Identity, because what it promotes is.
+      { source: LLM_INVOCATION_PARAMETERS, expand: invocationParameters, identity: true },
+      // The embedding model: OpenInference's EMBEDDING spans name it here. A
+      // non-empty string only, like the tool name. LAST, as in the Python SDK, so
+      // it only fills the key when no LLM spelling above produced one. Identity,
+      // as the request model is, so a pending embedding span is classifiable.
+      {
+        source: "embedding.model_name",
+        target: GEN_AI_REQUEST_MODEL,
+        convert: textValue,
+        identity: true
       }
-      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);
-        }
-        this.sanitizeStatus(span);
-        return span;
+    ];
+    NORMALIZATION_RULES = [
+      ...TAXONOMY_RULES,
+      ...OPENINFERENCE_RULES
+    ];
+    OPENINFERENCE_FIRST_TOKEN_EVENT = "First Token Stream Event";
+    MESSAGE_FAMILIES = [
+      [LLM_INPUT_MESSAGES_PREFIX, GEN_AI_INPUT_MESSAGES],
+      [LLM_OUTPUT_MESSAGES_PREFIX, GEN_AI_OUTPUT_MESSAGES]
+    ];
+    TOOL_CALL_FIELDS = [
+      [LLM_TOOL_CALL_ID, "id"],
+      [LLM_TOOL_CALL_FUNCTION_NAME, "name"],
+      [LLM_TOOL_CALL_FUNCTION_ARGUMENTS, "arguments"]
+    ];
+    INDEX = /^[+-]?[0-9]+$/;
+    INT64_LIMIT = 2n ** 63n;
+    TOOL_USE_ITEM_FIELDS = new Map(
+      TOOL_CALL_FIELDS.map(([field]) => [`${LLM_TOOL_CALL_PREFIX}${field}`, field])
+    );
+    LLM_TOOL_SCHEMA = /^llm\.tools\.([0-9]+)\.tool\.json_schema$/;
+    EMBEDDING_VECTOR = /^embedding\.embeddings\.[0-9]+\.embedding\.vector$/;
+    NormalizingSpanProcessor = class {
+      rules;
+      identityRules;
+      prefixes;
+      constructor(rules = NORMALIZATION_RULES) {
+        this.rules = rules;
+        this.identityRules = rules.filter((rule) => rule.identity === true);
+        this.prefixes = sourcePrefixes(rules);
       }
-      /**
-       * Drops or masks the status description, in place. `status` is mutable and
-       * exposed by reference on the SDK span, same as `attributes`, so mutating it
-       * here reaches the span about to be handed to the inner exporter. The ERROR
-       * code itself is left alone so the failure stays visible and classifiable,
-       * the same policy as `exception.type`.
-       */
-      sanitizeStatus(span) {
-        const status = span.status;
-        if (status?.code !== import_api5.SpanStatusCode.ERROR || !status.message) return;
-        if (!this.opts.captureContent) {
-          status.message = void 0;
-          return;
-        }
-        if (this.opts.mask === void 0) return;
-        try {
-          const masked = toAttributeValue(
-            this.opts.mask(status.message, { key: STATUS_DESCRIPTION_KEY })
-          );
-          status.message = typeof masked === "string" ? masked : String(masked);
-        } catch {
-          status.message = "[mask error]";
-        }
+      onStart(span, _parentContext) {
+        this.normalize(
+          span.attributes,
+          this.identityRules,
+          (key, value) => span.setAttribute(key, value)
+        );
+        qualifyRecordedExceptions(span);
       }
-      /** Strips or masks the content keys of one attribute bag, in place. */
-      sanitizeAttributes(attributes) {
-        if (attributes === void 0) return;
-        const sanitizing = !this.opts.captureContent || this.opts.mask !== void 0;
-        if (sanitizing && LLM_INVOCATION_PARAMETERS in attributes) {
-          const redacted = redactInvocationParameters(attributes[LLM_INVOCATION_PARAMETERS]);
-          if (redacted === void 0) delete attributes[LLM_INVOCATION_PARAMETERS];
-          else attributes[LLM_INVOCATION_PARAMETERS] = redacted;
+      onEnd(span) {
+        const attributes = span.attributes;
+        this.normalize(attributes, this.rules, (key, value) => {
+          attributes[key] = value;
+        });
+        normalizeToolDefinitions(attributes);
+        dropEmbeddingVectors(attributes);
+        for (const [key, value] of Object.entries({
+          ...normalizeFirstTokenEvent(span),
+          ...errorTypeFromExceptionEvent(span),
+          ...responseIdFromOutput(attributes)
+        })) {
+          if (attributes[key] === void 0) attributes[key] = value;
         }
-        for (const key of Object.keys(attributes)) {
-          if (!isContentKey(key)) continue;
-          if (!this.opts.captureContent) {
-            delete attributes[key];
-            continue;
+        reassembleOpenInferenceMessages(attributes);
+        promoteSystemInstruction(attributes);
+      }
+      normalize(attributes, rules, write) {
+        if (rules.length === 0) return;
+        const bag = attributes;
+        const keys = Object.keys(bag);
+        if (!keys.some((key) => this.prefixes.some((prefix) => key.startsWith(prefix)))) return;
+        const staged = { ...bag };
+        const { mapped, rewritten } = applyRules(staged, rules);
+        const rewrote = new Set(rewritten);
+        for (const key of Object.keys(staged)) {
+          if (staged[key] === void 0) continue;
+          if (bag[key] === void 0 || rewrote.has(key) && bag[key] !== staged[key]) {
+            write(key, staged[key]);
           }
-          if (this.opts.mask === void 0) continue;
-          try {
-            attributes[key] = toAttributeValue(this.opts.mask(attributes[key], { key }));
-          } catch {
-            attributes[key] = "[mask error]";
+        }
+        for (const { sources, targets } of mapped) {
+          if (targets.every((key) => bag[key] !== void 0)) {
+            for (const key of sources) delete bag[key];
           }
         }
       }
-      shutdown() {
-        return this.inner.shutdown();
+      async forceFlush() {
       }
-      forceFlush() {
-        return this.inner.forceFlush?.() ?? Promise.resolve();
+      async shutdown() {
       }
     };
   }
@@ -1223,7 +2928,7 @@ function identityAttributes(attributes) {
 }
 function buildSnapshot(span) {
   const attributes = identityAttributes(span.attributes);
-  attributes[GLASSFLOW_SPAN_PENDING] = true;
+  attributes[RIUS_SPAN_PENDING] = true;
   return {
     name: span.name,
     kind: span.kind,
@@ -1232,7 +2937,7 @@ function buildSnapshot(span) {
     startTime: span.startTime,
     endTime: span.startTime,
     duration: [0, 0],
-    status: { code: import_api6.SpanStatusCode.UNSET },
+    status: { code: import_api11.SpanStatusCode.UNSET },
     attributes,
     links: [],
     events: [],
@@ -1247,12 +2952,12 @@ function buildSnapshot(span) {
 function spanKey(context2) {
   return `${context2.traceId}:${context2.spanId}`;
 }
-var import_api6, PendingSpanProcessor;
+var import_api11, PendingSpanProcessor;
 var init_pending = __esm({
   "src/pending.ts"() {
     "use strict";
     init_cjs_shims();
-    import_api6 = require("@opentelemetry/api");
+    import_api11 = require("@opentelemetry/api");
     init_semconv();
     PendingSpanProcessor = class {
       delegate;
@@ -1300,17 +3005,18 @@ var init_pending = __esm({
 // src/session.ts
 function withSession(sessionIdOrFn, maybeFn) {
   const [sessionId, fn] = typeof sessionIdOrFn === "function" ? [(0, import_node_crypto.randomUUID)(), sessionIdOrFn] : [sessionIdOrFn, maybeFn];
-  return import_api7.context.with(import_api7.context.active().setValue(SESSION_KEY, sessionId), () => fn(sessionId));
+  return import_api12.context.with(import_api12.context.active().setValue(SESSION_KEY, sessionId), () => fn(sessionId));
 }
-var import_node_crypto, import_api7, SESSION_KEY, SessionSpanProcessor;
+var import_node_crypto, import_api12, SESSION_KEY, SessionSpanProcessor;
 var init_session = __esm({
   "src/session.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_crypto = require("crypto");
-    import_api7 = require("@opentelemetry/api");
+    import_api12 = require("@opentelemetry/api");
+    init_foreign();
     init_semconv();
-    SESSION_KEY = (0, import_api7.createContextKey)("rius-session-id");
+    SESSION_KEY = (0, import_api12.createContextKey)("rius-session-id");
     SessionSpanProcessor = class {
       constructor(defaultSessionId) {
         this.defaultSessionId = defaultSessionId;
@@ -1318,7 +3024,7 @@ var init_session = __esm({
       defaultSessionId;
       onStart(span, parentContext) {
         const value = parentContext.getValue(SESSION_KEY);
-        const parent = import_api7.trace.getSpan(parentContext);
+        const parent = twinOf(import_api12.trace.getSpan(parentContext));
         const inherited = parent?.attributes?.[SESSION_ID];
         const sessionId = typeof value === "string" ? value : typeof inherited === "string" ? inherited : this.defaultSessionId;
         if (sessionId !== void 0) span.setAttribute(SESSION_ID, sessionId);
@@ -1336,7 +3042,7 @@ var init_session = __esm({
 // src/workspace.ts
 function withWorkspace(alias, fn) {
   if (!alias) throw new Error("workspace alias must be a non-empty string");
-  return import_api8.context.with(import_api8.context.active().setValue(WORKSPACE_KEY, alias), () => fn(alias));
+  return import_api13.context.with(import_api13.context.active().setValue(WORKSPACE_KEY, alias), () => fn(alias));
 }
 function setGlobalRouting(routing) {
   globalRouting = routing;
@@ -1349,20 +3055,21 @@ function registerWorkspace(alias, apiKey) {
   }
   globalRouting.register(alias, apiKey);
 }
-var import_api8, WORKSPACE_KEY, WorkspaceSpanProcessor, RoutingSpanExporter, globalRouting;
+var import_api13, WORKSPACE_KEY, WorkspaceSpanProcessor, RoutingSpanExporter, globalRouting;
 var init_workspace = __esm({
   "src/workspace.ts"() {
     "use strict";
     init_cjs_shims();
-    import_api8 = require("@opentelemetry/api");
+    import_api13 = require("@opentelemetry/api");
     init_esm();
+    init_foreign();
     init_semconv();
-    WORKSPACE_KEY = (0, import_api8.createContextKey)("rius-workspace-alias");
+    WORKSPACE_KEY = (0, import_api13.createContextKey)("rius-workspace-alias");
     WorkspaceSpanProcessor = class {
       /** Straddles already warned about, as "parentAlias->alias"; one warning each, not one per span. */
       warnedStraddles = /* @__PURE__ */ new Set();
       onStart(span, parentContext) {
-        const parent = import_api8.trace.getSpan(parentContext);
+        const parent = twinOf(import_api13.trace.getSpan(parentContext));
         const parentAlias = parent?.attributes?.[WORKSPACE_ROUTE];
         const scoped = parentContext.getValue(WORKSPACE_KEY);
         const alias = typeof scoped === "string" ? scoped : parentAlias;
@@ -1463,6 +3170,19 @@ var init_workspace = __esm({
 });
 
 // src/client.ts
+function resolveSpanLimits() {
+  const fromEnv = (names) => {
+    for (const name of names) {
+      const value = getNumberFromEnv(name);
+      if (value !== void 0) return value;
+    }
+    return void 0;
+  };
+  return {
+    attributeCountLimit: fromEnv(ATTRIBUTE_COUNT_LIMIT_ENV) ?? DEFAULT_SPAN_ATTRIBUTE_COUNT_LIMIT,
+    attributeValueLengthLimit: fromEnv(ATTRIBUTE_VALUE_LENGTH_LIMIT_ENV) ?? Number.POSITIVE_INFINITY
+  };
+}
 function init(options = {}) {
   if (globalClient !== void 0) {
     console.warn(
@@ -1472,9 +3192,59 @@ function init(options = {}) {
   }
   const config = resolveConfig(options);
   const processors = new DelegatingSpanProcessor();
+  const foreignGlobal = foreignGlobalProviderName();
+  const instanceId = (0, import_node_crypto2.randomUUID)();
+  const resource = (0, import_resources2.resourceFromAttributes)({
+    [import_semantic_conventions2.ATTR_SERVICE_NAME]: config.serviceName,
+    [SERVICE_INSTANCE_ID]: instanceId,
+    // The agent name the heartbeats already carry. Without it here, spans
+    // fall back to service.name downstream while heartbeats group under the
+    // agent name, so a process that configures the two differently sees its
+    // agents view and its trace list disagree. Resolution defaults the agent
+    // name to the service name, so nothing changes when they are the same.
+    [GEN_AI_AGENT_NAME]: config.agentName,
+    // The same fact in our own namespace, and the one the sink reads first.
+    // `gen_ai.agent.name` above is kept ADDITIVELY and on purpose: it has no
+    // resource-level meaning in the conventions and on a span it names the
+    // agent being INVOKED, so it was one key answering two questions — but
+    // dropping it here would be a flag day, blanking agent identity for
+    // every deployment sitting between this SDK release and the sink
+    // release. A resource rides once per OTLP batch, not once per span, so
+    // carrying both costs essentially nothing.
+    //
+    // Spread like `service.version` below, for the same reason: a process
+    // that named nothing resolves to the `unknown_service` placeholder, and
+    // the main-agent name must then be ABSENT rather than claim an identity
+    // the caller never gave — exactly what the span helpers already do.
+    ...config.mainAgentName === void 0 ? {} : { [RIUS_MAIN_AGENT_NAME]: config.mainAgentName },
+    // Optional and never defaulted; see config.ts. `service.instance.id`
+    // above is the process identity, these describe the AGENT the process
+    // runs, which outlives any one process.
+    ...config.mainAgentId === void 0 ? {} : { [RIUS_MAIN_AGENT_ID]: config.mainAgentId },
+    ...config.mainAgentDescription === void 0 ? {} : { [RIUS_MAIN_AGENT_DESCRIPTION]: config.mainAgentDescription },
+    // The version of the AGENT DEFINITION, never derived from (nor deriving)
+    // `service.version` below: the build and the prompt/tools/policy it runs
+    // move independently.
+    ...config.mainAgentVersion === void 0 ? {} : { [RIUS_MAIN_AGENT_VERSION]: config.mainAgentVersion },
+    // `foreign:<Class>` when another SDK already held the OpenTelemetry global
+    // at init(); absent when Rius registered it. Spread, because the ABSENCE of
+    // the key is what says "Rius owns the global here" — a placeholder value
+    // would make every ordinary process look like a resolved conflict.
+    ...foreignGlobal === void 0 ? {} : { [RIUS_SDK_GLOBAL_PROVIDER]: `foreign:${foreignGlobal}` },
+    "telemetry.distro.name": "glassflow-rius",
+    "telemetry.distro.version": SDK_VERSION,
+    // Spread rather than assigned so an unresolved version leaves the key
+    // OFF the resource entirely. `resourceFromAttributes` keeps an explicit
+    // `undefined` as a raw attribute, and there is no placeholder to fall
+    // back on by design: `service.name`'s `unknown_service` is the standing
+    // argument against inventing one, since every unversioned process would
+    // then claim the same fake version.
+    ...config.serviceVersion === void 0 ? {} : { [import_semantic_conventions2.ATTR_SERVICE_VERSION]: config.serviceVersion }
+  });
   const authHeaders = config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {};
   let health;
   let routing;
+  let detector;
   if (!config.disabled) {
     let base = options.spanExporter ?? new import_exporter_trace_otlp_proto.OTLPTraceExporter({
       url: `${config.endpoint}/v1/traces`,
@@ -1493,7 +3263,11 @@ function init(options = {}) {
       captureContent: config.captureContent,
       mask: config.mask
     }) : health;
-    const batch = new import_sdk_trace_base.BatchSpanProcessor(exporter);
+    const adopting = new ResourceAdoptingExporter(exporter, resource);
+    const batch = new import_sdk_trace_base2.BatchSpanProcessor(adopting);
+    detector = new ForeignParentDetector(foreignGlobal);
+    processors.add(detector);
+    processors.add(new NormalizingSpanProcessor());
     processors.add(new SessionSpanProcessor(config.sessionId));
     processors.add(new UserSpanProcessor());
     if (routing !== void 0) {
@@ -1504,27 +3278,31 @@ function init(options = {}) {
     }
     processors.add(batch);
   }
-  const instanceId = (0, import_node_crypto2.randomUUID)();
+  const sampler = new BridgeAwareSampler(
+    new import_sdk_trace_base2.ParentBasedSampler({ root: new import_sdk_trace_base2.TraceIdRatioBasedSampler(config.sampleRate) })
+  );
+  const spanLimits = resolveSpanLimits();
   const provider = new import_sdk_trace_node.NodeTracerProvider({
-    // telemetry.sdk.* is reserved for the OTel SDK itself; we identify as a
-    // distribution via telemetry.distro.*, the same two keys Python stamps.
-    resource: (0, import_resources.resourceFromAttributes)({
-      [import_semantic_conventions.ATTR_SERVICE_NAME]: config.serviceName,
-      [SERVICE_INSTANCE_ID]: instanceId,
-      "telemetry.distro.name": "glassflow-rius",
-      "telemetry.distro.version": SDK_VERSION
-    }),
+    resource,
     // 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) }),
+    // Wrapped because ParentBased follows the PARENT's sampled flag, and a
+    // bridged parent's flag is the other SDK's decision (usually always-on),
+    // which would ship every trace it touches whatever sampleRate says.
+    sampler,
+    // Already resolved against the environment; see resolveSpanLimits().
+    spanLimits,
     spanProcessors: [processors]
   });
   const teardown = [];
   const ready = config.disabled ? Promise.resolve([]) : enableInstrumentations(processors, provider, void 0, teardown);
+  rememberOwnProvider(provider);
+  ownTracerProvider = provider;
   provider.register();
+  const bridged = config.disabled ? void 0 : bridgeOrWarn(provider, processors, sampler, spanLimits, config.bridgeForeignProvider);
   let heartbeat;
   const heartbeatCanAuthenticate = config.apiKey !== void 0 || options.heartbeatTransport !== void 0;
   if (config.heartbeat && !config.disabled && heartbeatCanAuthenticate) {
@@ -1537,7 +3315,8 @@ function init(options = {}) {
       agentName: config.agentName,
       instanceId,
       tracker,
-      transport: options.heartbeatTransport
+      transport: options.heartbeatTransport,
+      foreignParentSpans: detector === void 0 ? void 0 : () => detector.count
     });
     sender.start();
     const beforeExitHandler = () => {
@@ -1546,31 +3325,63 @@ function init(options = {}) {
     process.once("beforeExit", beforeExitHandler);
     heartbeat = { sender, beforeExitHandler };
   }
-  globalClient = createClient({ provider, processors, health, ready, teardown, heartbeat });
+  globalClient = createClient({
+    provider,
+    processors,
+    health,
+    ready,
+    teardown,
+    heartbeat,
+    bridge: bridged
+  });
   setGlobalRouting(routing);
+  setConfiguredAgentName(config.agentName);
   return globalClient;
 }
+function bridgeOrWarn(own, pipeline, sampler, spanLimits, bridgeForeignProvider) {
+  const existing = globalTracerProvider();
+  if (existing === void 0 || existing === own) return void 0;
+  const foreignGlobal = existing.constructor?.name || "unknown";
+  if (bridgeForeignProvider) {
+    const attached = bridge(existing, pipeline, sampler, spanLimits);
+    if (attached !== void 0) {
+      console.info(
+        `[rius] the OpenTelemetry global tracer provider was already set (${foreignGlobal}); Rius attached its span pipeline to it, so spans started through it are exported to Rius too.`
+      );
+      return attached;
+    }
+  }
+  const why = bridgeForeignProvider ? "it takes no additional span processor" : "bridgeForeignProvider is off";
+  console.warn(
+    `[rius] could not register the Rius tracer provider as the OpenTelemetry global (${foreignGlobal} is already set, or a previous init() claimed it), and Rius is not attached to it (${why}). Rius' own helpers (observe, startSpan, generations) follow this client regardless; third-party code using trace.getTracer() keeps the pre-existing provider, and LLM spans started inside its spans arrive without their parent. Set RIUS_BRIDGE_FOREIGN_PROVIDER=true or init({ bridgeForeignProvider: true }) to send that provider's spans to Rius as well.`
+  );
+  return void 0;
+}
 function getTracer() {
-  return import_api9.trace.getTracer(TRACER_NAME, SDK_VERSION);
+  return (ownTracerProvider ?? import_api14.trace).getTracer(TRACER_NAME, SDK_VERSION);
 }
-var import_node_crypto2, import_api9, import_exporter_trace_otlp_proto, import_resources, import_sdk_trace_base, import_sdk_trace_node, import_semantic_conventions, sinks, heartbeats, createClient, RiusClient, globalClient;
+var import_node_crypto2, import_api14, import_exporter_trace_otlp_proto, import_resources2, import_sdk_trace_base2, import_sdk_trace_node, import_semantic_conventions2, sinks, heartbeats, bridges, createClient, RiusClient, globalClient, DEFAULT_SPAN_ATTRIBUTE_COUNT_LIMIT, ATTRIBUTE_COUNT_LIMIT_ENV, ATTRIBUTE_VALUE_LENGTH_LIMIT_ENV, ownTracerProvider;
 var init_client = __esm({
   "src/client.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_crypto2 = require("crypto");
-    import_api9 = require("@opentelemetry/api");
+    import_api14 = require("@opentelemetry/api");
+    init_esm();
     import_exporter_trace_otlp_proto = require("@opentelemetry/exporter-trace-otlp-proto");
-    import_resources = require("@opentelemetry/resources");
-    import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+    import_resources2 = require("@opentelemetry/resources");
+    import_sdk_trace_base2 = require("@opentelemetry/sdk-trace-base");
     import_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
-    import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+    import_semantic_conventions2 = require("@opentelemetry/semantic-conventions");
+    init_agent();
     init_config();
     init_delegatingProcessor();
     init_exportHealth();
+    init_foreign();
     init_heartbeat();
     init_instrumentation();
     init_masking();
+    init_normalize();
     init_pending();
     init_semconv();
     init_session();
@@ -1579,6 +3390,7 @@ var init_client = __esm({
     init_workspace();
     sinks = /* @__PURE__ */ new WeakMap();
     heartbeats = /* @__PURE__ */ new WeakMap();
+    bridges = /* @__PURE__ */ new WeakMap();
     RiusClient = class _RiusClient {
       provider;
       health;
@@ -1592,6 +3404,7 @@ var init_client = __esm({
         this.teardown = parts.teardown;
         sinks.set(this, parts.processors);
         if (parts.heartbeat) heartbeats.set(this, parts.heartbeat);
+        if (parts.bridge) bridges.set(this, parts.bridge);
       }
       static {
         createClient = (parts) => new _RiusClient(parts);
@@ -1624,19 +3437,28 @@ var init_client = __esm({
           } catch {
           }
         }
+        bridges.get(this)?.release();
         try {
           await this.provider.shutdown();
         } finally {
           if (globalClient === this) {
             globalClient = void 0;
+            ownTracerProvider = void 0;
             setGlobalRouting(void 0);
-            import_api9.trace.disable();
-            import_api9.context.disable();
-            import_api9.propagation.disable();
+            setConfiguredAgentName(void 0);
+            import_api14.trace.disable();
+            import_api14.context.disable();
+            import_api14.propagation.disable();
           }
         }
       }
     };
+    DEFAULT_SPAN_ATTRIBUTE_COUNT_LIMIT = 4096;
+    ATTRIBUTE_COUNT_LIMIT_ENV = ["OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT", "OTEL_ATTRIBUTE_COUNT_LIMIT"];
+    ATTRIBUTE_VALUE_LENGTH_LIMIT_ENV = [
+      "OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT",
+      "OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT"
+    ];
   }
 });
 
@@ -1668,30 +3490,185 @@ init_client();
 init_cjs_shims();
 init_client();
 
+// src/contextSizes.ts
+init_cjs_shims();
+var DETAIL_WINDOW = 50;
+var MAX_SIZES_BYTES = 8192;
+var SIZES_VERSION = 1;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function canonicalBytes(value) {
+  try {
+    const text = JSON.stringify(value);
+    return text === void 0 ? 0 : Buffer.byteLength(text);
+  } catch {
+    return 0;
+  }
+}
+function toolName(tool) {
+  if (!isRecord(tool)) return null;
+  const fn = tool.function;
+  if (isRecord(fn) && typeof fn.name === "string") return fn.name;
+  return typeof tool.name === "string" ? tool.name : null;
+}
+function asToolName(name) {
+  return typeof name === "string" ? name : null;
+}
+function partsOf(message) {
+  if (!isRecord(message)) return [];
+  return Array.isArray(message.parts) ? message.parts : [];
+}
+function toolKey(name) {
+  return name === null ? "\0null" : `name:${name}`;
+}
+var Context = class {
+  callNames = /* @__PURE__ */ new Map();
+  constructor(messageLists) {
+    for (const messages of messageLists) {
+      for (const message of messages) {
+        for (const part of partsOf(message)) {
+          if (isRecord(part) && part.type === "tool_call" && typeof part.id === "string" && !this.callNames.has(part.id)) {
+            this.callNames.set(part.id, part.name);
+          }
+        }
+      }
+    }
+  }
+  partEntry(part) {
+    if (!isRecord(part)) return { type: "unknown" };
+    switch (part.type) {
+      case "text": {
+        const content = part.content ?? null;
+        const bytes = typeof content === "string" ? Buffer.byteLength(content) : canonicalBytes(content);
+        return { type: "text", bytes };
+      }
+      case "tool_call":
+        return { type: "tool_call", tool: asToolName(part.name), bytes: canonicalBytes(part) };
+      case "tool_call_response": {
+        const name = typeof part.id === "string" ? this.callNames.get(part.id) : void 0;
+        return { type: "tool_call_response", tool: asToolName(name), bytes: canonicalBytes(part) };
+      }
+      default:
+        return { type: typeof part.type === "string" ? part.type : "unknown" };
+    }
+  }
+  messageEntry(message) {
+    const role = isRecord(message) ? message.role : void 0;
+    return {
+      role: typeof role === "string" ? role : String(role),
+      parts: partsOf(message).map((part) => this.partEntry(part))
+    };
+  }
+};
+function hasCacheMarker(message) {
+  return partsOf(message).some(
+    (part) => isRecord(part) && part.cache_control !== void 0 && part.cache_control !== null
+  );
+}
+function fold(entries) {
+  let system = 0;
+  let user = 0;
+  let assistant = 0;
+  let multimodal = 0;
+  const tools = /* @__PURE__ */ new Map();
+  for (const { role, parts } of entries) {
+    for (const part of parts) {
+      if (!("bytes" in part)) {
+        multimodal += 1;
+      } else if (part.type === "text") {
+        if (role === "system" || role === "developer") system += part.bytes;
+        else if (role === "assistant") assistant += part.bytes;
+        else user += part.bytes;
+      } else if ("tool" in part) {
+        const key = toolKey(part.tool);
+        const sum = tools.get(key);
+        if (sum) sum.bytes += part.bytes;
+        else tools.set(key, { tool: part.tool, bytes: part.bytes });
+      }
+    }
+  }
+  const result = { messages: entries.length };
+  if (system > 0) result.system_bytes = system;
+  if (user > 0) result.user_bytes = user;
+  if (assistant > 0) result.assistant_bytes = assistant;
+  if (tools.size > 0) result.tools = [...tools.values()];
+  if (multimodal > 0) result.multimodal_parts = multimodal;
+  return result;
+}
+function assemble(toolEntries, inputEntries, outputEntries, cacheIndex, window) {
+  const sizes = { version: SIZES_VERSION };
+  if (toolEntries !== void 0) sizes.tool_definitions = toolEntries;
+  let folded;
+  if (inputEntries !== void 0) {
+    const excess = inputEntries.length - window;
+    if (excess > 0) {
+      folded = fold(inputEntries.slice(0, excess));
+      sizes.input_messages = inputEntries.slice(excess);
+    } else {
+      sizes.input_messages = inputEntries;
+    }
+  }
+  if (outputEntries !== void 0) sizes.output_messages = outputEntries;
+  if (cacheIndex !== void 0) sizes.cache_marker = cacheIndex;
+  if (folded !== void 0) sizes.folded = folded;
+  return sizes;
+}
+function asList(value) {
+  return Array.isArray(value) ? value : void 0;
+}
+function contextSizes(tools, inputMessages, outputMessages) {
+  try {
+    const toolList = asList(tools);
+    const inputs = asList(inputMessages);
+    const outputs = asList(outputMessages);
+    const context2 = new Context([inputs ?? [], outputs ?? []]);
+    const toolEntries = toolList?.map(
+      (tool) => ({ name: toolName(tool), bytes: canonicalBytes(tool) })
+    );
+    const inputEntries = inputs?.map((message) => context2.messageEntry(message));
+    const outputEntries = outputs?.map((message) => context2.messageEntry(message));
+    let cacheIndex;
+    inputs?.forEach((message, index) => {
+      if (hasCacheMarker(message)) cacheIndex = index;
+    });
+    let window = DETAIL_WINDOW;
+    for (; ; ) {
+      const text = JSON.stringify(
+        assemble(toolEntries, inputEntries, outputEntries, cacheIndex, window)
+      );
+      if (window === 0 || Buffer.byteLength(text) <= MAX_SIZES_BYTES) return text;
+      window = Math.floor(window / 2);
+    }
+  } catch {
+    return JSON.stringify({ version: SIZES_VERSION });
+  }
+}
+
 // src/messages.ts
 init_cjs_shims();
 init_serde();
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function asText(value) {
+function asText2(value) {
   if (typeof value === "string") return value;
   const text = toAttributeValue(value);
   return typeof text === "string" ? text : String(text);
 }
 function normalizePart(item) {
-  if (isRecord(item)) {
+  if (isRecord2(item)) {
     if (item.type === "text" && "text" in item) return { type: "text", content: item.text };
     if ("type" in item) return item;
   }
-  return { type: "text", content: asText(item) };
+  return { type: "text", content: asText2(item) };
 }
 function normalizeMessage(message, defaultRole) {
   if (typeof message === "string") {
     return { role: defaultRole, parts: [{ type: "text", content: message }] };
   }
-  if (!isRecord(message)) {
-    return { role: defaultRole, parts: [{ type: "text", content: asText(message) }] };
+  if (!isRecord2(message)) {
+    return { role: defaultRole, parts: [{ type: "text", content: asText2(message) }] };
   }
   if ("parts" in message) {
     return { ...message, role: message.role ?? defaultRole };
@@ -1700,7 +3677,16 @@ function normalizeMessage(message, defaultRole) {
   if (role === "tool" && "tool_call_id" in message) {
     return {
       role: "tool",
-      parts: [{ type: "tool_call_response", id: message.tool_call_id, response: message.content }]
+      // Missing fields become null, never absent: Python's dict.get() writes
+      // null for them, and the two SDKs' parts must serialize to the same
+      // bytes for the context sizes to agree.
+      parts: [
+        {
+          type: "tool_call_response",
+          id: message.tool_call_id ?? null,
+          response: message.content ?? null
+        }
+      ]
     };
   }
   const parts = [];
@@ -1710,24 +3696,30 @@ function normalizeMessage(message, defaultRole) {
   } else if (Array.isArray(content)) {
     for (const item of content) parts.push(normalizePart(item));
   } else if (content !== null && content !== void 0) {
-    parts.push({ type: "text", content: asText(content) });
+    parts.push({ type: "text", content: asText2(content) });
   }
   const toolCalls = message.tool_calls;
   if (Array.isArray(toolCalls)) {
     for (const call of toolCalls) {
-      if (!isRecord(call)) continue;
-      const fn = isRecord(call.function) ? call.function : {};
-      parts.push({ type: "tool_call", id: call.id, name: fn.name, arguments: fn.arguments });
+      if (!isRecord2(call)) continue;
+      const fn = isRecord2(call.function) ? call.function : {};
+      parts.push({
+        type: "tool_call",
+        id: call.id ?? null,
+        name: fn.name ?? null,
+        arguments: fn.arguments ?? null
+      });
     }
   }
   return { role, parts };
 }
-function serializeMessages(messages, defaultRole) {
+function normalizeMessages(messages, defaultRole) {
   const list = Array.isArray(messages) ? messages : [messages];
-  return toAttributeValue(list.map((message) => normalizeMessage(message, defaultRole)));
+  return list.map((message) => normalizeMessage(message, defaultRole));
 }
 
 // src/generation.ts
+init_normalize();
 init_semconv();
 init_serde();
 init_spans();
@@ -1739,6 +3731,7 @@ var Generation = class extends Observation {
   constructor(span, provider) {
     super(span);
     this.provider = provider;
+    this.span.setAttribute(RIUS_CONTEXT_SIZES, contextSizes(void 0, void 0, void 0));
   }
   provider;
   firstTokenRecorded = false;
@@ -1748,6 +3741,32 @@ var Generation = class extends Observation {
    * time, so this is what `recordFirstToken` measures the first chunk against.
    */
   startedAt = performance.now();
+  /**
+   * The latest normalized input / output and the tool definitions, kept so
+   * `rius.context.sizes` can be computed from all three once, in {@link end}.
+   */
+  inputMessages;
+  outputMessages;
+  tools;
+  /**
+   * Computed once, as the span ends, rather than on every content write: a
+   * generation with tools, input and output would otherwise pay for it three
+   * times, and only the last result matters. Derived from the normalized
+   * messages BEFORE truncation, which is what makes it trustworthy when the
+   * content attributes are not.
+   */
+  setContextSizes() {
+    if (!this.inputMessages && !this.outputMessages && !this.tools) return;
+    this.span.setAttribute(
+      RIUS_CONTEXT_SIZES,
+      contextSizes(this.tools, this.inputMessages, this.outputMessages)
+    );
+  }
+  /** Ends the span after recording the context sizes; idempotent like the base. */
+  end() {
+    if (!this.ended) this.setContextSizes();
+    super.end();
+  }
   /**
    * Record the request messages (`gen_ai.input.messages`), normalised to the
    * GenAI `{role, parts}` shape like the Python SDK does: bare strings, OpenAI
@@ -1755,12 +3774,14 @@ var Generation = class extends Observation {
    * lists are all accepted. Bare strings default to the `user` role.
    */
   setInput(value) {
-    this.span.setAttribute(GEN_AI_INPUT_MESSAGES, serializeMessages(value, "user"));
+    this.inputMessages = normalizeMessages(value, "user");
+    this.span.setAttribute(GEN_AI_INPUT_MESSAGES, toAttributeValue(this.inputMessages));
     return this;
   }
   /** Record the response messages (`gen_ai.output.messages`); bare strings default to `assistant`. */
   setOutput(value) {
-    this.span.setAttribute(GEN_AI_OUTPUT_MESSAGES, serializeMessages(value, "assistant"));
+    this.outputMessages = normalizeMessages(value, "assistant");
+    this.span.setAttribute(GEN_AI_OUTPUT_MESSAGES, toAttributeValue(this.outputMessages));
     return this;
   }
   /**
@@ -1772,6 +3793,7 @@ var Generation = class extends Observation {
    * masked/stripped under `captureContent: false` like messages are.
    */
   setToolDefinitions(tools) {
+    this.tools = tools;
     this.span.setAttribute(GEN_AI_TOOL_DEFINITIONS, toAttributeValue(tools));
     return this;
   }
@@ -1779,6 +3801,18 @@ var Generation = class extends Observation {
     this.span.setAttribute(GEN_AI_RESPONSE_MODEL, model);
     return this;
   }
+  /**
+   * The provider's identifier for this completion (`gen_ai.response.id`) —
+   * OpenAI's `id`, Anthropic's `id`, and so on. A post-call setter and not a
+   * creation option for the reason `setModel` is one: the value arrives WITH
+   * the response, so no span can carry it at creation and no pending snapshot
+   * can either. Recorded verbatim; it is an opaque provider string, and it is
+   * not content, so it survives `captureContent: false`.
+   */
+  setResponseId(id) {
+    this.span.setAttribute(GEN_AI_RESPONSE_ID, id);
+    return this;
+  }
   /**
    * Token usage (`gen_ai.usage.*`). Pass provider-reported values as-is;
    * never pre-add anything. Per the GenAI conventions, `inputTokens` is the
@@ -1843,37 +3877,69 @@ var Generation = class extends Observation {
     return this;
   }
 };
+function requestAttributes(modelParameters) {
+  const parameters = new Map(
+    Object.entries(modelParameters ?? {}).filter(([, value]) => value != null)
+  );
+  const attributes = {};
+  for (const [spelling, canonical] of Object.entries(GEN_AI_REQUEST_PARAMETERS)) {
+    if (!parameters.has(spelling)) continue;
+    const value = parameters.get(spelling);
+    parameters.delete(spelling);
+    const guarded = REQUEST_PARAMETER_GUARDS[canonical](value);
+    if (guarded !== void 0 && !Object.hasOwn(attributes, canonical)) {
+      attributes[canonical] = guarded;
+    } else {
+      const coerced = attributeValue(value);
+      if (coerced !== void 0) attributes[`${RIUS_REQUEST_PREFIX}${spelling}`] = coerced;
+    }
+  }
+  for (const [key, value] of parameters) {
+    const coerced = attributeValue(value);
+    if (coerced !== void 0) attributes[requestAttributeKey(key)] = coerced;
+  }
+  return attributes;
+}
 function attributesFor(options) {
   const attributes = { ...kindAttributes("LLM" /* LLM */) };
   if (options.operation !== void 0) attributes[GEN_AI_OPERATION_NAME] = options.operation;
+  Object.assign(attributes, requestAttributes(options.modelParameters));
+  if (options.reasoningLevel !== void 0) {
+    attributes[GEN_AI_REQUEST_REASONING_LEVEL] = options.reasoningLevel;
+  }
   if (options.model !== void 0) attributes[GEN_AI_REQUEST_MODEL] = options.model;
   if (options.provider !== void 0) attributes[GEN_AI_PROVIDER_NAME] = options.provider;
+  if (options.outputType !== void 0) attributes[GEN_AI_OUTPUT_TYPE] = options.outputType;
   if (options.userId !== void 0) attributes[USER_ID] = options.userId;
   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.reasoningLevel !== void 0) {
-    generation.setAttribute(GEN_AI_REQUEST_REASONING_LEVEL, options.reasoningLevel);
-  }
   if (options.tools !== void 0) generation.setToolDefinitions(options.tools);
   if (options.input !== void 0) generation.setInput(options.input);
   return generation;
 }
-function startGeneration(name, options = {}) {
-  const span = getTracer().startSpan(name, {
+function resolveName2(name, attributes) {
+  return name ?? composeSpanName("LLM" /* LLM */, attributes);
+}
+function startGeneration(nameOrOptions, maybeOptions) {
+  const [name, options] = typeof nameOrOptions === "string" ? [nameOrOptions, maybeOptions ?? {}] : [void 0, nameOrOptions ?? {}];
+  const attributes = attributesFor(options);
+  const span = getTracer().startSpan(resolveName2(name, attributes), {
     kind: otelSpanKind("LLM" /* LLM */),
-    attributes: attributesFor(options)
+    attributes
   });
   return configure2(new Generation(span, options.provider), options);
 }
-function startAsCurrentGeneration(name, optionsOrFn, maybeFn) {
-  const [options, fn] = typeof optionsOrFn === "function" ? [{}, optionsOrFn] : [optionsOrFn, maybeFn];
+function startAsCurrentGeneration(first, second, third) {
+  const { name, options, fn } = splitScopedArgs(
+    first,
+    second,
+    third
+  );
+  const attributes = attributesFor(options);
   return runActive(
-    name,
-    attributesFor(options),
+    resolveName2(name, attributes),
+    attributes,
     options.userId,
     (span) => configure2(new Generation(span, options.provider), options),
     fn,
@@ -1883,24 +3949,41 @@ function startAsCurrentGeneration(name, optionsOrFn, maybeFn) {
 
 // src/observe.ts
 init_cjs_shims();
+init_semconv();
 init_spans();
 function observe(fn, options = {}) {
-  const name = options.name ?? (fn.name || "anonymous");
+  const kind = options.kind ?? "CHAIN" /* CHAIN */;
+  const name = options.name ?? (kind === "CHAIN" /* CHAIN */ ? fn.name || "anonymous" : void 0);
+  const toolName2 = options.toolName ?? (kind === "TOOL" /* TOOL */ && name === void 0 ? fn.name || void 0 : void 0);
   const captureInput = options.captureInput ?? true;
   const captureOutput = options.captureOutput ?? true;
-  const wrapped = (...args) => startAsCurrentSpan(
-    name,
-    // {args, kwargs} is the Python SDK's shape; JavaScript has no keyword
-    // arguments, so kwargs is always empty, but the key stays so a saved
-    // search or a console view reads both SDKs' input.value the same way.
-    { kind: options.kind, input: captureInput ? { args, kwargs: {} } : void 0 },
-    async (observation) => {
+  const wrapped = (...args) => {
+    const spanOptions = {
+      kind: options.kind,
+      toolName: toolName2,
+      toolCallId: options.toolCallId,
+      toolType: options.toolType,
+      dataSourceId: options.dataSourceId,
+      topK: options.topK,
+      agentName: options.agentName,
+      agentId: options.agentId,
+      agentVersion: options.agentVersion,
+      // {args, kwargs} is the Python SDK's shape; JavaScript has no keyword
+      // arguments, so kwargs is always empty, but the key stays so a saved
+      // search or a console view reads both SDKs' input.value the same way.
+      input: captureInput ? { args, kwargs: {} } : void 0
+    };
+    const body = 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 name === void 0 ? startAsCurrentSpan(spanOptions, body) : startAsCurrentSpan(name, spanOptions, body);
+  };
+  Object.defineProperty(wrapped, "name", {
+    value: name ?? (fn.name || "anonymous"),
+    configurable: true
+  });
   return wrapped;
 }
 
@@ -1910,7 +3993,7 @@ init_session();
 init_user();
 init_spans();
 init_workspace();
-var VERSION = "0.8.0";
+var VERSION = "1.0.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Generation,