@glassflow-ai/rius 0.4.0 → 0.6.0

package/dist/index.cjs

@@ -53,7 +53,11 @@ function seconds(raw, fallback) {
   if (Number.isNaN(parsed)) return fallback;
   return parsed;
 }
-function clamp(name, value, min, max) {
+function clamp(name, value, min, max, fallback) {
+  if (!Number.isFinite(value)) {
+    console.warn(`[rius] ${name}=${value} is not a finite number; using ${fallback}.`);
+    return fallback;
+  }
   if (value >= min && value <= max) return value;
   const clamped = Math.min(Math.max(value, min), max);
   console.warn(`[rius] ${name}=${value} is outside [${min}, ${max}]; clamped to ${clamped}.`);
@@ -66,13 +70,15 @@ function resolveConfig(options = {}, env = process.env) {
     "heartbeatInterval",
     options.heartbeatInterval ?? seconds(env.RIUS_HEARTBEAT_INTERVAL, DEFAULT_HEARTBEAT_INTERVAL),
     HEARTBEAT_INTERVAL_MIN,
-    HEARTBEAT_INTERVAL_MAX
+    HEARTBEAT_INTERVAL_MAX,
+    DEFAULT_HEARTBEAT_INTERVAL
   );
   const partialSpansDelaySeconds = clamp(
     "partialSpansDelay",
     options.partialSpansDelay ?? seconds(env.RIUS_PARTIAL_SPANS_DELAY, DEFAULT_PARTIAL_SPANS_DELAY),
     PARTIAL_SPANS_DELAY_MIN,
-    PARTIAL_SPANS_DELAY_MAX
+    PARTIAL_SPANS_DELAY_MAX,
+    DEFAULT_PARTIAL_SPANS_DELAY
   );
   return {
     endpoint,
@@ -221,6 +227,24 @@ var init_exportHealth = __esm({
   }
 });
 
+// src/version.ts
+var import_node_module, SDK_VERSION;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_module = require("module");
+    SDK_VERSION = (() => {
+      try {
+        const pkg = (0, import_node_module.createRequire)(importMetaUrl)("../package.json");
+        return pkg.version ?? "0.0.0";
+      } catch {
+        return "0.0.0";
+      }
+    })();
+  }
+});
+
 // src/heartbeat.ts
 function httpTransport(url, headers) {
   return async (payload, timeoutMs) => {
@@ -237,24 +261,16 @@ function httpTransport(url, headers) {
     }
   };
 }
-var import_node_module, PAYLOAD_VERSION, OPEN_TRACES_CAP, DEFAULT_PING_TIMEOUT_MS, DEFAULT_FINAL_PING_TIMEOUT_MS, SDK_VERSION, OpenRootSpanTracker, HeartbeatSender;
+var PAYLOAD_VERSION, OPEN_TRACES_CAP, DEFAULT_PING_TIMEOUT_MS, DEFAULT_FINAL_PING_TIMEOUT_MS, OpenRootSpanTracker, HeartbeatSender;
 var init_heartbeat = __esm({
   "src/heartbeat.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_module = require("module");
+    init_version();
     PAYLOAD_VERSION = 1;
     OPEN_TRACES_CAP = 32;
     DEFAULT_PING_TIMEOUT_MS = 3e3;
     DEFAULT_FINAL_PING_TIMEOUT_MS = 1e3;
-    SDK_VERSION = (() => {
-      try {
-        const pkg = (0, import_node_module.createRequire)(importMetaUrl)("../package.json");
-        return pkg.version ?? "0.0.0";
-      } catch {
-        return "0.0.0";
-      }
-    })();
     OpenRootSpanTracker = class {
       // trace id (32-hex) -> count of open root spans in that trace. A trace id
       // normally has one root, but the count guards against duplicates.
@@ -306,6 +322,7 @@ var init_heartbeat = __esm({
       }
       /** Starts pinging: an immediate first ping, then every `intervalMs`. */
       start() {
+        if (this.timer !== void 0) return;
         void this.ping(this.pingTimeoutMs, false);
         const timer = setInterval(() => void this.ping(this.pingTimeoutMs, false), this.intervalMs);
         if (typeof timer.unref === "function") timer.unref();
@@ -356,7 +373,7 @@ function kindAttributes(kind) {
   if (operation !== void 0) attributes[GEN_AI_OPERATION_NAME] = operation;
   return attributes;
 }
-var TRACER_NAME, SERVICE_INSTANCE_ID, OPENINFERENCE_SPAN_KIND, INPUT_VALUE, OUTPUT_VALUE, SESSION_ID, WORKSPACE_ROUTE, GEN_AI_OPERATION_NAME, GEN_AI_PROVIDER_NAME, GEN_AI_REQUEST_MODEL, GEN_AI_RESPONSE_MODEL, GEN_AI_USAGE_INPUT_TOKENS, GEN_AI_USAGE_OUTPUT_TOKENS, GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS, GEN_AI_USAGE_CACHE_WRITE_INPUT_TOKENS, GEN_AI_INPUT_MESSAGES, GEN_AI_OUTPUT_MESSAGES, GEN_AI_RESPONSE_FINISH_REASONS, GEN_AI_TOOL_NAME, GEN_AI_REQUEST_PREFIX, MCP_RESULT_TYPE, GEN_AI_FIRST_TOKEN_EVENT, SpanKind, OPERATION_BY_KIND, CONTENT_ATTRIBUTES, CONTENT_ATTRIBUTE_PREFIXES, CONTENT_ATTRIBUTE_SUFFIXES, GLASSFLOW_SPAN_PENDING, PENDING_IDENTITY_ATTRIBUTES, PENDING_IDENTITY_PREFIXES;
+var 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_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_RESULT_TYPE, GEN_AI_FIRST_TOKEN_EVENT, SpanKind, OPERATION_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";
@@ -367,19 +384,23 @@ var init_semconv = __esm({
     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_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_RESULT_TYPE = "mcp.result_type";
     GEN_AI_FIRST_TOKEN_EVENT = "gen_ai.first_token";
@@ -408,7 +429,18 @@ var init_semconv = __esm({
       // or internal URLs in parameter defaults. gen_ai.tool.name stays: it is
       // identity, not content.
       "gen_ai.tool.description",
-      "gen_ai.tool.definitions",
+      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",
@@ -422,15 +454,44 @@ var init_semconv = __esm({
       "mlflow.spanInputs",
       "mlflow.spanOutputs",
       "traceloop.entity.input",
-      "traceloop.entity.output"
+      "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.prompt_template.",
+      "llm.tools.",
+      "ai.prompt."
     ];
     CONTENT_ATTRIBUTE_SUFFIXES = [
       ".document.content",
@@ -445,6 +506,9 @@ var init_semconv = __esm({
       // 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
@@ -454,31 +518,77 @@ var init_semconv = __esm({
 });
 
 // src/serde.ts
-function toAttributeValue(value) {
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
+function truncate(text) {
+  return text.length > MAX_ATTR_CHARS ? text.slice(0, MAX_ATTR_CHARS) + TRUNCATION_MARKER : text;
+}
+function renderable(raw, value) {
+  if (typeof raw === "bigint") return String(raw);
+  if (raw instanceof Map) return Object.fromEntries(raw);
+  if (raw instanceof Set) return [...raw];
+  if (ArrayBuffer.isView(raw)) {
+    return `<${raw.constructor.name} ${raw.byteLength} bytes>`;
   }
+  if (raw instanceof ArrayBuffer) return `<ArrayBuffer ${raw.byteLength} bytes>`;
+  return value;
+}
+function toAttributeValue(value) {
+  if (typeof value === "string") return truncate(value);
+  if (typeof value === "number" || typeof value === "boolean") return value;
   if (value === null || value === void 0) return "";
+  if (typeof value === "bigint") return String(value);
   const ancestors = [];
   try {
-    return JSON.stringify(value, function(_key, v) {
-      if (typeof v === "object" && v !== null) {
+    const text = JSON.stringify({ "": value }[""], function(key, v) {
+      const raw = this?.[key];
+      const rendered = renderable(raw, v);
+      if (typeof rendered === "object" && rendered !== null) {
         while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) {
           ancestors.pop();
         }
-        if (ancestors.includes(v)) return "[Circular]";
-        ancestors.push(v);
+        if (ancestors.includes(rendered)) return "[Circular]";
+        ancestors.push(rendered);
       }
-      return v;
+      return rendered;
     }) ?? String(value);
+    return truncate(text);
   } catch {
     return "[unserializable]";
   }
 }
+var MAX_ATTR_CHARS, TRUNCATION_MARKER;
 var init_serde = __esm({
   "src/serde.ts"() {
     "use strict";
     init_cjs_shims();
+    MAX_ATTR_CHARS = 32 * 1024;
+    TRUNCATION_MARKER = "\u2026(truncated)";
+  }
+});
+
+// src/user.ts
+function withUser(userId, fn) {
+  return import_api.context.with(import_api.context.active().setValue(USER_KEY, userId), () => fn(userId));
+}
+var import_api, USER_KEY, UserSpanProcessor;
+var init_user = __esm({
+  "src/user.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_api = require("@opentelemetry/api");
+    init_semconv();
+    USER_KEY = (0, import_api.createContextKey)("rius-user-id");
+    UserSpanProcessor = class {
+      onStart(span, parentContext) {
+        const value = parentContext.getValue(USER_KEY);
+        if (typeof value === "string") span.setAttribute(USER_ID, value);
+      }
+      onEnd(_span) {
+      }
+      async forceFlush() {
+      }
+      async shutdown() {
+      }
+    };
   }
 });
 
@@ -487,39 +597,50 @@ function configure(observation, options) {
   if (options.input !== void 0) observation.setInput(options.input);
   return observation;
 }
+function creationAttributes(options) {
+  const attributes = { ...kindAttributes(options.kind ?? "CHAIN" /* CHAIN */), ...options.attributes };
+  if (options.userId !== void 0) attributes[USER_ID] = options.userId;
+  return attributes;
+}
 function startSpan(name, options = {}) {
-  const span = getTracer().startSpan(name, {
-    attributes: kindAttributes(options.kind ?? "CHAIN" /* CHAIN */)
-  });
+  const span = getTracer().startSpan(name, { attributes: creationAttributes(options) });
   return configure(new Observation(span), options);
 }
 function startAsCurrentSpan(name, optionsOrFn, maybeFn) {
   const [options, fn] = typeof optionsOrFn === "function" ? [{}, optionsOrFn] : [optionsOrFn, maybeFn];
-  return getTracer().startActiveSpan(
+  return runActive(
     name,
-    { attributes: kindAttributes(options.kind ?? "CHAIN" /* CHAIN */) },
-    async (span) => {
-      const observation = configure(new Observation(span), options);
-      try {
-        return await fn(observation);
-      } catch (error) {
-        observation.recordException(error);
-        throw error;
-      } finally {
-        observation.end();
-      }
-    }
+    creationAttributes(options),
+    options.userId,
+    (span) => configure(new Observation(span), options),
+    fn
   );
 }
-var import_api, Observation;
+function runActive(name, attributes, userId, makeHandle, fn) {
+  const run = () => getTracer().startActiveSpan(name, { attributes }, async (span) => {
+    const handle = makeHandle(span);
+    try {
+      return await fn(handle);
+    } catch (error) {
+      handle.recordException(error);
+      throw error;
+    } finally {
+      handle.end();
+    }
+  });
+  return userId !== void 0 ? withUser(userId, run) : run();
+}
+var import_api2, Observation;
 var init_spans = __esm({
   "src/spans.ts"() {
     "use strict";
     init_cjs_shims();
-    import_api = require("@opentelemetry/api");
+    import_api2 = require("@opentelemetry/api");
     init_client();
     init_semconv();
     init_serde();
+    init_user();
+    Symbol.dispose ??= /* @__PURE__ */ Symbol.for("Symbol.dispose");
     Observation = class {
       constructor(span) {
         this.span = span;
@@ -534,7 +655,26 @@ var init_spans = __esm({
         this.span.setAttribute(OUTPUT_VALUE, toAttributeValue(value));
         return this;
       }
+      /**
+       * Set an arbitrary attribute. Primitives and homogeneous primitive arrays
+       * are passed through as the OTel values they are; objects are JSON-encoded
+       * and bounded; `undefined` and `null` set nothing, since "no value" is not
+       * 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));
         return this;
       }
@@ -549,7 +689,7 @@ var init_spans = __esm({
       recordException(error) {
         const wrapped = error instanceof Error ? error : new Error(String(error));
         this.span.recordException(wrapped);
-        this.span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: wrapped.message });
+        this.span.setStatus({ code: import_api2.SpanStatusCode.ERROR, message: wrapped.message });
         return this;
       }
       end() {
@@ -570,6 +710,21 @@ var instrumentationMcp_exports = {};
 __export(instrumentationMcp_exports, {
   instrumentMcpClient: () => instrumentMcpClient
 });
+function serializeResult(result) {
+  if (typeof result !== "object" || result === null) return toAttributeValue(result);
+  const record = result;
+  const structured = record.structured_content ?? record.structuredContent;
+  if (structured !== void 0 && structured !== null) return toAttributeValue(structured);
+  const content = record.content;
+  if (Array.isArray(content)) {
+    const texts = content.map(
+      (block) => typeof block === "object" && block !== null ? block.text : void 0
+    ).filter((text) => typeof text === "string");
+    if (texts.length === 1) return truncate(texts[0]);
+    if (texts.length > 1) return toAttributeValue(texts);
+  }
+  return toAttributeValue(result);
+}
 function resultIsError(result) {
   if (typeof result !== "object" || result === null) return false;
   const record = result;
@@ -581,10 +736,10 @@ function recordResult(observation, result) {
     observation.setAttribute(MCP_RESULT_TYPE, INPUT_REQUIRED);
     return;
   }
-  observation.setOutput(result);
+  observation.setAttribute(OUTPUT_VALUE, serializeResult(result));
   if (resultIsError(result)) {
     observation.span.setStatus({
-      code: import_api2.SpanStatusCode.ERROR,
+      code: import_api3.SpanStatusCode.ERROR,
       message: "tool returned an error result"
     });
   }
@@ -601,9 +756,14 @@ function instrumentMcpClient(ClientClass) {
   const instrumented = function instrumentedCallTool(params, ...rest) {
     return startAsCurrentSpan(
       `execute_tool ${params.name}`,
-      { kind: "TOOL" /* TOOL */, input: params.arguments },
+      // Tool name at CREATION: pending snapshots are built at start, so an
+      // attribute set inside the callback never reaches them.
+      {
+        kind: "TOOL" /* TOOL */,
+        input: params.arguments,
+        attributes: { [GEN_AI_TOOL_NAME]: params.name }
+      },
       async (observation) => {
-        observation.setAttribute(GEN_AI_TOOL_NAME, params.name);
         const result = await original.call(this, params, ...rest);
         recordResult(observation, result);
         return result;
@@ -616,13 +776,14 @@ function instrumentMcpClient(ClientClass) {
     ClientClass.prototype.callTool = original;
   };
 }
-var import_api2, INPUT_REQUIRED;
+var import_api3, INPUT_REQUIRED;
 var init_instrumentationMcp = __esm({
   "src/instrumentationMcp.ts"() {
     "use strict";
     init_cjs_shims();
-    import_api2 = require("@opentelemetry/api");
+    import_api3 = require("@opentelemetry/api");
     init_semconv();
+    init_serde();
     init_spans();
     INPUT_REQUIRED = "input_required";
   }
@@ -714,21 +875,55 @@ function mcpClientPatchable(exports2) {
   const cls = exports2.Client;
   return typeof cls?.prototype?.callTool === "function" ? { Client: cls } : void 0;
 }
-async function enableInstrumentations(sink, tracerProvider, names) {
+async function registerVercelTelemetry(tracerProvider, teardown) {
+  const ai = await optional("ai");
+  const register = ai?.registerTelemetry;
+  if (register === void 0) return false;
+  const otel = await optional("@ai-sdk/otel");
+  const OpenTelemetryIntegration = otel?.OpenTelemetry;
+  if (OpenTelemetryIntegration === void 0) {
+    console.warn(
+      "[rius] Vercel AI SDK v7+ found, but its spans require the @ai-sdk/otel package, which is not installed \u2014 `ai` calls will not be traced. Install it (npm i @ai-sdk/otel) and rius registers it automatically."
+    );
+    return false;
+  }
+  const bag = globalThis;
+  if (vercelTelemetryIntegration !== void 0 && bag.AI_SDK_TELEMETRY_INTEGRATIONS) {
+    bag.AI_SDK_TELEMETRY_INTEGRATIONS = bag.AI_SDK_TELEMETRY_INTEGRATIONS.filter(
+      (integration2) => integration2 !== vercelTelemetryIntegration
+    );
+  }
+  const integration = new OpenTelemetryIntegration({
+    tracer: tracerProvider.getTracer(TRACER_NAME, SDK_VERSION)
+  });
+  vercelTelemetryIntegration = integration;
+  register(integration);
+  teardown?.push(() => {
+    if (bag.AI_SDK_TELEMETRY_INTEGRATIONS) {
+      bag.AI_SDK_TELEMETRY_INTEGRATIONS = bag.AI_SDK_TELEMETRY_INTEGRATIONS.filter(
+        (candidate) => candidate !== integration
+      );
+    }
+    if (vercelTelemetryIntegration === integration) vercelTelemetryIntegration = void 0;
+  });
+  return true;
+}
+async function enableInstrumentations(sink, tracerProvider, names, teardown) {
   const wanted = names ? REGISTRY.filter((e) => names.includes(e.name)) : REGISTRY;
   const enabled = [];
   for (const entry of wanted) {
     try {
-      const loaded = await entry.load();
+      const loaded = await entry.load(tracerProvider, teardown);
       if (loaded === void 0) continue;
       if (entry.kind === "processor") {
         if (entry.insert === "first") sink.addFirst(loaded);
         else sink.add(loaded);
       } else if (entry.kind === "instrumentation") {
-        (0, import_instrumentation.registerInstrumentations)({
+        const disable = (0, import_instrumentation.registerInstrumentations)({
           instrumentations: [loaded],
           tracerProvider
         });
+        teardown?.push(disable);
       }
       enabled.push(entry.name);
     } catch (error) {
@@ -737,7 +932,7 @@ async function enableInstrumentations(sink, tracerProvider, names) {
   }
   return enabled;
 }
-var import_node_module2, import_node_path, import_instrumentation, dynamicImport, REGISTRY;
+var import_node_module2, import_node_path, import_instrumentation, dynamicImport, vercelTelemetryIntegration, REGISTRY;
 var init_instrumentation = __esm({
   "src/instrumentation.ts"() {
     "use strict";
@@ -745,6 +940,8 @@ var init_instrumentation = __esm({
     import_node_module2 = require("module");
     import_node_path = require("path");
     import_instrumentation = require("@opentelemetry/instrumentation");
+    init_semconv();
+    init_version();
     dynamicImport = new Function("s", "return import(s)");
     REGISTRY = [
       {
@@ -755,15 +952,16 @@ var init_instrumentation = __esm({
         // transform has to run before the exporting processor sees the span or the
         // attributes it added would never be sanitised.
         insert: "first",
-        async load() {
+        async load(tracerProvider, teardown) {
+          const registered = tracerProvider === void 0 ? false : await registerVercelTelemetry(tracerProvider, teardown);
           const utils = await optional("@arizeai/openinference-vercel/utils");
           const add = utils?.addOpenInferenceAttributesToSpan;
-          if (add === void 0) return void 0;
+          if (add === void 0 && !registered) return void 0;
           return {
             onStart() {
             },
             onEnd(span) {
-              add(span);
+              add?.(span);
             },
             async forceFlush() {
             },
@@ -813,14 +1011,18 @@ var init_instrumentation = __esm({
       {
         name: "mcp",
         kind: "self-applying",
-        async load() {
+        async load(_tracerProvider, teardown) {
           const mod = await optional("@modelcontextprotocol/sdk/client/index.js");
           const ClientClass = mod?.Client;
           if (ClientClass === void 0) return void 0;
           const { instrumentMcpClient: instrumentMcpClient2 } = await Promise.resolve().then(() => (init_instrumentationMcp(), instrumentationMcp_exports));
-          instrumentMcpClient2(ClientClass);
+          const uninstallEsm = instrumentMcpClient2(ClientClass);
+          teardown?.push(uninstallEsm);
           const cjs = cachedCjsExports("@modelcontextprotocol/sdk", mcpClientPatchable);
-          if (cjs !== void 0) instrumentMcpClient2(cjs.Client);
+          if (cjs !== void 0) {
+            const uninstallCjs = instrumentMcpClient2(cjs.Client);
+            teardown?.push(uninstallCjs);
+          }
           return true;
         }
       }
@@ -834,16 +1036,35 @@ function isContentKey(key) {
   if (CONTENT_ATTRIBUTE_PREFIXES.some((p) => key.startsWith(p))) return true;
   return CONTENT_ATTRIBUTE_SUFFIXES.some((s) => key.endsWith(s));
 }
-var import_api3, EXCEPTION_EVENT_NAME, EXCEPTION_CONTENT_KEYS, MaskingSpanExporter;
+function redactInvocationParameters(value) {
+  if (typeof value !== "string") return void 0;
+  let parameters;
+  try {
+    parameters = JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+  if (parameters === null || typeof parameters !== "object" || Array.isArray(parameters)) {
+    return void 0;
+  }
+  const bag = parameters;
+  if (!INVOCATION_PARAMETERS_CONTENT_MEMBERS.some((member) => member in bag)) {
+    return value;
+  }
+  for (const member of INVOCATION_PARAMETERS_CONTENT_MEMBERS) delete bag[member];
+  return JSON.stringify(bag);
+}
+var import_api4, EXCEPTION_EVENT_NAME, EXCEPTION_CONTENT_KEYS, STATUS_DESCRIPTION_KEY, MaskingSpanExporter;
 var init_masking = __esm({
   "src/masking.ts"() {
     "use strict";
     init_cjs_shims();
-    import_api3 = require("@opentelemetry/api");
+    import_api4 = require("@opentelemetry/api");
     init_semconv();
     init_serde();
     EXCEPTION_EVENT_NAME = "exception";
     EXCEPTION_CONTENT_KEYS = ["exception.message", "exception.stacktrace"];
+    STATUS_DESCRIPTION_KEY = "status.description";
     MaskingSpanExporter = class {
       constructor(inner, opts) {
         this.inner = inner;
@@ -869,14 +1090,42 @@ var init_masking = __esm({
         for (const link of span.links ?? []) {
           this.sanitizeAttributes(link.attributes);
         }
-        if (!this.opts.captureContent && span.status?.code === import_api3.SpanStatusCode.ERROR) {
-          span.status.message = void 0;
-        }
+        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_api4.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;
+        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;
+        }
         for (const key of Object.keys(attributes)) {
           if (!isContentKey(key)) continue;
           if (!this.opts.captureContent) {
@@ -923,7 +1172,7 @@ function buildSnapshot(span) {
     startTime: span.startTime,
     endTime: span.startTime,
     duration: [0, 0],
-    status: { code: import_api4.SpanStatusCode.UNSET },
+    status: { code: import_api5.SpanStatusCode.UNSET },
     attributes,
     links: [],
     events: [],
@@ -935,15 +1184,15 @@ function buildSnapshot(span) {
     ended: true
   };
 }
-function spanKey(context) {
-  return `${context.traceId}:${context.spanId}`;
+function spanKey(context2) {
+  return `${context2.traceId}:${context2.spanId}`;
 }
-var import_api4, PendingSpanProcessor;
+var import_api5, PendingSpanProcessor;
 var init_pending = __esm({
   "src/pending.ts"() {
     "use strict";
     init_cjs_shims();
-    import_api4 = require("@opentelemetry/api");
+    import_api5 = require("@opentelemetry/api");
     init_semconv();
     PendingSpanProcessor = class {
       delegate;
@@ -991,17 +1240,17 @@ 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_api5.context.with(import_api5.context.active().setValue(SESSION_KEY, sessionId), () => fn(sessionId));
+  return import_api6.context.with(import_api6.context.active().setValue(SESSION_KEY, sessionId), () => fn(sessionId));
 }
-var import_node_crypto, import_api5, SESSION_KEY, SessionSpanProcessor;
+var import_node_crypto, import_api6, SESSION_KEY, SessionSpanProcessor;
 var init_session = __esm({
   "src/session.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_crypto = require("crypto");
-    import_api5 = require("@opentelemetry/api");
+    import_api6 = require("@opentelemetry/api");
     init_semconv();
-    SESSION_KEY = (0, import_api5.createContextKey)("rius-session-id");
+    SESSION_KEY = (0, import_api6.createContextKey)("rius-session-id");
     SessionSpanProcessor = class {
       constructor(defaultSessionId) {
         this.defaultSessionId = defaultSessionId;
@@ -1009,7 +1258,9 @@ var init_session = __esm({
       defaultSessionId;
       onStart(span, parentContext) {
         const value = parentContext.getValue(SESSION_KEY);
-        const sessionId = typeof value === "string" ? value : this.defaultSessionId;
+        const parent = import_api6.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);
       }
       onEnd(_span) {
@@ -1025,7 +1276,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_api6.context.with(import_api6.context.active().setValue(WORKSPACE_KEY, alias), () => fn(alias));
+  return import_api7.context.with(import_api7.context.active().setValue(WORKSPACE_KEY, alias), () => fn(alias));
 }
 function setGlobalRouting(routing) {
   globalRouting = routing;
@@ -1038,25 +1289,32 @@ function registerWorkspace(alias, apiKey) {
   }
   globalRouting.register(alias, apiKey);
 }
-var import_api6, WORKSPACE_KEY, WorkspaceSpanProcessor, RoutingSpanExporter, globalRouting;
+var import_api7, WORKSPACE_KEY, WorkspaceSpanProcessor, RoutingSpanExporter, globalRouting;
 var init_workspace = __esm({
   "src/workspace.ts"() {
     "use strict";
     init_cjs_shims();
-    import_api6 = require("@opentelemetry/api");
+    import_api7 = require("@opentelemetry/api");
     init_esm();
     init_semconv();
-    WORKSPACE_KEY = (0, import_api6.createContextKey)("rius-workspace-alias");
+    WORKSPACE_KEY = (0, import_api7.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 alias = parentContext.getValue(WORKSPACE_KEY);
-        if (typeof alias !== "string") return;
-        const parent = import_api6.trace.getSpan(parentContext);
+        const parent = import_api7.trace.getSpan(parentContext);
         const parentAlias = parent?.attributes?.[WORKSPACE_ROUTE];
+        const scoped = parentContext.getValue(WORKSPACE_KEY);
+        const alias = typeof scoped === "string" ? scoped : parentAlias;
+        if (typeof alias !== "string") return;
         if (parentAlias !== void 0 && parentAlias !== alias) {
-          console.warn(
-            `[rius] span "${span.name}" starts under workspace "${alias}" but its parent is stamped "${String(parentAlias)}"; a trace cannot straddle two workspaces (the backend derives the workspace from the API key). Switch workspaces at request boundaries, before the root span starts.`
-          );
+          const straddle = `${String(parentAlias)}->${alias}`;
+          if (!this.warnedStraddles.has(straddle)) {
+            this.warnedStraddles.add(straddle);
+            console.warn(
+              `[rius] span "${span.name}" starts under workspace "${alias}" but its parent is stamped "${String(parentAlias)}"; a trace cannot straddle two workspaces (the backend derives the workspace from the API key). Switch workspaces at request boundaries, before the root span starts. Further spans of this straddle are not reported.`
+            );
+          }
         }
         span.setAttribute(WORKSPACE_ROUTE, alias);
       }
@@ -1177,6 +1435,7 @@ function init(options = {}) {
     }) : health;
     const batch = new import_sdk_trace_base.BatchSpanProcessor(exporter);
     processors.add(new SessionSpanProcessor(config.sessionId));
+    processors.add(new UserSpanProcessor());
     if (routing !== void 0) {
       processors.add(new WorkspaceSpanProcessor());
     }
@@ -1187,9 +1446,13 @@ function init(options = {}) {
   }
   const instanceId = (0, import_node_crypto2.randomUUID)();
   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
+      [SERVICE_INSTANCE_ID]: instanceId,
+      "telemetry.distro.name": "glassflow-rius",
+      "telemetry.distro.version": SDK_VERSION
     }),
     // Always ParentBased, with no AlwaysOn shortcut at rate 1. They are not
     // equivalent: ParentBased honours a remote UNSAMPLED parent and drops,
@@ -1199,10 +1462,12 @@ function init(options = {}) {
     sampler: new import_sdk_trace_base.ParentBasedSampler({ root: new import_sdk_trace_base.TraceIdRatioBasedSampler(config.sampleRate) }),
     spanProcessors: [processors]
   });
-  const ready = config.disabled ? Promise.resolve([]) : enableInstrumentations(processors, provider).catch(() => []);
+  const teardown = [];
+  const ready = config.disabled ? Promise.resolve([]) : enableInstrumentations(processors, provider, void 0, teardown);
   provider.register();
   let heartbeat;
-  if (config.heartbeat && !config.disabled) {
+  const heartbeatCanAuthenticate = config.apiKey !== void 0 || options.heartbeatTransport !== void 0;
+  if (config.heartbeat && !config.disabled && heartbeatCanAuthenticate) {
     const tracker = new OpenRootSpanTracker();
     processors.add(tracker);
     const sender = new HeartbeatSender({
@@ -1221,20 +1486,20 @@ function init(options = {}) {
     process.once("beforeExit", beforeExitHandler);
     heartbeat = { sender, beforeExitHandler };
   }
-  globalClient = createClient({ provider, processors, health, ready, heartbeat });
+  globalClient = createClient({ provider, processors, health, ready, teardown, heartbeat });
   setGlobalRouting(routing);
   return globalClient;
 }
 function getTracer() {
-  return import_api7.trace.getTracer(TRACER_NAME);
+  return import_api8.trace.getTracer(TRACER_NAME, SDK_VERSION);
 }
-var import_node_crypto2, import_api7, 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_api8, import_exporter_trace_otlp_proto, import_resources, import_sdk_trace_base, import_sdk_trace_node, import_semantic_conventions, sinks, heartbeats, createClient, RiusClient, globalClient;
 var init_client = __esm({
   "src/client.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_crypto2 = require("crypto");
-    import_api7 = require("@opentelemetry/api");
+    import_api8 = require("@opentelemetry/api");
     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");
@@ -1249,18 +1514,22 @@ var init_client = __esm({
     init_pending();
     init_semconv();
     init_session();
+    init_user();
+    init_version();
     init_workspace();
     sinks = /* @__PURE__ */ new WeakMap();
     heartbeats = /* @__PURE__ */ new WeakMap();
     RiusClient = class _RiusClient {
       provider;
       health;
+      teardown;
       /** Resolves with the names of the auto-instrumentations that attached. */
       ready;
       constructor(parts) {
         this.provider = parts.provider;
         this.health = parts.health;
         this.ready = parts.ready;
+        this.teardown = parts.teardown;
         sinks.set(this, parts.processors);
         if (parts.heartbeat) heartbeats.set(this, parts.heartbeat);
       }
@@ -1288,13 +1557,22 @@ var init_client = __esm({
           process.removeListener("beforeExit", heartbeat.beforeExitHandler);
           await heartbeat.sender.stop();
         }
+        await this.ready;
+        for (const disable of this.teardown.splice(0)) {
+          try {
+            disable();
+          } catch {
+          }
+        }
         try {
           await this.provider.shutdown();
         } finally {
           if (globalClient === this) {
             globalClient = void 0;
             setGlobalRouting(void 0);
-            import_api7.trace.disable();
+            import_api8.trace.disable();
+            import_api8.context.disable();
+            import_api8.propagation.disable();
           }
         }
       }
@@ -1319,6 +1597,7 @@ __export(index_exports, {
   startGeneration: () => startGeneration,
   startSpan: () => startSpan,
   withSession: () => withSession,
+  withUser: () => withUser,
   withWorkspace: () => withWorkspace
 });
 module.exports = __toCommonJS(index_exports);
@@ -1328,17 +1607,106 @@ init_client();
 // src/generation.ts
 init_cjs_shims();
 init_client();
+
+// src/messages.ts
+init_cjs_shims();
+init_serde();
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asText(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 (item.type === "text" && "text" in item) return { type: "text", content: item.text };
+    if ("type" in item) return item;
+  }
+  return { type: "text", content: asText(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 ("parts" in message) {
+    return { ...message, role: message.role ?? defaultRole };
+  }
+  const role = message.role ?? 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 }]
+    };
+  }
+  const parts = [];
+  const content = message.content;
+  if (typeof content === "string") {
+    parts.push({ type: "text", content });
+  } 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) });
+  }
+  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 });
+    }
+  }
+  return { role, parts };
+}
+function serializeMessages(messages, defaultRole) {
+  const list = Array.isArray(messages) ? messages : [messages];
+  return toAttributeValue(list.map((message) => normalizeMessage(message, defaultRole)));
+}
+
+// src/generation.ts
 init_semconv();
 init_serde();
 init_spans();
 var Generation = class extends Observation {
+  /**
+   * The provider passed at creation; drives the Anthropic input-token summing
+   * in {@link setUsage}. A bare `new Generation(span)` has none and never sums.
+   */
+  constructor(span, provider) {
+    super(span);
+    this.provider = provider;
+  }
+  provider;
   firstTokenRecorded = false;
+  /**
+   * Record the request messages (`gen_ai.input.messages`), normalised to the
+   * GenAI `{role, parts}` shape like the Python SDK does: bare strings, OpenAI
+   * dicts (including `tool_calls` and tool responses) and multimodal content
+   * lists are all accepted. Bare strings default to the `user` role.
+   */
   setInput(value) {
-    this.span.setAttribute(GEN_AI_INPUT_MESSAGES, toAttributeValue(value));
+    this.span.setAttribute(GEN_AI_INPUT_MESSAGES, serializeMessages(value, "user"));
     return this;
   }
+  /** Record the response messages (`gen_ai.output.messages`); bare strings default to `assistant`. */
   setOutput(value) {
-    this.span.setAttribute(GEN_AI_OUTPUT_MESSAGES, toAttributeValue(value));
+    this.span.setAttribute(GEN_AI_OUTPUT_MESSAGES, serializeMessages(value, "assistant"));
+    return this;
+  }
+  /**
+   * The request's tool/function definitions (`gen_ai.tool.definitions`).
+   * Serialized verbatim, in whatever shape the provider request used (OpenAI
+   * nests each tool under `function`, Anthropic uses top-level
+   * `name`/`input_schema`) — no normalization, so what is recorded is exactly
+   * what the model was shown. Definitions are content, not identity: they are
+   * masked/stripped under `captureContent: false` like messages are.
+   */
+  setToolDefinitions(tools) {
+    this.span.setAttribute(GEN_AI_TOOL_DEFINITIONS, toAttributeValue(tools));
     return this;
   }
   setModel(model) {
@@ -1346,15 +1714,20 @@ var Generation = class extends Observation {
     return this;
   }
   /**
-   * Token usage (`gen_ai.usage.*`). Pass provider-reported values as-is.
-   * Per the GenAI conventions, `inputTokens` is the total including cached
-   * tokens (the cache counts are subsets of it); providers that report an
-   * exclusive `inputTokens` (e.g. Anthropic) are detected and normalized by
-   * the backend, so no client-side arithmetic is needed.
+   * Token usage (`gen_ai.usage.*`). Pass provider-reported values as-is;
+   * never pre-add anything. Per the GenAI conventions, `inputTokens` is the
+   * total including cached tokens (the cache counts are subsets of it).
+   * Anthropic's API reports `input_tokens` excluding the cache counts, and
+   * the conventions require the instrumentation to do the summing, so when
+   * the generation's provider is `"anthropic"` the emitted total is
+   * `inputTokens` plus both cache counts. Every other provider is recorded
+   * verbatim.
    */
   setUsage(usage) {
     if (usage.inputTokens !== void 0) {
-      this.span.setAttribute(GEN_AI_USAGE_INPUT_TOKENS, usage.inputTokens);
+      const sums = this.provider?.toLowerCase() === "anthropic";
+      const total = sums ? usage.inputTokens + (usage.cacheReadInputTokens ?? 0) + (usage.cacheWriteInputTokens ?? 0) : usage.inputTokens;
+      this.span.setAttribute(GEN_AI_USAGE_INPUT_TOKENS, total);
     }
     if (usage.outputTokens !== void 0) {
       this.span.setAttribute(GEN_AI_USAGE_OUTPUT_TOKENS, usage.outputTokens);
@@ -1365,6 +1738,9 @@ var Generation = class extends Observation {
     if (usage.cacheWriteInputTokens !== void 0) {
       this.span.setAttribute(GEN_AI_USAGE_CACHE_WRITE_INPUT_TOKENS, usage.cacheWriteInputTokens);
     }
+    if (usage.reasoningOutputTokens !== void 0) {
+      this.span.setAttribute(GEN_AI_USAGE_REASONING_OUTPUT_TOKENS, usage.reasoningOutputTokens);
+    }
     return this;
   }
   /**
@@ -1396,34 +1772,36 @@ var Generation = class extends Observation {
 };
 function attributesFor(options) {
   const attributes = { ...kindAttributes("LLM" /* LLM */) };
+  if (options.operation !== void 0) attributes[GEN_AI_OPERATION_NAME] = options.operation;
   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.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, { attributes: attributesFor(options) });
-  return configure2(new Generation(span), options);
+  return configure2(new Generation(span, options.provider), options);
 }
 function startAsCurrentGeneration(name, optionsOrFn, maybeFn) {
   const [options, fn] = typeof optionsOrFn === "function" ? [{}, optionsOrFn] : [optionsOrFn, maybeFn];
-  return getTracer().startActiveSpan(name, { attributes: attributesFor(options) }, async (span) => {
-    const generation = configure2(new Generation(span), options);
-    try {
-      return await fn(generation);
-    } catch (error) {
-      generation.recordException(error);
-      throw error;
-    } finally {
-      generation.end();
-    }
-  });
+  return runActive(
+    name,
+    attributesFor(options),
+    options.userId,
+    (span) => configure2(new Generation(span, options.provider), options),
+    fn
+  );
 }
 
 // src/observe.ts
@@ -1435,7 +1813,10 @@ function observe(fn, options = {}) {
   const captureOutput = options.captureOutput ?? true;
   const wrapped = (...args) => startAsCurrentSpan(
     name,
-    { kind: options.kind, input: captureInput ? args : void 0 },
+    // {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 result = await fn(...args);
       if (captureOutput && result !== void 0) observation.setOutput(result);
@@ -1449,9 +1830,10 @@ function observe(fn, options = {}) {
 // src/index.ts
 init_semconv();
 init_session();
+init_user();
 init_spans();
 init_workspace();
-var VERSION = "0.4.0";
+var VERSION = "0.6.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Generation,
@@ -1468,5 +1850,6 @@ var VERSION = "0.4.0";
   startGeneration,
   startSpan,
   withSession,
+  withUser,
   withWorkspace
 });