@glassflow-ai/rius 0.1.0 → 0.2.2

package/dist/index.js

@@ -8,6 +8,15 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
 // src/config.ts
 function bool(name, raw, fallback) {
   if (raw === void 0) return fallback;
@@ -25,24 +34,64 @@ function rate(raw, fallback) {
   if (Number.isNaN(parsed)) return fallback;
   return Math.min(1, Math.max(0, parsed));
 }
+function seconds(raw, fallback) {
+  if (raw === void 0) return fallback;
+  const parsed = Number.parseFloat(raw);
+  if (Number.isNaN(parsed)) return fallback;
+  return parsed;
+}
+function clamp(name, value, min, max) {
+  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}.`);
+  return clamped;
+}
 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;
+  const heartbeatIntervalSeconds = clamp(
+    "heartbeatInterval",
+    options.heartbeatInterval ?? seconds(env.RIUS_HEARTBEAT_INTERVAL, DEFAULT_HEARTBEAT_INTERVAL),
+    HEARTBEAT_INTERVAL_MIN,
+    HEARTBEAT_INTERVAL_MAX
+  );
+  const partialSpansDelaySeconds = clamp(
+    "partialSpansDelay",
+    options.partialSpansDelay ?? seconds(env.RIUS_PARTIAL_SPANS_DELAY, DEFAULT_PARTIAL_SPANS_DELAY),
+    PARTIAL_SPANS_DELAY_MIN,
+    PARTIAL_SPANS_DELAY_MAX
+  );
   return {
     endpoint,
     apiKey: options.apiKey ?? env.RIUS_API_KEY,
-    serviceName: options.serviceName ?? env.RIUS_SERVICE_NAME ?? DEFAULT_SERVICE_NAME,
+    serviceName,
     disabled: options.disabled ?? bool("RIUS_DISABLED", env.RIUS_DISABLED, false),
     sampleRate: options.sampleRate ?? rate(env.RIUS_SAMPLE_RATE, 1),
     captureContent: options.captureContent ?? bool("RIUS_CAPTURE_CONTENT", env.RIUS_CAPTURE_CONTENT, true),
-    mask: options.mask
+    mask: options.mask,
+    heartbeat: options.heartbeat ?? bool("RIUS_HEARTBEAT", env.RIUS_HEARTBEAT, true),
+    heartbeatIntervalMs: heartbeatIntervalSeconds * 1e3,
+    heartbeatEndpoint: `${endpoint}/v1/heartbeat`,
+    // 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,
+    partialSpans: options.partialSpans ?? bool("RIUS_PARTIAL_SPANS", env.RIUS_PARTIAL_SPANS, false),
+    partialSpansDelayMs: partialSpansDelaySeconds * 1e3
   };
 }
-var DEFAULT_ENDPOINT, DEFAULT_SERVICE_NAME, AFFIRMATIVE, NEGATIVE;
+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;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
+    init_esm_shims();
     DEFAULT_ENDPOINT = "https://ingest.eu.console.rius-glassflow.com";
     DEFAULT_SERVICE_NAME = "unknown_service";
+    HEARTBEAT_INTERVAL_MIN = 5;
+    HEARTBEAT_INTERVAL_MAX = 300;
+    DEFAULT_HEARTBEAT_INTERVAL = 15;
+    PARTIAL_SPANS_DELAY_MIN = 0;
+    PARTIAL_SPANS_DELAY_MAX = 60;
+    DEFAULT_PARTIAL_SPANS_DELAY = 0;
     AFFIRMATIVE = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
     NEGATIVE = /* @__PURE__ */ new Set(["0", "false", "no", "off"]);
   }
@@ -53,6 +102,7 @@ var DelegatingSpanProcessor;
 var init_delegatingProcessor = __esm({
   "src/delegatingProcessor.ts"() {
     "use strict";
+    init_esm_shims();
     DelegatingSpanProcessor = class {
       delegates = [];
       add(processor) {
@@ -90,6 +140,7 @@ var ExportResultCode;
 var init_ExportResult = __esm({
   "node_modules/@opentelemetry/core/build/esm/ExportResult.js"() {
     "use strict";
+    init_esm_shims();
     (function(ExportResultCode2) {
       ExportResultCode2[ExportResultCode2["SUCCESS"] = 0] = "SUCCESS";
       ExportResultCode2[ExportResultCode2["FAILED"] = 1] = "FAILED";
@@ -101,6 +152,7 @@ var init_ExportResult = __esm({
 var init_esm = __esm({
   "node_modules/@opentelemetry/core/build/esm/index.js"() {
     "use strict";
+    init_esm_shims();
     init_ExportResult();
   }
 });
@@ -110,6 +162,7 @@ var ExportOutcomeExporter;
 var init_exportHealth = __esm({
   "src/exportHealth.ts"() {
     "use strict";
+    init_esm_shims();
     init_esm();
     ExportOutcomeExporter = class {
       constructor(inner, onFirstFailure = (m) => console.warn(m)) {
@@ -152,6 +205,134 @@ var init_exportHealth = __esm({
   }
 });
 
+// src/heartbeat.ts
+import { randomUUID } from "crypto";
+import { createRequire } from "module";
+function httpTransport(url, headers) {
+  return async (payload, timeoutMs) => {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...headers },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    await response.body?.cancel().catch(() => {
+    });
+    if (!response.ok) {
+      throw new Error(`heartbeat POST ${url} returned ${response.status}`);
+    }
+  };
+}
+var PAYLOAD_VERSION, OPEN_TRACES_CAP, DEFAULT_PING_TIMEOUT_MS, DEFAULT_FINAL_PING_TIMEOUT_MS, SDK_VERSION, OpenRootSpanTracker, HeartbeatSender;
+var init_heartbeat = __esm({
+  "src/heartbeat.ts"() {
+    "use strict";
+    init_esm_shims();
+    PAYLOAD_VERSION = 1;
+    OPEN_TRACES_CAP = 32;
+    DEFAULT_PING_TIMEOUT_MS = 3e3;
+    DEFAULT_FINAL_PING_TIMEOUT_MS = 1e3;
+    SDK_VERSION = (() => {
+      try {
+        const pkg = createRequire(import.meta.url)("../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.
+      open = /* @__PURE__ */ new Map();
+      onStart(span, _parentContext) {
+        if (span.parentSpanContext !== void 0) return;
+        const traceId = span.spanContext().traceId;
+        this.open.set(traceId, (this.open.get(traceId) ?? 0) + 1);
+      }
+      onEnd(span) {
+        if (span.parentSpanContext !== void 0) return;
+        const traceId = span.spanContext().traceId;
+        const count = (this.open.get(traceId) ?? 0) - 1;
+        if (count <= 0) {
+          this.open.delete(traceId);
+        } else {
+          this.open.set(traceId, count);
+        }
+      }
+      /** Trace ids of currently-open root spans, in the order they opened. */
+      openTraceIds() {
+        return [...this.open.keys()];
+      }
+      async forceFlush() {
+      }
+      async shutdown() {
+      }
+    };
+    HeartbeatSender = class {
+      /** Identity of one process lifetime, fresh per sender. */
+      instanceId = randomUUID();
+      agentName;
+      tracker;
+      intervalMs;
+      pingTimeoutMs;
+      finalPingTimeoutMs;
+      send;
+      timer;
+      stopped = false;
+      deliveryWarned = false;
+      constructor(opts) {
+        this.agentName = opts.agentName;
+        this.tracker = opts.tracker;
+        this.intervalMs = opts.intervalMs;
+        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);
+      }
+      /** Starts pinging: an immediate first ping, then every `intervalMs`. */
+      start() {
+        void this.ping(this.pingTimeoutMs, false);
+        const timer = setInterval(() => void this.ping(this.pingTimeoutMs, false), this.intervalMs);
+        if (typeof timer.unref === "function") timer.unref();
+        this.timer = timer;
+      }
+      /** Stops the interval and sends the final `stopped: true` ping. Idempotent. */
+      async stop() {
+        if (this.stopped) return;
+        this.stopped = true;
+        if (this.timer !== void 0) clearInterval(this.timer);
+        await this.ping(this.finalPingTimeoutMs, true);
+      }
+      buildPayload(stopped) {
+        const openIds = this.tracker.openTraceIds();
+        const payload = {
+          v: PAYLOAD_VERSION,
+          instance_id: this.instanceId,
+          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 kindAttributes(kind) {
   const attributes = { [OPENINFERENCE_SPAN_KIND]: kind };
@@ -159,10 +340,11 @@ function kindAttributes(kind) {
   if (operation !== void 0) attributes[GEN_AI_OPERATION_NAME] = operation;
   return attributes;
 }
-var TRACER_NAME, OPENINFERENCE_SPAN_KIND, INPUT_VALUE, OUTPUT_VALUE, GEN_AI_OPERATION_NAME, GEN_AI_PROVIDER_NAME, GEN_AI_REQUEST_MODEL, GEN_AI_RESPONSE_MODEL, GEN_AI_USAGE_INPUT_TOKENS, GEN_AI_USAGE_OUTPUT_TOKENS, GEN_AI_INPUT_MESSAGES, GEN_AI_OUTPUT_MESSAGES, GEN_AI_RESPONSE_FINISH_REASONS, GEN_AI_TOOL_NAME, GEN_AI_REQUEST_PREFIX, MCP_RESULT_TYPE, GEN_AI_FIRST_TOKEN_EVENT, SpanKind, OPERATION_BY_KIND, CONTENT_ATTRIBUTES, CONTENT_ATTRIBUTE_PREFIXES, CONTENT_ATTRIBUTE_SUFFIXES;
+var TRACER_NAME, OPENINFERENCE_SPAN_KIND, INPUT_VALUE, OUTPUT_VALUE, GEN_AI_OPERATION_NAME, GEN_AI_PROVIDER_NAME, GEN_AI_REQUEST_MODEL, GEN_AI_RESPONSE_MODEL, GEN_AI_USAGE_INPUT_TOKENS, GEN_AI_USAGE_OUTPUT_TOKENS, GEN_AI_INPUT_MESSAGES, GEN_AI_OUTPUT_MESSAGES, GEN_AI_RESPONSE_FINISH_REASONS, GEN_AI_TOOL_NAME, GEN_AI_REQUEST_PREFIX, MCP_RESULT_TYPE, GEN_AI_FIRST_TOKEN_EVENT, SpanKind, OPERATION_BY_KIND, CONTENT_ATTRIBUTES, CONTENT_ATTRIBUTE_PREFIXES, CONTENT_ATTRIBUTE_SUFFIXES, GLASSFLOW_SPAN_PENDING, PENDING_IDENTITY_ATTRIBUTES, PENDING_IDENTITY_PREFIXES;
 var init_semconv = __esm({
   "src/semconv.ts"() {
     "use strict";
+    init_esm_shims();
     TRACER_NAME = "glassflow";
     OPENINFERENCE_SPAN_KIND = "openinference.span.kind";
     INPUT_VALUE = "input.value";
@@ -227,6 +409,14 @@ var init_semconv = __esm({
       ".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
+    ]);
+    PENDING_IDENTITY_PREFIXES = [GEN_AI_REQUEST_PREFIX];
   }
 });
 
@@ -255,6 +445,7 @@ function toAttributeValue(value) {
 var init_serde = __esm({
   "src/serde.ts"() {
     "use strict";
+    init_esm_shims();
   }
 });
 
@@ -292,6 +483,7 @@ var Observation;
 var init_spans = __esm({
   "src/spans.ts"() {
     "use strict";
+    init_esm_shims();
     init_client();
     init_semconv();
     init_serde();
@@ -384,6 +576,7 @@ var INPUT_REQUIRED;
 var init_instrumentationMcp = __esm({
   "src/instrumentationMcp.ts"() {
     "use strict";
+    init_esm_shims();
     init_semconv();
     init_spans();
     INPUT_REQUIRED = "input_required";
@@ -391,7 +584,7 @@ var init_instrumentationMcp = __esm({
 });
 
 // src/instrumentation.ts
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 import { join, sep } from "path";
 import { registerInstrumentations } from "@opentelemetry/instrumentation";
 function packageOf(specifier) {
@@ -437,7 +630,7 @@ function warnBroken(subject, error) {
 function cachedCjsExports(pkg, toPatchable) {
   let cache;
   try {
-    cache = createRequire(join(process.cwd(), "noop.js")).cache;
+    cache = createRequire2(join(process.cwd(), "noop.js")).cache;
   } catch {
     return void 0;
   }
@@ -506,6 +699,7 @@ var dynamicImport, REGISTRY;
 var init_instrumentation = __esm({
   "src/instrumentation.ts"() {
     "use strict";
+    init_esm_shims();
     dynamicImport = new Function("s", "return import(s)");
     REGISTRY = [
       {
@@ -600,6 +794,7 @@ var EXCEPTION_EVENT_NAME, EXCEPTION_CONTENT_KEYS, MaskingSpanExporter;
 var init_masking = __esm({
   "src/masking.ts"() {
     "use strict";
+    init_esm_shims();
     init_semconv();
     init_serde();
     EXCEPTION_EVENT_NAME = "exception";
@@ -661,6 +856,93 @@ var init_masking = __esm({
   }
 });
 
+// src/pending.ts
+import { SpanStatusCode as SpanStatusCode3 } from "@opentelemetry/api";
+function identityAttributes(attributes) {
+  if (!attributes) return {};
+  const result = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    if (PENDING_IDENTITY_ATTRIBUTES.has(key) || PENDING_IDENTITY_PREFIXES.some((p) => key.startsWith(p))) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function buildSnapshot(span) {
+  const attributes = identityAttributes(span.attributes);
+  attributes[GLASSFLOW_SPAN_PENDING] = true;
+  return {
+    name: span.name,
+    kind: span.kind,
+    spanContext: () => span.spanContext(),
+    parentSpanContext: span.parentSpanContext,
+    startTime: span.startTime,
+    endTime: span.startTime,
+    duration: [0, 0],
+    status: { code: SpanStatusCode3.UNSET },
+    attributes,
+    links: [],
+    events: [],
+    resource: span.resource,
+    instrumentationScope: span.instrumentationScope,
+    droppedAttributesCount: 0,
+    droppedEventsCount: 0,
+    droppedLinksCount: 0,
+    ended: true
+  };
+}
+function spanKey(context) {
+  return `${context.traceId}:${context.spanId}`;
+}
+var PendingSpanProcessor;
+var init_pending = __esm({
+  "src/pending.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_semconv();
+    PendingSpanProcessor = class {
+      delegate;
+      delayMs;
+      scheduled = /* @__PURE__ */ new Map();
+      constructor(delegate, opts) {
+        this.delegate = delegate;
+        this.delayMs = opts?.delayMs ?? 0;
+      }
+      onStart(span, _parentContext) {
+        if (!span.isRecording()) return;
+        const snapshot = buildSnapshot(span);
+        if (this.delayMs <= 0) {
+          this.delegate.onEnd(snapshot);
+          return;
+        }
+        const key = spanKey(span.spanContext());
+        const timer = setTimeout(() => {
+          this.scheduled.delete(key);
+          try {
+            this.delegate.onEnd(snapshot);
+          } catch {
+          }
+        }, this.delayMs);
+        if (typeof timer.unref === "function") timer.unref();
+        this.scheduled.set(key, timer);
+      }
+      onEnd(span) {
+        const key = spanKey(span.spanContext());
+        const timer = this.scheduled.get(key);
+        if (timer === void 0) return;
+        clearTimeout(timer);
+        this.scheduled.delete(key);
+      }
+      async shutdown() {
+        for (const timer of this.scheduled.values()) clearTimeout(timer);
+        this.scheduled.clear();
+      }
+      async forceFlush() {
+      }
+    };
+  }
+});
+
 // src/client.ts
 import { trace } from "@opentelemetry/api";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
@@ -681,18 +963,23 @@ function init(options = {}) {
   }
   const config = resolveConfig(options);
   const processors = new DelegatingSpanProcessor();
+  const authHeaders = config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {};
   let health;
   if (!config.disabled) {
     const base = options.spanExporter ?? new OTLPTraceExporter({
       url: `${config.endpoint}/v1/traces`,
-      headers: config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : void 0
+      headers: config.apiKey ? authHeaders : void 0
     });
     health = new ExportOutcomeExporter(base);
     const exporter = !config.captureContent || config.mask !== void 0 ? new MaskingSpanExporter(health, {
       captureContent: config.captureContent,
       mask: config.mask
     }) : health;
-    processors.add(new BatchSpanProcessor(exporter));
+    const batch = new BatchSpanProcessor(exporter);
+    if (config.partialSpans) {
+      processors.add(new PendingSpanProcessor(batch, { delayMs: config.partialSpansDelayMs }));
+    }
+    processors.add(batch);
   }
   const provider = new NodeTracerProvider({
     resource: resourceFromAttributes({ [ATTR_SERVICE_NAME]: config.serviceName }),
@@ -706,23 +993,46 @@ function init(options = {}) {
   });
   const ready = config.disabled ? Promise.resolve([]) : enableInstrumentations(processors, provider).catch(() => []);
   provider.register();
-  globalClient = createClient({ provider, processors, health, ready });
+  let heartbeat;
+  if (config.heartbeat && !config.disabled) {
+    const tracker = new OpenRootSpanTracker();
+    processors.add(tracker);
+    const sender = new HeartbeatSender({
+      url: config.heartbeatEndpoint,
+      headers: authHeaders,
+      intervalMs: config.heartbeatIntervalMs,
+      agentName: config.agentName,
+      tracker,
+      transport: options.heartbeatTransport
+    });
+    sender.start();
+    const beforeExitHandler = () => {
+      void sender.stop();
+    };
+    process.once("beforeExit", beforeExitHandler);
+    heartbeat = { sender, beforeExitHandler };
+  }
+  globalClient = createClient({ provider, processors, health, ready, heartbeat });
   return globalClient;
 }
 function getTracer() {
   return trace.getTracer(TRACER_NAME);
 }
-var sinks, createClient, RiusClient, globalClient;
+var sinks, heartbeats, createClient, RiusClient, globalClient;
 var init_client = __esm({
   "src/client.ts"() {
     "use strict";
+    init_esm_shims();
     init_config();
     init_delegatingProcessor();
     init_exportHealth();
+    init_heartbeat();
     init_instrumentation();
     init_masking();
+    init_pending();
     init_semconv();
     sinks = /* @__PURE__ */ new WeakMap();
+    heartbeats = /* @__PURE__ */ new WeakMap();
     RiusClient = class _RiusClient {
       provider;
       health;
@@ -733,6 +1043,7 @@ var init_client = __esm({
         this.health = parts.health;
         this.ready = parts.ready;
         sinks.set(this, parts.processors);
+        if (parts.heartbeat) heartbeats.set(this, parts.heartbeat);
       }
       static {
         createClient = (parts) => new _RiusClient(parts);
@@ -745,8 +1056,19 @@ var init_client = __esm({
       /**
        * Drains and tears down the provider, then releases the global registration
        * so a later init() can reconfigure the SDK.
+       *
+       * The heartbeat's final `stopped: true` ping is sent before the provider
+       * shuts down, so the backend hears "stopped" while the trace pipeline can
+       * still export it. Idempotent: `sender.stop()` no-ops on a second call, and
+       * the `beforeExit` listener is removed here so repeated init/shutdown
+       * cycles never leak listeners.
        */
       async shutdown() {
+        const heartbeat = heartbeats.get(this);
+        if (heartbeat) {
+          process.removeListener("beforeExit", heartbeat.beforeExitHandler);
+          await heartbeat.sender.stop();
+        }
         try {
           await this.provider.shutdown();
         } finally {
@@ -761,9 +1083,11 @@ var init_client = __esm({
 });
 
 // src/index.ts
+init_esm_shims();
 init_client();
 
 // src/generation.ts
+init_esm_shims();
 init_client();
 init_semconv();
 init_serde();
@@ -851,6 +1175,7 @@ function startAsCurrentGeneration(name, optionsOrFn, maybeFn) {
 }
 
 // src/observe.ts
+init_esm_shims();
 init_spans();
 function observe(fn, options = {}) {
   const name = options.name ?? (fn.name || "anonymous");
@@ -872,7 +1197,7 @@ function observe(fn, options = {}) {
 // src/index.ts
 init_semconv();
 init_spans();
-var VERSION = "0.1.0";
+var VERSION = "0.2.2";
 export {
   Generation,
   Observation,

package/package.json

@@ -1,8 +1,26 @@
 {
   "name": "@glassflow-ai/rius",
-  "version": "0.1.0",
+  "version": "0.2.2",
   "description": "OpenTelemetry-native tracing for AI agents and LLM applications",
+  "keywords": [
+    "opentelemetry",
+    "otel",
+    "observability",
+    "tracing",
+    "llm",
+    "ai-agents",
+    "genai",
+    "instrumentation",
+    "rius",
+    "glassflow"
+  ],
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/glassflow/rius-sdk-typescript.git"
+  },
+  "homepage": "https://docs.glassflow.ai/rius/sdk",
+  "bugs": "https://github.com/glassflow/rius-sdk-typescript/issues",
   "type": "module",
   "engines": {
     "node": ">=18"
@@ -22,7 +40,9 @@
       }
     }
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsup",
     "test": "vitest run",