risicare 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1268 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AgentRole: () => AgentRole,
+  MessageType: () => MessageType,
+  SemanticPhase: () => SemanticPhase,
+  SpanKind: () => SpanKind,
+  SpanStatus: () => SpanStatus,
+  agent: () => agent,
+  disable: () => disable,
+  enable: () => enable,
+  extractTraceContext: () => extractTraceContext,
+  flush: () => flush,
+  getCurrentAgent: () => getCurrentAgent,
+  getCurrentAgentId: () => getCurrentAgentId,
+  getCurrentContext: () => getCurrentContext,
+  getCurrentPhase: () => getCurrentPhase,
+  getCurrentSession: () => getCurrentSession,
+  getCurrentSessionId: () => getCurrentSessionId,
+  getCurrentSpan: () => getCurrentSpan,
+  getCurrentSpanId: () => getCurrentSpanId,
+  getCurrentTraceId: () => getCurrentTraceId,
+  getSpanById: () => getSpanById,
+  getTraceContext: () => getTraceContext,
+  getTracer: () => getTracer,
+  init: () => init,
+  injectTraceContext: () => injectTraceContext,
+  isEnabled: () => isEnabled,
+  registerSpan: () => registerSpan,
+  session: () => session,
+  shutdown: () => shutdown,
+  traceAct: () => traceAct,
+  traceCoordinate: () => traceCoordinate,
+  traceDecide: () => traceDecide,
+  traceDelegate: () => traceDelegate,
+  traceMessage: () => traceMessage,
+  traceObserve: () => traceObserve,
+  traceThink: () => traceThink,
+  unregisterSpan: () => unregisterSpan,
+  withAgent: () => withAgent,
+  withPhase: () => withPhase,
+  withSession: () => withSession
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/config.ts
+var DEFAULT_ENDPOINT = "https://app.risicare.ai";
+function resolveConfig(config) {
+  const env = process.env;
+  const apiKey = config?.apiKey ?? env.RISICARE_API_KEY;
+  const endpoint = config?.endpoint ?? env.RISICARE_ENDPOINT ?? DEFAULT_ENDPOINT;
+  const projectId = config?.projectId ?? env.RISICARE_PROJECT_ID;
+  const environment = config?.environment ?? env.RISICARE_ENVIRONMENT ?? "development";
+  const serviceName = config?.serviceName ?? env.RISICARE_SERVICE_NAME;
+  const serviceVersion = config?.serviceVersion ?? env.RISICARE_SERVICE_VERSION;
+  const traceContent = config?.traceContent ?? parseBool(env.RISICARE_TRACE_CONTENT, true);
+  const sampleRate = config?.sampleRate ?? parseFloat(env.RISICARE_SAMPLE_RATE ?? "1.0");
+  const debug2 = config?.debug ?? parseBool(env.RISICARE_DEBUG, false);
+  const batchSize = config?.batchSize ?? 100;
+  const batchTimeoutMs = config?.batchTimeoutMs ?? 1e3;
+  const maxQueueSize = config?.maxQueueSize ?? 1e4;
+  let enabled;
+  if (config?.enabled !== void 0) {
+    enabled = config.enabled;
+  } else if (env.RISICARE_TRACING !== void 0) {
+    enabled = parseBool(env.RISICARE_TRACING, false);
+  } else {
+    enabled = !!apiKey;
+  }
+  return {
+    apiKey: apiKey ?? "",
+    endpoint,
+    projectId: projectId ?? "",
+    environment,
+    serviceName: serviceName ?? "",
+    serviceVersion: serviceVersion ?? "",
+    enabled,
+    traceContent,
+    sampleRate: Math.max(0, Math.min(1, sampleRate)),
+    batchSize,
+    batchTimeoutMs,
+    maxQueueSize,
+    debug: debug2,
+    metadata: config?.metadata ?? {}
+  };
+}
+function parseBool(value, defaultValue) {
+  if (value === void 0) return defaultValue;
+  const lower = value.toLowerCase();
+  return lower === "true" || lower === "1" || lower === "yes";
+}
+
+// src/ids.ts
+var import_node_crypto = require("crypto");
+var HEX_REGEX_32 = /^[0-9a-f]{32}$/;
+var HEX_REGEX_16 = /^[0-9a-f]{16}$/;
+function generateTraceId() {
+  return (0, import_node_crypto.randomBytes)(16).toString("hex");
+}
+function generateSpanId() {
+  return (0, import_node_crypto.randomBytes)(8).toString("hex");
+}
+function generateAgentId(prefix) {
+  const suffix = (0, import_node_crypto.randomBytes)(6).toString("hex");
+  return prefix ? `${prefix}-${suffix}` : suffix;
+}
+function validateTraceId(id) {
+  return HEX_REGEX_32.test(id);
+}
+function validateSpanId(id) {
+  return HEX_REGEX_16.test(id);
+}
+
+// src/types.ts
+var SpanKind = /* @__PURE__ */ ((SpanKind2) => {
+  SpanKind2["INTERNAL"] = "internal";
+  SpanKind2["CLIENT"] = "client";
+  SpanKind2["SERVER"] = "server";
+  SpanKind2["PRODUCER"] = "producer";
+  SpanKind2["CONSUMER"] = "consumer";
+  SpanKind2["AGENT"] = "agent";
+  SpanKind2["LLM_CALL"] = "llm_call";
+  SpanKind2["TOOL_CALL"] = "tool_call";
+  SpanKind2["RETRIEVAL"] = "retrieval";
+  SpanKind2["DECISION"] = "decision";
+  SpanKind2["MESSAGE"] = "message";
+  SpanKind2["DELEGATION"] = "delegation";
+  SpanKind2["COORDINATION"] = "coordination";
+  SpanKind2["THINK"] = "think";
+  SpanKind2["DECIDE"] = "decide";
+  SpanKind2["OBSERVE"] = "observe";
+  SpanKind2["REFLECT"] = "reflect";
+  return SpanKind2;
+})(SpanKind || {});
+var SpanStatus = /* @__PURE__ */ ((SpanStatus2) => {
+  SpanStatus2["UNSET"] = "unset";
+  SpanStatus2["OK"] = "ok";
+  SpanStatus2["ERROR"] = "error";
+  return SpanStatus2;
+})(SpanStatus || {});
+var SemanticPhase = /* @__PURE__ */ ((SemanticPhase2) => {
+  SemanticPhase2["THINK"] = "think";
+  SemanticPhase2["DECIDE"] = "decide";
+  SemanticPhase2["ACT"] = "act";
+  SemanticPhase2["OBSERVE"] = "observe";
+  return SemanticPhase2;
+})(SemanticPhase || {});
+var AgentRole = /* @__PURE__ */ ((AgentRole2) => {
+  AgentRole2["ORCHESTRATOR"] = "orchestrator";
+  AgentRole2["WORKER"] = "worker";
+  AgentRole2["REVIEWER"] = "reviewer";
+  AgentRole2["PLANNER"] = "planner";
+  AgentRole2["EXECUTOR"] = "executor";
+  AgentRole2["CRITIC"] = "critic";
+  AgentRole2["CUSTOM"] = "custom";
+  return AgentRole2;
+})(AgentRole || {});
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+  MessageType2["REQUEST"] = "request";
+  MessageType2["RESPONSE"] = "response";
+  MessageType2["DELEGATE"] = "delegate";
+  MessageType2["COORDINATE"] = "coordinate";
+  MessageType2["BROADCAST"] = "broadcast";
+  return MessageType2;
+})(MessageType || {});
+
+// src/utils/clock.ts
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function hrtimeMs() {
+  return Number(process.hrtime.bigint()) / 1e6;
+}
+
+// src/span.ts
+var Span = class {
+  traceId;
+  spanId;
+  parentSpanId;
+  name;
+  kind;
+  startTime;
+  startHrtime;
+  endTime;
+  status;
+  statusMessage;
+  attributes;
+  events;
+  links;
+  // Agent/session fields
+  sessionId;
+  agentId;
+  agentName;
+  agentType;
+  semanticPhase;
+  // LLM-specific fields
+  llmProvider;
+  llmModel;
+  llmPromptTokens;
+  llmCompletionTokens;
+  llmTotalTokens;
+  llmCostUsd;
+  // Tool fields
+  toolName;
+  toolSuccess;
+  _ended = false;
+  _endHrtime;
+  _onEnd;
+  constructor(options, onEnd) {
+    this.traceId = options.traceId ?? generateTraceId();
+    this.spanId = options.spanId ?? generateSpanId();
+    this.parentSpanId = options.parentSpanId;
+    this.name = options.name;
+    this.kind = options.kind ?? "internal" /* INTERNAL */;
+    this.startTime = nowISO();
+    this.startHrtime = hrtimeMs();
+    this.status = "unset" /* UNSET */;
+    this.attributes = options.attributes ? { ...options.attributes } : {};
+    this.events = [];
+    this.links = options.links ? [...options.links] : [];
+    this.sessionId = options.sessionId;
+    this.agentId = options.agentId;
+    this.agentName = options.agentName;
+    this.agentType = options.agentType;
+    this.semanticPhase = options.semanticPhase;
+    this._onEnd = onEnd;
+  }
+  get isEnded() {
+    return this._ended;
+  }
+  get durationMs() {
+    if (this._ended && this._endHrtime !== void 0) {
+      return this._endHrtime - this.startHrtime;
+    }
+    return hrtimeMs() - this.startHrtime;
+  }
+  setAttribute(key, value) {
+    if (this._ended) return this;
+    this.attributes[key] = value;
+    return this;
+  }
+  setAttributes(attrs) {
+    if (this._ended) return this;
+    Object.assign(this.attributes, attrs);
+    return this;
+  }
+  setStatus(status, message) {
+    if (this._ended) return this;
+    this.status = status;
+    if (message !== void 0) {
+      this.statusMessage = message;
+    }
+    return this;
+  }
+  addEvent(name, attributes) {
+    if (this._ended) return this;
+    this.events.push({
+      name,
+      timestamp: nowISO(),
+      attributes
+    });
+    return this;
+  }
+  addLink(traceId, spanId, attributes) {
+    if (this._ended) return this;
+    this.links.push({ traceId, spanId, attributes });
+    return this;
+  }
+  recordException(error) {
+    if (this._ended) return this;
+    const message = typeof error === "string" ? error : error.message;
+    const stack = typeof error === "string" ? void 0 : error.stack;
+    this.setStatus("error" /* ERROR */, message);
+    this.addEvent("exception", {
+      "exception.type": typeof error === "string" ? "Error" : error.constructor.name,
+      "exception.message": message,
+      ...stack ? { "exception.stacktrace": stack } : {}
+    });
+    return this;
+  }
+  setLlmFields(fields) {
+    if (this._ended) return this;
+    if (fields.provider !== void 0) this.llmProvider = fields.provider;
+    if (fields.model !== void 0) this.llmModel = fields.model;
+    if (fields.promptTokens !== void 0) this.llmPromptTokens = fields.promptTokens;
+    if (fields.completionTokens !== void 0) this.llmCompletionTokens = fields.completionTokens;
+    if (fields.totalTokens !== void 0) this.llmTotalTokens = fields.totalTokens;
+    if (fields.costUsd !== void 0) this.llmCostUsd = fields.costUsd;
+    return this;
+  }
+  setToolFields(fields) {
+    if (this._ended) return this;
+    if (fields.name !== void 0) this.toolName = fields.name;
+    if (fields.success !== void 0) this.toolSuccess = fields.success;
+    return this;
+  }
+  end() {
+    if (this._ended) return;
+    this._ended = true;
+    this._endHrtime = hrtimeMs();
+    this.endTime = nowISO();
+    if (this.status === "unset" /* UNSET */) {
+      this.status = "ok" /* OK */;
+    }
+    this._onEnd?.(this);
+  }
+  /**
+   * Serialize to the wire format expected by the Rust gateway.
+   */
+  toPayload() {
+    const payload = {
+      traceId: this.traceId,
+      spanId: this.spanId,
+      name: this.name,
+      kind: this.kind,
+      startTime: this.startTime,
+      status: this.status,
+      attributes: this.attributes,
+      events: this.events,
+      links: this.links
+    };
+    if (this.parentSpanId !== void 0) payload.parentSpanId = this.parentSpanId;
+    if (this.endTime !== void 0) payload.endTime = this.endTime;
+    if (this._ended) payload.durationMs = this.durationMs;
+    if (this.statusMessage !== void 0) payload.statusMessage = this.statusMessage;
+    if (this.sessionId !== void 0) payload.sessionId = this.sessionId;
+    if (this.agentId !== void 0) payload.agentId = this.agentId;
+    if (this.agentName !== void 0) payload.agentName = this.agentName;
+    if (this.agentType !== void 0) payload.agentType = this.agentType;
+    if (this.semanticPhase !== void 0) payload.semanticPhase = this.semanticPhase;
+    if (this.llmProvider !== void 0) payload.llmProvider = this.llmProvider;
+    if (this.llmModel !== void 0) payload.llmModel = this.llmModel;
+    if (this.llmPromptTokens !== void 0) payload.llmPromptTokens = this.llmPromptTokens;
+    if (this.llmCompletionTokens !== void 0) payload.llmCompletionTokens = this.llmCompletionTokens;
+    if (this.llmTotalTokens !== void 0) payload.llmTotalTokens = this.llmTotalTokens;
+    if (this.llmCostUsd !== void 0) payload.llmCostUsd = this.llmCostUsd;
+    if (this.toolName !== void 0) payload.toolName = this.toolName;
+    if (this.toolSuccess !== void 0) payload.toolSuccess = this.toolSuccess;
+    return payload;
+  }
+};
+
+// src/noop.ts
+var NOOP_SPAN = Object.freeze({
+  traceId: "00000000000000000000000000000000",
+  spanId: "0000000000000000",
+  parentSpanId: void 0,
+  name: "noop",
+  kind: "internal" /* INTERNAL */,
+  startTime: "",
+  startHrtime: 0,
+  endTime: void 0,
+  status: "unset" /* UNSET */,
+  statusMessage: void 0,
+  attributes: Object.freeze({}),
+  events: Object.freeze([]),
+  links: Object.freeze([]),
+  sessionId: void 0,
+  agentId: void 0,
+  agentName: void 0,
+  semanticPhase: void 0,
+  llmProvider: void 0,
+  llmModel: void 0,
+  llmPromptTokens: void 0,
+  llmCompletionTokens: void 0,
+  llmTotalTokens: void 0,
+  llmCostUsd: void 0,
+  toolName: void 0,
+  toolSuccess: void 0,
+  isEnded: true,
+  durationMs: 0,
+  setAttribute() {
+    return this;
+  },
+  setAttributes() {
+    return this;
+  },
+  setStatus() {
+    return this;
+  },
+  addEvent() {
+    return this;
+  },
+  addLink() {
+    return this;
+  },
+  recordException() {
+    return this;
+  },
+  setLlmFields() {
+    return this;
+  },
+  setToolFields() {
+    return this;
+  },
+  end() {
+  },
+  toPayload() {
+    return {
+      traceId: this.traceId,
+      spanId: this.spanId,
+      name: this.name,
+      kind: this.kind,
+      startTime: this.startTime,
+      status: this.status,
+      attributes: {},
+      events: [],
+      links: []
+    };
+  }
+});
+
+// src/utils/sampling.ts
+function shouldSample(traceId, sampleRate) {
+  if (sampleRate >= 1) return true;
+  if (sampleRate <= 0) return false;
+  const hash = parseInt(traceId.substring(0, 8), 16);
+  return hash / 4294967295 < sampleRate;
+}
+
+// src/context/storage.ts
+var import_node_async_hooks = require("async_hooks");
+var contextStorage = new import_node_async_hooks.AsyncLocalStorage();
+function getContext() {
+  return contextStorage.getStore() ?? {};
+}
+function runWithContext(overrides, fn) {
+  const parent = getContext();
+  const merged = { ...parent, ...overrides };
+  return contextStorage.run(merged, fn);
+}
+function getCurrentSession() {
+  return getContext().session;
+}
+function getCurrentAgent() {
+  return getContext().agent;
+}
+function getCurrentSpan() {
+  return getContext().span;
+}
+function getCurrentPhase() {
+  return getContext().phase;
+}
+function getCurrentSessionId() {
+  return getContext().session?.sessionId;
+}
+function getCurrentAgentId() {
+  return getContext().agent?.agentId;
+}
+function getCurrentTraceId() {
+  return getContext().span?.traceId;
+}
+function getCurrentSpanId() {
+  return getContext().span?.spanId;
+}
+function getCurrentContext() {
+  const ctx = getContext();
+  return {
+    session: ctx.session ? { sessionId: ctx.session.sessionId, userId: ctx.session.userId } : null,
+    agent: ctx.agent ? { agentId: ctx.agent.agentId, agentName: ctx.agent.agentName, agentRole: ctx.agent.agentRole } : null,
+    span: ctx.span ? { spanId: ctx.span.spanId, traceId: ctx.span.traceId } : null,
+    phase: ctx.phase ?? null
+  };
+}
+
+// src/tracer.ts
+var Tracer = class {
+  _onSpanEnd;
+  _sampleRate;
+  _enabled;
+  constructor(config) {
+    this._onSpanEnd = config.onSpanEnd;
+    this._sampleRate = config.sampleRate ?? 1;
+    this._enabled = config.enabled ?? true;
+  }
+  get enabled() {
+    return this._enabled;
+  }
+  set enabled(value) {
+    this._enabled = value;
+  }
+  /**
+   * Start a span, run the callback within its context, and auto-end on completion.
+   *
+   * The span is automatically:
+   * - Linked to the current parent span (if any)
+   * - Given the current trace ID (or a new one for root spans)
+   * - Enriched with session/agent/phase context
+   * - Ended when the callback returns (or throws)
+   * - Marked as ERROR if the callback throws
+   *
+   * @returns The callback's return value
+   */
+  startSpan(options, fn) {
+    const opts = typeof options === "string" ? { name: options } : options;
+    if (!this._enabled) {
+      return fn(NOOP_SPAN);
+    }
+    const parentSpan = getCurrentSpan();
+    const session2 = getCurrentSession();
+    const agent2 = getCurrentAgent();
+    const phase = getCurrentPhase();
+    const traceId = opts.traceId ?? parentSpan?.traceId ?? generateTraceId();
+    if (!parentSpan && this._sampleRate < 1) {
+      if (!shouldSample(traceId, this._sampleRate)) {
+        return fn(NOOP_SPAN);
+      }
+    }
+    const parentSpanId = opts.parentSpanId ?? parentSpan?.spanId;
+    const spanOptions = {
+      name: opts.name,
+      kind: opts.kind ?? "internal" /* INTERNAL */,
+      traceId,
+      parentSpanId,
+      attributes: opts.attributes,
+      sessionId: session2?.sessionId,
+      agentId: agent2?.agentId,
+      agentName: agent2?.agentName,
+      agentType: agent2?.agentType,
+      semanticPhase: phase
+    };
+    const span = new Span(spanOptions, this._onSpanEnd);
+    try {
+      const result = runWithContext({ span }, () => fn(span));
+      if (result instanceof Promise) {
+        return result.then(
+          (value) => {
+            span.end();
+            return value;
+          },
+          (error) => {
+            span.recordException(error instanceof Error ? error : String(error));
+            span.end();
+            throw error;
+          }
+        );
+      }
+      span.end();
+      return result;
+    } catch (error) {
+      span.recordException(error instanceof Error ? error : String(error));
+      span.end();
+      throw error;
+    }
+  }
+  /**
+   * Create a span without auto-ending. Caller is responsible for calling span.end().
+   *
+   * Useful for long-running operations where you need manual control.
+   * The span is still linked to context and enriched with session/agent/phase.
+   */
+  createSpan(options) {
+    const opts = typeof options === "string" ? { name: options } : options;
+    if (!this._enabled) {
+      return NOOP_SPAN;
+    }
+    const parentSpan = getCurrentSpan();
+    const session2 = getCurrentSession();
+    const agent2 = getCurrentAgent();
+    const phase = getCurrentPhase();
+    const traceId = opts.traceId ?? parentSpan?.traceId ?? generateTraceId();
+    if (!parentSpan && this._sampleRate < 1) {
+      if (!shouldSample(traceId, this._sampleRate)) {
+        return NOOP_SPAN;
+      }
+    }
+    const parentSpanId = opts.parentSpanId ?? parentSpan?.spanId;
+    return new Span(
+      {
+        name: opts.name,
+        kind: opts.kind ?? "internal" /* INTERNAL */,
+        traceId,
+        parentSpanId,
+        attributes: opts.attributes,
+        sessionId: session2?.sessionId,
+        agentId: agent2?.agentId,
+        agentName: agent2?.agentName,
+        agentType: agent2?.agentType,
+        semanticPhase: phase
+      },
+      this._onSpanEnd
+    );
+  }
+};
+
+// src/utils/log.ts
+var _debug = false;
+function setDebug(enabled) {
+  _debug = enabled;
+}
+function debug(msg) {
+  if (_debug) {
+    process.stderr.write(`[risicare] ${msg}
+`);
+  }
+}
+function warn(msg) {
+  process.stderr.write(`[risicare] WARNING: ${msg}
+`);
+}
+
+// src/exporters/batch.ts
+var BatchSpanProcessor = class {
+  _exporters;
+  _batchSize;
+  _batchTimeoutMs;
+  _maxQueueSize;
+  _debug;
+  _queue = [];
+  _timer = null;
+  _started = false;
+  _flushing = false;
+  // Metrics
+  droppedSpans = 0;
+  exportedSpans = 0;
+  failedExports = 0;
+  constructor(options) {
+    this._exporters = [...options.exporters];
+    this._batchSize = options.batchSize ?? 100;
+    this._batchTimeoutMs = options.batchTimeoutMs ?? 1e3;
+    this._maxQueueSize = options.maxQueueSize ?? 1e4;
+    this._debug = options.debug ?? false;
+  }
+  start() {
+    if (this._started) return;
+    this._started = true;
+    this._timer = setInterval(() => {
+      void this._exportBatch();
+    }, this._batchTimeoutMs);
+    this._timer.unref();
+    process.on("beforeExit", () => {
+      void this.shutdown();
+    });
+  }
+  async shutdown(timeoutMs = 5e3) {
+    if (!this._started) return;
+    this._started = false;
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+    const flushPromise = this._exportBatch();
+    const timeoutPromise = new Promise((resolve) => setTimeout(resolve, timeoutMs));
+    await Promise.race([flushPromise, timeoutPromise]);
+    for (const exporter of this._exporters) {
+      try {
+        await exporter.shutdown();
+      } catch (e) {
+        debug(`Error shutting down ${exporter.name}: ${e}`);
+      }
+    }
+    debug(
+      `BatchSpanProcessor shutdown. Exported: ${this.exportedSpans}, Dropped: ${this.droppedSpans}, Failed: ${this.failedExports}`
+    );
+  }
+  onSpanEnd(span) {
+    if (!this._started) return;
+    if (this._queue.length >= this._maxQueueSize) {
+      this.droppedSpans++;
+      if (this.droppedSpans === 1 || this.droppedSpans % 1e3 === 0) {
+        warn(`Span queue full (${this._maxQueueSize}). ${this.droppedSpans} spans dropped so far.`);
+      }
+      return;
+    }
+    this._queue.push(span);
+    if (this._queue.length >= this._batchSize) {
+      void this._exportBatch();
+    }
+  }
+  async flush(timeoutMs = 5e3) {
+    if (!this._started) return true;
+    const start = Date.now();
+    while (this._queue.length > 0 || this._flushing) {
+      if (!this._flushing && this._queue.length > 0) {
+        await this._exportBatch();
+      } else {
+        await new Promise((r) => setTimeout(r, 1));
+      }
+      if (Date.now() - start > timeoutMs) return false;
+    }
+    return true;
+  }
+  getMetrics() {
+    return {
+      exportedSpans: this.exportedSpans,
+      droppedSpans: this.droppedSpans,
+      failedExports: this.failedExports,
+      queueSize: this._queue.length,
+      queueCapacity: this._maxQueueSize,
+      queueUtilization: this._queue.length / this._maxQueueSize
+    };
+  }
+  async _exportBatch() {
+    if (this._flushing || this._queue.length === 0) return;
+    this._flushing = true;
+    try {
+      const batch = this._queue.splice(0, this._batchSize);
+      if (batch.length === 0) return;
+      debug(`Exporting batch of ${batch.length} spans`);
+      let batchExported = false;
+      for (const exporter of this._exporters) {
+        try {
+          const result = await exporter.export(batch);
+          if (result === "success" /* SUCCESS */) {
+            if (!batchExported) {
+              this.exportedSpans += batch.length;
+              batchExported = true;
+            }
+          } else {
+            this.failedExports++;
+          }
+        } catch (e) {
+          this.failedExports++;
+          debug(`Export to ${exporter.name} failed: ${e}`);
+        }
+      }
+    } finally {
+      this._flushing = false;
+    }
+  }
+};
+
+// src/exporters/http.ts
+var HttpExporter = class {
+  name = "http";
+  _endpoint;
+  _apiKey;
+  _projectId;
+  _environment;
+  _timeoutMs;
+  _maxRetries;
+  _compress;
+  // Circuit breaker
+  _consecutiveFailures = 0;
+  _circuitOpenUntil = 0;
+  _circuitBreakerThreshold = 3;
+  _circuitBreakerCooldownMs = 3e4;
+  constructor(options) {
+    this._endpoint = options.endpoint.replace(/\/+$/, "");
+    this._apiKey = options.apiKey;
+    this._projectId = options.projectId;
+    this._environment = options.environment;
+    this._timeoutMs = options.timeoutMs ?? 5e3;
+    this._maxRetries = options.maxRetries ?? 3;
+    this._compress = options.compress ?? false;
+  }
+  async export(spans) {
+    if (spans.length === 0) return "success" /* SUCCESS */;
+    const now = Date.now();
+    if (this._consecutiveFailures >= this._circuitBreakerThreshold) {
+      if (now < this._circuitOpenUntil) {
+        return "failure" /* FAILURE */;
+      }
+    }
+    const body = {
+      spans: spans.map((s) => s.toPayload())
+    };
+    if (this._projectId) body.projectId = this._projectId;
+    if (this._environment) body.environment = this._environment;
+    for (let attempt = 0; attempt < this._maxRetries; attempt++) {
+      const result = await this._sendRequest(body);
+      if (result === "success" /* SUCCESS */) {
+        this._consecutiveFailures = 0;
+        return result;
+      }
+      if (attempt < this._maxRetries - 1) {
+        await sleep(100 * Math.pow(2, attempt));
+      }
+    }
+    this._consecutiveFailures++;
+    if (this._consecutiveFailures >= this._circuitBreakerThreshold) {
+      this._circuitOpenUntil = Date.now() + this._circuitBreakerCooldownMs;
+      warn(
+        `HTTP exporter circuit breaker opened after ${this._consecutiveFailures} failures. Cooldown: ${this._circuitBreakerCooldownMs / 1e3}s`
+      );
+    }
+    return "failure" /* FAILURE */;
+  }
+  async _sendRequest(body) {
+    const url = `${this._endpoint}/v1/spans`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this._apiKey) {
+      headers["Authorization"] = `Bearer ${this._apiKey}`;
+    }
+    let payload = JSON.stringify(body);
+    if (this._compress && payload.length > 1024) {
+      try {
+        const { gzipSync } = await import("zlib");
+        payload = gzipSync(Buffer.from(payload));
+        headers["Content-Encoding"] = "gzip";
+      } catch {
+      }
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this._timeoutMs);
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: payload,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.status < 300) {
+        return "success" /* SUCCESS */;
+      } else if (response.status === 408 || response.status === 504) {
+        debug(`HTTP export timeout: ${response.status}`);
+        return "timeout" /* TIMEOUT */;
+      }
+      debug(`HTTP export failed: ${response.status}`);
+      return "failure" /* FAILURE */;
+    } catch (e) {
+      debug(`HTTP export error: ${e}`);
+      return "failure" /* FAILURE */;
+    }
+  }
+  shutdown() {
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/exporters/console.ts
+var ConsoleExporter = class {
+  name = "console";
+  export(spans) {
+    for (const span of spans) {
+      const payload = span.toPayload();
+      const line = JSON.stringify(payload);
+      process.stderr.write(`[risicare] ${line}
+`);
+    }
+    return "success" /* SUCCESS */;
+  }
+  shutdown() {
+  }
+};
+
+// src/client.ts
+var _client;
+var _tracer;
+var RisicareClient = class {
+  config;
+  processor;
+  tracer;
+  _shutdownCalled = false;
+  constructor(config) {
+    this.config = resolveConfig(config);
+    let exporter;
+    if (this.config.debug && !this.config.apiKey) {
+      exporter = new ConsoleExporter();
+    } else if (this.config.apiKey) {
+      exporter = new HttpExporter({
+        endpoint: this.config.endpoint,
+        apiKey: this.config.apiKey,
+        projectId: this.config.projectId || void 0,
+        environment: this.config.environment || void 0
+      });
+    } else {
+      exporter = new ConsoleExporter();
+    }
+    this.processor = new BatchSpanProcessor({
+      exporters: [exporter],
+      batchSize: this.config.batchSize,
+      batchTimeoutMs: this.config.batchTimeoutMs,
+      maxQueueSize: this.config.maxQueueSize,
+      debug: this.config.debug
+    });
+    this.tracer = new Tracer({
+      onSpanEnd: (span) => this.processor.onSpanEnd(span),
+      sampleRate: this.config.sampleRate,
+      enabled: this.config.enabled
+    });
+    this.processor.start();
+    this._registerShutdownHooks();
+    setDebug(this.config.debug);
+    debug(`Initialized: enabled=${this.config.enabled}, endpoint=${this.config.endpoint}`);
+  }
+  get enabled() {
+    return this.tracer.enabled;
+  }
+  set enabled(value) {
+    this.tracer.enabled = value;
+  }
+  async shutdown() {
+    if (this._shutdownCalled) return;
+    this._shutdownCalled = true;
+    debug("Shutting down...");
+    await this.processor.shutdown();
+  }
+  async flush() {
+    await this.processor.flush();
+  }
+  _registerShutdownHooks() {
+    const onShutdown = () => {
+      this.shutdown().catch(() => {
+      });
+    };
+    process.once("beforeExit", onShutdown);
+    process.once("SIGTERM", onShutdown);
+    process.once("SIGINT", onShutdown);
+  }
+};
+function init(config) {
+  if (_client) {
+    debug("Already initialized. Call shutdown() first to re-initialize.");
+    return;
+  }
+  _client = new RisicareClient(config);
+  _tracer = _client.tracer;
+}
+async function shutdown() {
+  if (!_client) return;
+  await _client.shutdown();
+  _client = void 0;
+  _tracer = void 0;
+}
+async function flush() {
+  if (!_client) return;
+  await _client.flush();
+}
+function enable() {
+  if (_client) _client.enabled = true;
+}
+function disable() {
+  if (_client) _client.enabled = false;
+}
+function isEnabled() {
+  return _client?.enabled ?? false;
+}
+function getTracer() {
+  return _tracer;
+}
+
+// src/context/agent.ts
+function withAgent(options, fn) {
+  if (!isEnabled()) return fn();
+  const parent = getCurrentAgent();
+  const agentName = options.name ?? "agent";
+  const agent2 = {
+    agentId: options.agentId ?? generateAgentId(agentName),
+    agentName,
+    agentRole: options.role,
+    agentType: options.agentType,
+    parentAgentId: parent?.agentId,
+    version: options.version,
+    metadata: options.metadata
+  };
+  return runWithContext({ agent: agent2 }, fn);
+}
+
+// src/decorators/agent.ts
+function agent(options, fn) {
+  const spanName = `agent:${options.name ?? "agent"}`;
+  return (...args) => {
+    const tracer = getTracer();
+    if (!tracer) {
+      return fn(...args);
+    }
+    return withAgent(options, () => {
+      return tracer.startSpan({ name: spanName, kind: "agent" /* AGENT */ }, () => {
+        return fn(...args);
+      });
+    });
+  };
+}
+
+// src/context/session.ts
+function withSession(options, fn) {
+  if (!isEnabled()) return fn();
+  const session2 = {
+    sessionId: options.sessionId,
+    userId: options.userId,
+    metadata: options.metadata,
+    parentSessionId: options.parentSessionId,
+    turnNumber: options.turnNumber ?? 1
+  };
+  return runWithContext({ session: session2 }, fn);
+}
+
+// src/decorators/session.ts
+function session(optionsOrResolver, fn) {
+  return (...args) => {
+    const options = typeof optionsOrResolver === "function" ? optionsOrResolver(...args) : optionsOrResolver;
+    return withSession(options, () => fn(...args));
+  };
+}
+
+// src/context/phase.ts
+function withPhase(phase, fn) {
+  if (!isEnabled()) return fn();
+  return runWithContext({ phase }, fn);
+}
+
+// src/decorators/phase.ts
+function phaseWrapper(phase, fn) {
+  return (...args) => {
+    const tracer = getTracer();
+    if (!tracer) {
+      return fn(...args);
+    }
+    return withPhase(phase, () => {
+      return tracer.startSpan({ name: `phase:${phase}` }, () => fn(...args));
+    });
+  };
+}
+function traceThink(fn) {
+  return phaseWrapper("think" /* THINK */, fn);
+}
+function traceDecide(fn) {
+  return phaseWrapper("decide" /* DECIDE */, fn);
+}
+function traceAct(fn) {
+  return phaseWrapper("act" /* ACT */, fn);
+}
+function traceObserve(fn) {
+  return phaseWrapper("observe" /* OBSERVE */, fn);
+}
+
+// src/decorators/multi-agent.ts
+function namespacedMetadata(metadata) {
+  if (!metadata) return {};
+  const result = {};
+  for (const [key, value] of Object.entries(metadata)) {
+    result[`metadata.${key}`] = value;
+  }
+  return result;
+}
+function traceMessage(options, fn) {
+  const msgType = options.type ?? "request" /* REQUEST */;
+  return (...args) => {
+    const tracer = getTracer();
+    if (!tracer) return fn(...args);
+    return tracer.startSpan(
+      {
+        name: `message:${msgType}\u2192${options.to}`,
+        kind: "message" /* MESSAGE */,
+        attributes: {
+          ...namespacedMetadata(options.metadata),
+          "message.to": options.to,
+          "message.type": msgType,
+          "message.target_agent_id": options.to
+        }
+      },
+      () => fn(...args)
+    );
+  };
+}
+function traceDelegate(options, fn) {
+  return (...args) => {
+    const tracer = getTracer();
+    if (!tracer) return fn(...args);
+    return tracer.startSpan(
+      {
+        name: `delegate\u2192${options.to}`,
+        kind: "delegation" /* DELEGATION */,
+        attributes: {
+          ...namespacedMetadata(options.metadata),
+          "delegate.to": options.to,
+          "message.type": "delegate" /* DELEGATE */,
+          "message.target_agent_id": options.to
+        }
+      },
+      () => fn(...args)
+    );
+  };
+}
+function traceCoordinate(options, fn) {
+  return (...args) => {
+    const tracer = getTracer();
+    if (!tracer) return fn(...args);
+    return tracer.startSpan(
+      {
+        name: `coordinate:[${options.participants.join(",")}]`,
+        kind: "coordination" /* COORDINATION */,
+        attributes: {
+          ...namespacedMetadata(options.metadata),
+          "coordinate.participants": options.participants.join(","),
+          "message.type": "coordinate" /* COORDINATE */
+        }
+      },
+      () => fn(...args)
+    );
+  };
+}
+
+// src/context/trace-context.ts
+function getTraceContext() {
+  const span = getCurrentSpan();
+  const session2 = getCurrentSession();
+  const agent2 = getCurrentAgent();
+  return {
+    traceId: span?.traceId ?? generateTraceId(),
+    spanId: span?.spanId ?? generateSpanId(),
+    sessionId: session2?.sessionId,
+    agentId: agent2?.agentId
+  };
+}
+var TRACEPARENT_HEADER = "traceparent";
+var TRACESTATE_HEADER = "tracestate";
+var RISICARE_STATE_DELIMITER = ";";
+function injectTraceContext(headers) {
+  const span = getCurrentSpan();
+  const session2 = getCurrentSession();
+  const agent2 = getCurrentAgent();
+  if (span) {
+    headers[TRACEPARENT_HEADER] = `00-${span.traceId}-${span.spanId}-01`;
+    const parts = [];
+    if (session2) parts.push(`session_id=${session2.sessionId}`);
+    if (agent2) parts.push(`agent_id=${agent2.agentId}`);
+    if (parts.length > 0) {
+      const riscareEntry = `risicare=${parts.join(RISICARE_STATE_DELIMITER)}`;
+      const existing = headers[TRACESTATE_HEADER] ?? "";
+      const otherEntries = existing.split(",").map((e) => e.trim()).filter((e) => e && !e.startsWith("risicare="));
+      headers[TRACESTATE_HEADER] = [riscareEntry, ...otherEntries].join(",");
+    }
+  }
+  return headers;
+}
+function extractTraceContext(headers) {
+  const result = {};
+  const normalizedHeaders = {};
+  for (const [key, value] of Object.entries(headers)) {
+    normalizedHeaders[key.toLowerCase()] = value;
+  }
+  const traceparent = normalizedHeaders[TRACEPARENT_HEADER] ?? "";
+  if (traceparent) {
+    const parts = traceparent.split("-");
+    if (parts.length >= 4) {
+      const traceId = parts[1].toLowerCase();
+      const spanId = parts[2].toLowerCase();
+      if (validateTraceId(traceId)) result.traceId = traceId;
+      if (validateSpanId(spanId)) result.parentSpanId = spanId;
+      result.flags = parts[3];
+    }
+  }
+  const tracestate = normalizedHeaders[TRACESTATE_HEADER] ?? "";
+  if (tracestate) {
+    for (const entry of tracestate.split(",")) {
+      const trimmed = entry.trim();
+      if (trimmed.startsWith("risicare=")) {
+        const state = trimmed.slice(9);
+        for (const kv of state.split(RISICARE_STATE_DELIMITER)) {
+          const eqIdx = kv.indexOf("=");
+          if (eqIdx > 0) {
+            const key = kv.slice(0, eqIdx).trim();
+            const value = kv.slice(eqIdx + 1).trim();
+            if (key && value) result[key] = value;
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// src/context/registry.ts
+var DEFAULT_TTL_MS = 6e4;
+var MAX_ENTRIES = 1e4;
+var CLEANUP_INTERVAL = 100;
+var entries = /* @__PURE__ */ new Map();
+var operationCount = 0;
+function registerSpan(span, ttlMs = DEFAULT_TTL_MS) {
+  entries.set(span.spanId, {
+    span,
+    registeredAt: Date.now(),
+    ttlMs
+  });
+  operationCount++;
+  maybeCleanup();
+}
+function getSpanById(spanId) {
+  const entry = entries.get(spanId);
+  if (!entry) return void 0;
+  if (Date.now() - entry.registeredAt > entry.ttlMs) {
+    entries.delete(spanId);
+    return void 0;
+  }
+  return entry.span;
+}
+function unregisterSpan(spanId) {
+  entries.delete(spanId);
+}
+function maybeCleanup() {
+  if (operationCount % CLEANUP_INTERVAL !== 0) return;
+  if (entries.size <= MAX_ENTRIES) return;
+  const now = Date.now();
+  for (const [id, entry] of entries) {
+    if (now - entry.registeredAt > entry.ttlMs) {
+      entries.delete(id);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentRole,
+  MessageType,
+  SemanticPhase,
+  SpanKind,
+  SpanStatus,
+  agent,
+  disable,
+  enable,
+  extractTraceContext,
+  flush,
+  getCurrentAgent,
+  getCurrentAgentId,
+  getCurrentContext,
+  getCurrentPhase,
+  getCurrentSession,
+  getCurrentSessionId,
+  getCurrentSpan,
+  getCurrentSpanId,
+  getCurrentTraceId,
+  getSpanById,
+  getTraceContext,
+  getTracer,
+  init,
+  injectTraceContext,
+  isEnabled,
+  registerSpan,
+  session,
+  shutdown,
+  traceAct,
+  traceCoordinate,
+  traceDecide,
+  traceDelegate,
+  traceMessage,
+  traceObserve,
+  traceThink,
+  unregisterSpan,
+  withAgent,
+  withPhase,
+  withSession
+});
+//# sourceMappingURL=index.cjs.map