@smthrs/observability 0.33.0

package/src/agentSessionEventToOtelLogRecord.js

@@ -0,0 +1,55 @@
+import { buildOtelAttributes, buildOtelLogRecord, inferSessionSeverity } from "./_otelLogBuilders.js";
+/**
+ * @typedef {import('./agentTrace.ts').AgentSessionTranscriptEvent} AgentSessionTranscriptEvent
+ * @typedef {import('./_otelLogBuilders.js').OtelLogRecord} OtelLogRecord
+ */
+
+/**
+ * @param {AgentSessionTranscriptEvent} event
+ * @param {{ agentId?: string; model?: string }} [context]
+ * @returns {OtelLogRecord}
+ */
+export function agentSessionEventToOtelLogRecord(event, context) {
+  const attributes = buildOtelAttributes(
+    {
+      "smithers.event.category": "agent-session",
+      "smithers.trace.version": undefined,
+      "smithers.transcript.version": event.transcriptVersion,
+      "run.id": event.runId,
+      "workflow.path": event.workflowPath,
+      "workflow.hash": event.workflowHash,
+      "node.id": event.nodeId,
+      "node.iteration": event.iteration,
+      "node.attempt": event.attempt,
+      "agent.family": event.source.agentFamily,
+      "agent.id": context?.agentId,
+      "agent.model": context?.model,
+      "agent.capture_mode": event.source.captureMode,
+      "trace.completeness": undefined,
+      "event.kind": undefined,
+      "event.phase": undefined,
+      "event.sequence": undefined,
+      "source.raw_type": undefined,
+      "source.raw_event_id": undefined,
+      "source.observed": undefined,
+      "provider.session_id": event.source.providerSessionId,
+      "provider.thread_id": event.source.providerThreadId,
+      "session.ingest_source": event.source.ingestSource,
+      "session.observed_live": event.source.observedLive,
+      "session.row_type": event.event.rowType,
+      "session.row_sequence": event.event.sequence,
+    },
+    event.annotations,
+  );
+  return buildOtelLogRecord(
+    {
+      category: "agent-session",
+      payload: undefined,
+      raw: event.raw,
+      redaction: event.redaction,
+      annotations: event.annotations,
+    },
+    attributes,
+    inferSessionSeverity(event.raw),
+  );
+}

package/src/agentTrace.ts

@@ -0,0 +1,144 @@
+export type AgentFamily =
+  | "pi"
+  | "codex"
+  | "claude-code"
+  | "antigravity"
+  | "gemini"
+  | "kimi"
+  | "openai"
+  | "anthropic"
+  | "amp"
+  | "forge"
+  | "unknown";
+
+export type AgentCaptureMode =
+  | "sdk-events"
+  | "rpc-events"
+  | "cli-json-stream"
+  | "cli-json"
+  | "cli-text"
+  | "artifact-import";
+
+export type TraceCompleteness = "full-observed" | "partial-observed" | "final-only" | "capture-failed";
+
+export type CanonicalAgentTraceEventKind =
+  | "session.start"
+  | "session.end"
+  | "turn.start"
+  | "turn.end"
+  | "message.start"
+  | "message.update"
+  | "message.end"
+  | "assistant.text.delta"
+  | "assistant.thinking.delta"
+  | "assistant.message.final"
+  | "tool.execution.start"
+  | "tool.execution.update"
+  | "tool.execution.end"
+  | "tool.result"
+  | "retry.start"
+  | "retry.end"
+  | "compaction.start"
+  | "compaction.end"
+  | "stderr"
+  | "stdout"
+  | "usage"
+  | "capture.warning"
+  | "capture.error"
+  | "artifact.created";
+
+export type CanonicalAgentTraceEventPhase = "agent" | "turn" | "message" | "tool" | "session" | "capture" | "artifact";
+
+export type CanonicalAgentTraceEvent = {
+  traceVersion: "1";
+  runId: string;
+  workflowPath?: string;
+  workflowHash?: string;
+  nodeId: string;
+  iteration: number;
+  attempt: number;
+  timestampMs: number;
+  event: {
+    sequence: number;
+    kind: CanonicalAgentTraceEventKind;
+    phase: CanonicalAgentTraceEventPhase;
+  };
+  source: {
+    agentFamily: AgentFamily;
+    captureMode: AgentCaptureMode;
+    rawType?: string;
+    rawEventId?: string;
+    observed: boolean;
+  };
+  traceCompleteness: TraceCompleteness;
+  payload: Record<string, unknown> | null;
+  raw: unknown;
+  redaction: {
+    applied: boolean;
+    ruleIds: string[];
+  };
+  annotations: Record<string, string | number | boolean>;
+};
+
+export type AgentTraceSummary = {
+  traceVersion: "1";
+  runId: string;
+  workflowPath?: string;
+  workflowHash?: string;
+  nodeId: string;
+  iteration: number;
+  attempt: number;
+  traceStartedAtMs: number;
+  traceFinishedAtMs: number;
+  agentFamily: AgentFamily;
+  agentId?: string;
+  model?: string;
+  captureMode: AgentCaptureMode;
+  traceCompleteness: TraceCompleteness;
+  unsupportedEventKinds: CanonicalAgentTraceEventKind[];
+  missingExpectedEventKinds: CanonicalAgentTraceEventKind[];
+  rawArtifactRefs: string[];
+};
+
+export type AgentSessionTranscriptEvent = {
+  transcriptVersion: "1";
+  runId: string;
+  workflowPath?: string;
+  workflowHash?: string;
+  nodeId: string;
+  iteration: number;
+  attempt: number;
+  timestampMs: number;
+  event: {
+    sequence: number;
+    rowType: string;
+  };
+  source: {
+    agentFamily: AgentFamily;
+    captureMode: AgentCaptureMode;
+    ingestSource: "live" | "artifact";
+    observedLive: boolean;
+    providerSessionId?: string;
+    providerThreadId?: string;
+  };
+  raw: unknown;
+  redaction: {
+    applied: boolean;
+    ruleIds: string[];
+  };
+  annotations: Record<string, string | number | boolean>;
+};
+
+export type AgentTraceCapabilityProfile = {
+  sessionMetadata: boolean;
+  assistantTextDeltas: boolean;
+  visibleThinkingDeltas: boolean;
+  finalAssistantMessage: boolean;
+  toolExecutionStart: boolean;
+  toolExecutionUpdate: boolean;
+  toolExecutionEnd: boolean;
+  retryEvents: boolean;
+  compactionEvents: boolean;
+  rawStderrDiagnostics: boolean;
+  persistedSessionArtifact: boolean;
+};

package/src/agentTraceCapabilities.js

@@ -0,0 +1,151 @@
+/**
+ * @typedef {import('./agentTrace.ts').AgentFamily} AgentFamily
+ * @typedef {import('./agentTrace.ts').AgentTraceCapabilityProfile} AgentTraceCapabilityProfile
+ */
+
+/** @type {Record<AgentFamily, AgentTraceCapabilityProfile>} */
+export const agentTraceCapabilities = {
+  pi: {
+    sessionMetadata: true,
+    assistantTextDeltas: true,
+    visibleThinkingDeltas: true,
+    finalAssistantMessage: true,
+    toolExecutionStart: true,
+    toolExecutionUpdate: true,
+    toolExecutionEnd: true,
+    retryEvents: true,
+    compactionEvents: true,
+    rawStderrDiagnostics: true,
+    persistedSessionArtifact: true,
+  },
+  codex: {
+    sessionMetadata: false,
+    assistantTextDeltas: false,
+    visibleThinkingDeltas: false,
+    finalAssistantMessage: true,
+    toolExecutionStart: false,
+    toolExecutionUpdate: false,
+    toolExecutionEnd: false,
+    retryEvents: false,
+    compactionEvents: false,
+    rawStderrDiagnostics: true,
+    persistedSessionArtifact: false,
+  },
+  "claude-code": {
+    sessionMetadata: false,
+    assistantTextDeltas: true,
+    visibleThinkingDeltas: false,
+    finalAssistantMessage: true,
+    toolExecutionStart: false,
+    toolExecutionUpdate: false,
+    toolExecutionEnd: false,
+    retryEvents: false,
+    compactionEvents: false,
+    rawStderrDiagnostics: true,
+    persistedSessionArtifact: false,
+  },
+  antigravity: {
+    sessionMetadata: false,
+    assistantTextDeltas: false,
+    visibleThinkingDeltas: false,
+    finalAssistantMessage: true,
+    toolExecutionStart: false,
+    toolExecutionUpdate: false,
+    toolExecutionEnd: false,
+    retryEvents: false,
+    compactionEvents: false,
+    rawStderrDiagnostics: true,
+    persistedSessionArtifact: false,
+  },
+  gemini: {
+    sessionMetadata: false,
+    assistantTextDeltas: false,
+    visibleThinkingDeltas: false,
+    finalAssistantMessage: true,
+    toolExecutionStart: false,
+    toolExecutionUpdate: false,
+    toolExecutionEnd: false,
+    retryEvents: false,
+    compactionEvents: false,
+    rawStderrDiagnostics: true,
+    persistedSessionArtifact: false,
+  },
+  kimi: {
+    sessionMetadata: false,
+    assistantTextDeltas: false,
+    visibleThinkingDeltas: false,
+    finalAssistantMessage: true,
+    toolExecutionStart: false,
+    toolExecutionUpdate: false,
+    toolExecutionEnd: false,
+    retryEvents: false,
+    compactionEvents: false,
+    rawStderrDiagnostics: true,
+    persistedSessionArtifact: false,
+  },
+  openai: {
+    sessionMetadata: false,
+    assistantTextDeltas: false,
+    visibleThinkingDeltas: false,
+    finalAssistantMessage: true,
+    toolExecutionStart: true,
+    toolExecutionUpdate: false,
+    toolExecutionEnd: true,
+    retryEvents: false,
+    compactionEvents: false,
+    rawStderrDiagnostics: false,
+    persistedSessionArtifact: false,
+  },
+  anthropic: {
+    sessionMetadata: false,
+    assistantTextDeltas: false,
+    visibleThinkingDeltas: false,
+    finalAssistantMessage: true,
+    toolExecutionStart: true,
+    toolExecutionUpdate: false,
+    toolExecutionEnd: true,
+    retryEvents: false,
+    compactionEvents: false,
+    rawStderrDiagnostics: false,
+    persistedSessionArtifact: false,
+  },
+  amp: {
+    sessionMetadata: false,
+    assistantTextDeltas: false,
+    visibleThinkingDeltas: false,
+    finalAssistantMessage: true,
+    toolExecutionStart: true,
+    toolExecutionUpdate: false,
+    toolExecutionEnd: true,
+    retryEvents: false,
+    compactionEvents: false,
+    rawStderrDiagnostics: true,
+    persistedSessionArtifact: false,
+  },
+  forge: {
+    sessionMetadata: false,
+    assistantTextDeltas: false,
+    visibleThinkingDeltas: false,
+    finalAssistantMessage: true,
+    toolExecutionStart: true,
+    toolExecutionUpdate: false,
+    toolExecutionEnd: true,
+    retryEvents: false,
+    compactionEvents: false,
+    rawStderrDiagnostics: true,
+    persistedSessionArtifact: false,
+  },
+  unknown: {
+    sessionMetadata: false,
+    assistantTextDeltas: false,
+    visibleThinkingDeltas: false,
+    finalAssistantMessage: true,
+    toolExecutionStart: true,
+    toolExecutionUpdate: false,
+    toolExecutionEnd: true,
+    retryEvents: false,
+    compactionEvents: false,
+    rawStderrDiagnostics: true,
+    persistedSessionArtifact: false,
+  },
+};

package/src/annotateSmithersTrace.js

@@ -0,0 +1,11 @@
+import { TracingService, annotateSmithersTrace as annotateCoreSmithersTrace } from "./_coreTracing.js";
+import { Effect } from "effect";
+/**
+ * @param {Readonly<Record<string, unknown>>} [attributes]
+ * @returns {Effect.Effect<void>}
+ */
+export function annotateSmithersTrace(attributes = {}) {
+  return Effect.flatMap(Effect.serviceOption(TracingService), (service) =>
+    service._tag === "Some" ? service.value.annotate({ ...attributes }) : annotateCoreSmithersTrace(attributes),
+  );
+}

package/src/canonicalTraceEventToOtelLogRecord.js

@@ -0,0 +1,55 @@
+import { buildOtelAttributes, buildOtelLogRecord, inferCanonicalSeverity } from "./_otelLogBuilders.js";
+/**
+ * @typedef {import('./agentTrace.ts').CanonicalAgentTraceEvent} CanonicalAgentTraceEvent
+ * @typedef {import('./_otelLogBuilders.js').OtelLogRecord} OtelLogRecord
+ */
+
+/**
+ * @param {CanonicalAgentTraceEvent} event
+ * @param {{ agentId?: string; model?: string }} [context]
+ * @returns {OtelLogRecord}
+ */
+export function canonicalTraceEventToOtelLogRecord(event, context) {
+  const attributes = buildOtelAttributes(
+    {
+      "smithers.event.category": "agent-trace",
+      "smithers.trace.version": event.traceVersion,
+      "smithers.transcript.version": undefined,
+      "run.id": event.runId,
+      "workflow.path": event.workflowPath,
+      "workflow.hash": event.workflowHash,
+      "node.id": event.nodeId,
+      "node.iteration": event.iteration,
+      "node.attempt": event.attempt,
+      "agent.family": event.source.agentFamily,
+      "agent.id": context?.agentId,
+      "agent.model": context?.model,
+      "agent.capture_mode": event.source.captureMode,
+      "trace.completeness": event.traceCompleteness,
+      "event.kind": event.event.kind,
+      "event.phase": event.event.phase,
+      "event.sequence": event.event.sequence,
+      "source.raw_type": event.source.rawType,
+      "source.raw_event_id": event.source.rawEventId,
+      "source.observed": event.source.observed,
+      "session.row_type": undefined,
+      "session.row_sequence": undefined,
+      "session.ingest_source": undefined,
+      "session.observed_live": undefined,
+      "provider.session_id": undefined,
+      "provider.thread_id": undefined,
+    },
+    event.annotations,
+  );
+  return buildOtelLogRecord(
+    {
+      category: "agent-trace",
+      payload: event.payload,
+      raw: event.raw,
+      redaction: event.redaction,
+      annotations: event.annotations,
+    },
+    attributes,
+    inferCanonicalSeverity(event),
+  );
+}

package/src/correlation.js

@@ -0,0 +1,56 @@
+import {
+  getCurrentCorrelationContext as getCoreCurrentCorrelationContext,
+  mergeCorrelationContext as mergeCoreCorrelationContext,
+} from "./_coreCorrelation/index.js";
+/** @typedef {import("./_coreCorrelation/CorrelationContext.ts").CorrelationContext} CorrelationContext */
+/** @typedef {import("./_coreCorrelation/CorrelationPatch.ts").CorrelationPatch} CorrelationPatch */
+/** @typedef {CorrelationPatch} CorrelationContextPatch */
+
+export {
+  correlationContextFiberRef,
+  correlationContextToLogAnnotations,
+  CorrelationContextLive,
+  CorrelationContextService,
+  getCurrentCorrelationContext,
+  getCurrentCorrelationContextEffect,
+  mergeCorrelationContext,
+  runWithCorrelationContext,
+  withCorrelationContext,
+  withCurrentCorrelationContext,
+} from "./_coreCorrelation/index.js";
+/**
+ * Temporary compatibility shim for legacy, non-Effect callers.
+ *
+ * Unlike the FiberRef-based core implementation
+ * ({@link import("./_coreCorrelation/updateCurrentCorrelationContext.js").updateCurrentCorrelationContext}),
+ * which returns an Effect and sets a fresh merged context on the
+ * `correlationContextFiberRef`, this shim runs synchronously and applies the
+ * patch by **mutating the current context object in place** via
+ * `Object.assign(current, next)`. Any references already holding the current
+ * context object will observe the mutation. This in-place semantics is
+ * intentional and exists only to preserve behavior for callers that captured a
+ * context reference before the Effect-based API existed.
+ *
+ * If there is no current context, the patch is a no-op (nothing is created).
+ *
+ * @deprecated Prefer the Effect-returning
+ * `updateCurrentCorrelationContext` from
+ * `@smthrs/observability` (the `_coreCorrelation` version),
+ * which does not mutate shared state. This shim will be removed once legacy
+ * callers migrate.
+ *
+ * @param {CorrelationPatch} patch
+ * @returns {void}
+ */
+export function updateCurrentCorrelationContext(patch) {
+  const current = getCoreCurrentCorrelationContext();
+  if (!current) return;
+  // Compatibility shim: mutate the current context in place rather than
+  // setting a new FiberRef value. See the JSDoc above — this preserves
+  // behavior for legacy callers and is intentional, not a bug. Remove once
+  // those callers adopt the Effect-returning core
+  // updateCurrentCorrelationContext.
+  const next = mergeCoreCorrelationContext(current, patch);
+  if (!next) return;
+  Object.assign(current, next);
+}

package/src/createSmithersObservabilityLayer.js

@@ -0,0 +1,59 @@
+import * as BunContext from "@effect/platform-bun/BunServices";
+import { TracingServiceLive } from "./_coreTracing.js";
+import { Effect, Layer, Logger, References } from "effect";
+import { SmithersObservability } from "./SmithersObservability.js";
+import { resolveSmithersObservabilityOptions } from "./resolveSmithersObservabilityOptions.js";
+import { createSmithersOtelLayer } from "./createSmithersOtelLayer.js";
+import { MetricsServiceLive } from "./MetricsServiceLive.js";
+import { annotateSmithersTrace } from "./annotateSmithersTrace.js";
+import { withSmithersSpan } from "./withSmithersSpan.js";
+/** @typedef {import("./ResolvedSmithersObservabilityOptions.ts").ResolvedSmithersObservabilityOptions} ResolvedSmithersObservabilityOptions */
+/** @typedef {import("./SmithersLogFormat.ts").SmithersLogFormat} SmithersLogFormat */
+/** @typedef {import("./SmithersObservabilityService.ts").SmithersObservabilityService} SmithersObservabilityService */
+
+/** @typedef {import("./SmithersObservabilityOptions.ts").SmithersObservabilityOptions} SmithersObservabilityOptions */
+
+/**
+ * @param {SmithersLogFormat} format
+ */
+function resolveLogger(format) {
+  switch (format) {
+    case "json":
+      return Logger.consoleJson;
+    case "pretty":
+      return Logger.consolePretty();
+    case "string":
+      return Logger.consolePretty({ colors: false });
+    case "logfmt":
+    default:
+      return Logger.consoleLogFmt;
+  }
+}
+/**
+ * @param {ResolvedSmithersObservabilityOptions} options
+ * @returns {SmithersObservabilityService}
+ */
+function makeService(options) {
+  return {
+    options,
+    annotate: (attributes) => annotateSmithersTrace(attributes),
+    withSpan: (name, effect, attributes) => withSmithersSpan(name, effect, attributes),
+  };
+}
+/**
+ * @param {SmithersObservabilityOptions} [options]
+ */
+export function createSmithersObservabilityLayer(options = {}) {
+  const resolved = resolveSmithersObservabilityOptions(options);
+  const loggerLayers = resolved.installLogger
+    ? [Logger.layer([resolveLogger(resolved.logFormat)]), Layer.succeed(References.MinimumLogLevel, resolved.logLevel)]
+    : [];
+  return Layer.mergeAll(
+    BunContext.layer,
+    ...loggerLayers,
+    createSmithersOtelLayer(resolved),
+    MetricsServiceLive,
+    TracingServiceLive,
+    Layer.succeed(SmithersObservability, makeService(resolved)),
+  );
+}

package/src/createSmithersOtelLayer.js

@@ -0,0 +1,23 @@
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as Otlp from "effect/unstable/observability/Otlp";
+import { Fiber, Layer } from "effect";
+import { smithersTraceSpanStorage } from "./_smithersTraceSpanStorage.js";
+import { resolveSmithersObservabilityOptions } from "./resolveSmithersObservabilityOptions.js";
+/** @typedef {import("./SmithersObservabilityOptions.ts").SmithersObservabilityOptions} SmithersObservabilityOptions */
+
+/**
+ * @param {SmithersObservabilityOptions} [options]
+ */
+export function createSmithersOtelLayer(options = {}) {
+  const resolved = resolveSmithersObservabilityOptions(options);
+  if (!resolved.enabled) {
+    return Layer.empty;
+  }
+  return Otlp.layerJson({
+    baseUrl: resolved.endpoint,
+    ...(resolved.headers && Object.keys(resolved.headers).length > 0 ? { headers: resolved.headers } : {}),
+    resource: { serviceName: resolved.serviceName },
+    tracerContext: (primitive, span) =>
+      smithersTraceSpanStorage.run(span, () => primitive["~effect/Effect/evaluate"](Fiber.getCurrent())),
+  }).pipe(Layer.provide(FetchHttpClient.layer));
+}

package/src/createSmithersRuntimeLayer.js

@@ -0,0 +1,2 @@
+import { createSmithersObservabilityLayer } from "./createSmithersObservabilityLayer.js";
+export const createSmithersRuntimeLayer = createSmithersObservabilityLayer;

package/src/detectAgentFamily.js

@@ -0,0 +1,26 @@
+/**
+ * @typedef {import('./agentTrace.ts').AgentFamily} AgentFamily
+ */
+
+/**
+ * @param {any} agent
+ * @returns {AgentFamily}
+ */
+export function detectAgentFamily(agent) {
+  const constructorName = String(agent?.constructor?.name ?? "").toLowerCase();
+  const idName = String(agent?.id ?? "").toLowerCase();
+  const name = constructorName && constructorName !== "object" ? `${constructorName} ${idName}` : idName;
+  if (name.includes("antigravity") || name.includes("agy")) return "antigravity";
+  if (name.includes("codex")) return "codex";
+  if (name.includes("claude")) return "claude-code";
+  if (name.includes("gemini")) return "gemini";
+  if (name.includes("kimi")) return "kimi";
+  if (name.includes("openai")) return "openai";
+  if (name.includes("anthropic")) return "anthropic";
+  if (name.includes("amp")) return "amp";
+  if (name.includes("forge")) return "forge";
+  if (constructorName.includes("piagent") || /(?:^|[-_\s])pi(?:$|[-_\s])/.test(idName)) {
+    return "pi";
+  }
+  return "unknown";
+}

package/src/detectCaptureMode.js

@@ -0,0 +1,24 @@
+import { detectAgentFamily } from "./detectAgentFamily.js";
+/**
+ * @typedef {import('./agentTrace.ts').AgentCaptureMode} AgentCaptureMode
+ */
+
+/**
+ * @param {any} agent
+ * @returns {AgentCaptureMode}
+ */
+export function detectCaptureMode(agent) {
+  const family = detectAgentFamily(agent);
+  const mode = agent?.opts?.mode ?? agent?.mode;
+  if (family === "pi") {
+    if (mode === "rpc") return "rpc-events";
+    if (mode === "json") return "cli-json-stream";
+    return "cli-text";
+  }
+  if (family === "codex") return "cli-json-stream";
+  const outputFormat = agent?.opts?.outputFormat ?? agent?.outputFormat;
+  if (family === "openai" || family === "anthropic") return "sdk-events";
+  if (outputFormat === "stream-json") return "cli-json-stream";
+  if (outputFormat === "json" || agent?.opts?.json) return "cli-json";
+  return "cli-text";
+}

package/src/emitOtelLogRecord.js

@@ -0,0 +1,19 @@
+import { logErrorAwait, logInfoAwait, logWarningAwait } from "./logging.js";
+/**
+ * @typedef {import('./_otelLogBuilders.js').OtelLogRecord} OtelLogRecord
+ */
+
+/**
+ * @param {"agent-trace" | "agent-session"} category
+ * @param {OtelLogRecord} record
+ * @returns {Promise<void>}
+ */
+export async function emitOtelLogRecord(category, record) {
+  if (record.severity === "ERROR") {
+    await logErrorAwait(record.body, record.attributes, category);
+  } else if (record.severity === "WARN") {
+    await logWarningAwait(record.body, record.attributes, category);
+  } else {
+    await logInfoAwait(record.body, record.attributes, category);
+  }
+}

package/src/getCurrentSmithersTraceAnnotations.js

@@ -0,0 +1,14 @@
+import { getCurrentSmithersTraceSpan } from "./getCurrentSmithersTraceSpan.js";
+/**
+ * @returns {| Readonly<Record<string, string>> | undefined}
+ */
+export function getCurrentSmithersTraceAnnotations() {
+  const span = getCurrentSmithersTraceSpan();
+  if (!span) {
+    return undefined;
+  }
+  return {
+    traceId: span.traceId,
+    spanId: span.spanId,
+  };
+}

package/src/getCurrentSmithersTraceSpan.js

@@ -0,0 +1,7 @@
+import { smithersTraceSpanStorage } from "./_smithersTraceSpanStorage.js";
+/**
+ * @returns {import("effect/Tracer").AnySpan | undefined}
+ */
+export function getCurrentSmithersTraceSpan() {
+  return smithersTraceSpanStorage.getStore();
+}