@reactive-agents/observability 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tyler Buell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,45 @@
+# @reactive-agents/observability
+
+Observability for the [Reactive Agents](https://tylerjrbuell.github.io/reactive-agents-ts/) framework.
+
+Adds distributed tracing, metrics, and structured logging to every phase of the agent execution engine.
+
+## Installation
+
+```bash
+bun add @reactive-agents/observability effect
+```
+
+## Features
+
+- **Distributed tracing** — span per execution phase, compatible with OpenTelemetry exporters
+- **Metrics** — token usage, latency, step count, cost per run
+- **Structured logging** — JSON logs with trace context for easy querying
+
+## Usage
+
+```typescript
+import { ReactiveAgents } from "reactive-agents";
+
+const agent = await ReactiveAgents.create()
+  .withName("traced-agent")
+  .withProvider("anthropic")
+  .withObservability()
+  .build();
+
+const result = await agent.run("Analyze this data");
+// All 10 execution phases are traced automatically
+```
+
+## What Gets Traced
+
+Each of the 10 execution phases emits a span:
+
+```
+bootstrap → guardrail → cost-route → strategy-select →
+think → act → observe → verify → memory-flush → complete
+```
+
+## Documentation
+
+Full documentation at [tylerjrbuell.github.io/reactive-agents-ts](https://tylerjrbuell.github.io/reactive-agents-ts/)

package/dist/index.d.ts

@@ -0,0 +1,201 @@
+import { Schema, Effect, Context, Layer } from 'effect';
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+import * as effect_Layer from 'effect/Layer';
+
+declare const LogLevel: Schema.Literal<["debug", "info", "warn", "error"]>;
+type LogLevel = typeof LogLevel.Type;
+declare const LogEntrySchema: Schema.Struct<{
+    timestamp: typeof Schema.DateFromSelf;
+    level: Schema.Literal<["debug", "info", "warn", "error"]>;
+    message: typeof Schema.String;
+    agentId: Schema.optional<typeof Schema.String>;
+    sessionId: Schema.optional<typeof Schema.String>;
+    traceId: Schema.optional<typeof Schema.String>;
+    spanId: Schema.optional<typeof Schema.String>;
+    layer: Schema.optional<typeof Schema.String>;
+    operation: Schema.optional<typeof Schema.String>;
+    durationMs: Schema.optional<typeof Schema.Number>;
+    metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>;
+type LogEntry = typeof LogEntrySchema.Type;
+declare const SpanStatusSchema: Schema.Literal<["ok", "error", "unset"]>;
+type SpanStatus = typeof SpanStatusSchema.Type;
+declare const SpanSchema: Schema.Struct<{
+    traceId: typeof Schema.String;
+    spanId: typeof Schema.String;
+    parentSpanId: Schema.optional<typeof Schema.String>;
+    name: typeof Schema.String;
+    startTime: typeof Schema.DateFromSelf;
+    endTime: Schema.optional<typeof Schema.DateFromSelf>;
+    status: Schema.Literal<["ok", "error", "unset"]>;
+    attributes: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+    events: Schema.Array$<Schema.Struct<{
+        name: typeof Schema.String;
+        timestamp: typeof Schema.DateFromSelf;
+        attributes: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+    }>>;
+}>;
+type Span = typeof SpanSchema.Type;
+declare const MetricType: Schema.Literal<["counter", "histogram", "gauge"]>;
+type MetricType = typeof MetricType.Type;
+declare const MetricSchema: Schema.Struct<{
+    name: typeof Schema.String;
+    type: Schema.Literal<["counter", "histogram", "gauge"]>;
+    value: typeof Schema.Number;
+    timestamp: typeof Schema.DateFromSelf;
+    labels: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+    unit: Schema.optional<typeof Schema.String>;
+}>;
+type Metric = typeof MetricSchema.Type;
+declare const AgentStateSnapshotSchema: Schema.Struct<{
+    agentId: typeof Schema.String;
+    timestamp: typeof Schema.DateFromSelf;
+    workingMemory: Schema.Array$<typeof Schema.Unknown>;
+    currentStrategy: Schema.optional<typeof Schema.String>;
+    reasoningStep: Schema.optional<typeof Schema.Number>;
+    activeTools: Schema.Array$<typeof Schema.String>;
+    tokenUsage: Schema.Struct<{
+        inputTokens: typeof Schema.Number;
+        outputTokens: typeof Schema.Number;
+        contextWindowUsed: typeof Schema.Number;
+        contextWindowMax: typeof Schema.Number;
+    }>;
+    costAccumulated: typeof Schema.Number;
+}>;
+type AgentStateSnapshot = typeof AgentStateSnapshotSchema.Type;
+
+declare const TracingError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "TracingError";
+} & Readonly<A>;
+declare class TracingError extends TracingError_base<{
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const MetricsError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "MetricsError";
+} & Readonly<A>;
+declare class MetricsError extends MetricsError_base<{
+    readonly message: string;
+    readonly metricName?: string;
+}> {
+}
+declare const ExporterError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "ExporterError";
+} & Readonly<A>;
+declare class ExporterError extends ExporterError_base<{
+    readonly message: string;
+    readonly exporter: string;
+    readonly cause?: unknown;
+}> {
+}
+
+interface Tracer {
+    readonly withSpan: <A, E>(name: string, effect: Effect.Effect<A, E>, attributes?: Record<string, unknown>) => Effect.Effect<A, E>;
+    readonly getTraceContext: () => Effect.Effect<{
+        traceId: string;
+        spanId: string;
+    }, never>;
+    readonly getSpans: (filter?: {
+        name?: string;
+        status?: SpanStatus;
+    }) => Effect.Effect<readonly Span[], never>;
+}
+declare const makeTracer: Effect.Effect<{
+    withSpan: <A, E>(name: string, effect: Effect.Effect<A, E>, attributes?: Record<string, unknown>) => Effect.Effect<A, E>;
+    getTraceContext: () => Effect.Effect<{
+        traceId: string;
+        spanId: string;
+    }, never>;
+    getSpans: (filter?: {
+        name?: string;
+        status?: SpanStatus;
+    }) => Effect.Effect<readonly Span[], never>;
+}, never, never>;
+
+interface StructuredLogger {
+    readonly log: (level: LogLevel, message: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;
+    readonly debug: (message: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;
+    readonly info: (message: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;
+    readonly warn: (message: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;
+    readonly error: (message: string, err?: unknown, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;
+    readonly getLogs: (filter?: {
+        level?: LogLevel;
+        agentId?: string;
+        limit?: number;
+    }) => Effect.Effect<readonly LogEntry[], never>;
+}
+declare const makeStructuredLogger: Effect.Effect<{
+    log: (level: LogLevel, message: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;
+    debug: (msg: string, meta?: Record<string, unknown>) => Effect.Effect<void, never, never>;
+    info: (msg: string, meta?: Record<string, unknown>) => Effect.Effect<void, never, never>;
+    warn: (msg: string, meta?: Record<string, unknown>) => Effect.Effect<void, never, never>;
+    error: (msg: string, err?: unknown, meta?: Record<string, unknown>) => Effect.Effect<void, never, never>;
+    getLogs: (filter?: {
+        level?: LogLevel;
+        agentId?: string;
+        limit?: number;
+    }) => Effect.Effect<readonly LogEntry[], never>;
+}, never, never>;
+
+interface MetricsCollector {
+    readonly incrementCounter: (name: string, value?: number, labels?: Record<string, string>) => Effect.Effect<void, never>;
+    readonly recordHistogram: (name: string, value: number, labels?: Record<string, string>) => Effect.Effect<void, never>;
+    readonly setGauge: (name: string, value: number, labels?: Record<string, string>) => Effect.Effect<void, never>;
+    readonly getMetrics: (filter?: {
+        name?: string;
+        startTime?: Date;
+        endTime?: Date;
+    }) => Effect.Effect<readonly Metric[], never>;
+}
+declare const makeMetricsCollector: Effect.Effect<{
+    incrementCounter: (name: string, value?: number, labels?: Record<string, string>) => Effect.Effect<void, never>;
+    recordHistogram: (name: string, value: number, labels?: Record<string, string>) => Effect.Effect<void, never>;
+    setGauge: (name: string, value: number, labels?: Record<string, string>) => Effect.Effect<void, never>;
+    getMetrics: (filter?: {
+        name?: string;
+        startTime?: Date;
+        endTime?: Date;
+    }) => Effect.Effect<readonly Metric[], never>;
+}, never, never>;
+
+interface StateInspector {
+    readonly capture: (agentId: string, state: Partial<AgentStateSnapshot>) => Effect.Effect<AgentStateSnapshot, never>;
+    readonly getSnapshots: (agentId: string, limit?: number) => Effect.Effect<readonly AgentStateSnapshot[], never>;
+}
+declare const makeStateInspector: Effect.Effect<{
+    capture: (agentId: string, partialState: Partial<AgentStateSnapshot>) => Effect.Effect<AgentStateSnapshot, never>;
+    getSnapshots: (agentId: string, limit?: number) => Effect.Effect<readonly AgentStateSnapshot[], never>;
+}, never, never>;
+
+declare const ObservabilityService_base: Context.TagClass<ObservabilityService, "ObservabilityService", {
+    readonly withSpan: <A, E>(name: string, effect: Effect.Effect<A, E>, attributes?: Record<string, unknown>) => Effect.Effect<A, E>;
+    readonly getTraceContext: () => Effect.Effect<{
+        traceId: string;
+        spanId: string;
+    }, never>;
+    readonly log: (level: LogLevel, message: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;
+    readonly debug: (message: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;
+    readonly info: (message: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;
+    readonly warn: (message: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;
+    readonly error: (message: string, error?: unknown, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;
+    readonly incrementCounter: (name: string, value?: number, labels?: Record<string, string>) => Effect.Effect<void, never>;
+    readonly recordHistogram: (name: string, value: number, labels?: Record<string, string>) => Effect.Effect<void, never>;
+    readonly setGauge: (name: string, value: number, labels?: Record<string, string>) => Effect.Effect<void, never>;
+    readonly getMetrics: (filter?: {
+        name?: string;
+        startTime?: Date;
+        endTime?: Date;
+    }) => Effect.Effect<readonly Metric[], never>;
+    readonly captureSnapshot: (agentId: string, state: Partial<AgentStateSnapshot>) => Effect.Effect<AgentStateSnapshot, never>;
+    readonly getSnapshots: (agentId: string, limit?: number) => Effect.Effect<readonly AgentStateSnapshot[], never>;
+    readonly flush: () => Effect.Effect<void, ExporterError>;
+}>;
+declare class ObservabilityService extends ObservabilityService_base {
+}
+declare const ObservabilityServiceLive: Layer.Layer<ObservabilityService, never, never>;
+
+declare const createObservabilityLayer: () => effect_Layer.Layer<ObservabilityService, never, never>;
+
+export { type AgentStateSnapshot, AgentStateSnapshotSchema, ExporterError, type LogEntry, LogEntrySchema, LogLevel, type Metric, MetricSchema, MetricType, type MetricsCollector, MetricsError, ObservabilityService, ObservabilityServiceLive, type Span, SpanSchema, type SpanStatus, SpanStatusSchema, type StateInspector, type StructuredLogger, type Tracer, TracingError, createObservabilityLayer, makeMetricsCollector, makeStateInspector, makeStructuredLogger, makeTracer };

package/dist/index.js

@@ -0,0 +1,279 @@
+// src/types.ts
+import { Schema } from "effect";
+var LogLevel = Schema.Literal("debug", "info", "warn", "error");
+var LogEntrySchema = Schema.Struct({
+  timestamp: Schema.DateFromSelf,
+  level: LogLevel,
+  message: Schema.String,
+  agentId: Schema.optional(Schema.String),
+  sessionId: Schema.optional(Schema.String),
+  traceId: Schema.optional(Schema.String),
+  spanId: Schema.optional(Schema.String),
+  layer: Schema.optional(Schema.String),
+  operation: Schema.optional(Schema.String),
+  durationMs: Schema.optional(Schema.Number),
+  metadata: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Unknown }))
+});
+var SpanStatusSchema = Schema.Literal("ok", "error", "unset");
+var SpanSchema = Schema.Struct({
+  traceId: Schema.String,
+  spanId: Schema.String,
+  parentSpanId: Schema.optional(Schema.String),
+  name: Schema.String,
+  startTime: Schema.DateFromSelf,
+  endTime: Schema.optional(Schema.DateFromSelf),
+  status: SpanStatusSchema,
+  attributes: Schema.Record({ key: Schema.String, value: Schema.Unknown }),
+  events: Schema.Array(Schema.Struct({
+    name: Schema.String,
+    timestamp: Schema.DateFromSelf,
+    attributes: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Unknown }))
+  }))
+});
+var MetricType = Schema.Literal("counter", "histogram", "gauge");
+var MetricSchema = Schema.Struct({
+  name: Schema.String,
+  type: MetricType,
+  value: Schema.Number,
+  timestamp: Schema.DateFromSelf,
+  labels: Schema.Record({ key: Schema.String, value: Schema.String }),
+  unit: Schema.optional(Schema.String)
+});
+var AgentStateSnapshotSchema = Schema.Struct({
+  agentId: Schema.String,
+  timestamp: Schema.DateFromSelf,
+  workingMemory: Schema.Array(Schema.Unknown),
+  currentStrategy: Schema.optional(Schema.String),
+  reasoningStep: Schema.optional(Schema.Number),
+  activeTools: Schema.Array(Schema.String),
+  tokenUsage: Schema.Struct({
+    inputTokens: Schema.Number,
+    outputTokens: Schema.Number,
+    contextWindowUsed: Schema.Number,
+    contextWindowMax: Schema.Number
+  }),
+  costAccumulated: Schema.Number
+});
+
+// src/errors.ts
+import { Data } from "effect";
+var TracingError = class extends Data.TaggedError("TracingError") {
+};
+var MetricsError = class extends Data.TaggedError("MetricsError") {
+};
+var ExporterError = class extends Data.TaggedError("ExporterError") {
+};
+
+// src/tracing/tracer.ts
+import { Effect, Ref } from "effect";
+var generateId = () => {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+};
+var generateSpanId = () => {
+  const bytes = new Uint8Array(8);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+};
+var makeTracer = Effect.gen(function* () {
+  const spansRef = yield* Ref.make([]);
+  const withSpan = (name, effect, attributes) => Effect.gen(function* () {
+    const traceId = generateId();
+    const spanId = generateSpanId();
+    const startTime = performance.now();
+    const baseSpan = {
+      traceId,
+      spanId,
+      name,
+      startTime: /* @__PURE__ */ new Date(),
+      status: "unset",
+      attributes: { ...attributes, "service.name": "reactive-agents" },
+      events: []
+    };
+    const result = yield* effect.pipe(
+      Effect.tap(
+        () => Ref.update(spansRef, (spans) => [
+          ...spans,
+          {
+            ...baseSpan,
+            endTime: /* @__PURE__ */ new Date(),
+            status: "ok",
+            attributes: { ...baseSpan.attributes, duration_ms: performance.now() - startTime }
+          }
+        ])
+      ),
+      Effect.tapError(
+        (error) => Ref.update(spansRef, (spans) => [
+          ...spans,
+          {
+            ...baseSpan,
+            endTime: /* @__PURE__ */ new Date(),
+            status: "error",
+            attributes: { ...baseSpan.attributes, duration_ms: performance.now() - startTime, "error.message": String(error) },
+            events: [{ name: "exception", timestamp: /* @__PURE__ */ new Date(), attributes: { message: String(error) } }]
+          }
+        ])
+      )
+    );
+    return result;
+  });
+  const getTraceContext = () => Effect.succeed({ traceId: generateId(), spanId: generateSpanId() });
+  const getSpans = (filter) => Effect.gen(function* () {
+    const spans = yield* Ref.get(spansRef);
+    let filtered = spans;
+    if (filter?.name) filtered = filtered.filter((s) => s.name.includes(filter.name));
+    if (filter?.status) filtered = filtered.filter((s) => s.status === filter.status);
+    return filtered;
+  });
+  return { withSpan, getTraceContext, getSpans };
+});
+
+// src/logging/structured-logger.ts
+import { Effect as Effect2, Ref as Ref2 } from "effect";
+var LOG_LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var makeStructuredLogger = Effect2.gen(function* () {
+  const logsRef = yield* Ref2.make([]);
+  const log = (level, message, metadata) => Ref2.update(logsRef, (logs) => [
+    ...logs,
+    { timestamp: /* @__PURE__ */ new Date(), level, message, metadata }
+  ]);
+  const debug = (msg, meta) => log("debug", msg, meta);
+  const info = (msg, meta) => log("info", msg, meta);
+  const warn = (msg, meta) => log("warn", msg, meta);
+  const error = (msg, err, meta) => log("error", msg, {
+    ...meta,
+    error: err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : { message: String(err) }
+  });
+  const getLogs = (filter) => Effect2.gen(function* () {
+    const logs = yield* Ref2.get(logsRef);
+    let filtered = logs;
+    if (filter?.level) filtered = filtered.filter((l) => LOG_LEVEL_ORDER[l.level] >= LOG_LEVEL_ORDER[filter.level]);
+    if (filter?.agentId) filtered = filtered.filter((l) => l.agentId === filter.agentId);
+    if (filter?.limit) filtered = filtered.slice(-filter.limit);
+    return filtered;
+  });
+  return { log, debug, info, warn, error, getLogs };
+});
+
+// src/metrics/metrics-collector.ts
+import { Effect as Effect3, Ref as Ref3 } from "effect";
+var makeMetricsCollector = Effect3.gen(function* () {
+  const metricsRef = yield* Ref3.make([]);
+  const incrementCounter = (name, value = 1, labels = {}) => Ref3.update(metricsRef, (metrics) => [
+    ...metrics,
+    { name, type: "counter", value, timestamp: /* @__PURE__ */ new Date(), labels }
+  ]);
+  const recordHistogram = (name, value, labels = {}) => Ref3.update(metricsRef, (metrics) => [
+    ...metrics,
+    { name, type: "histogram", value, timestamp: /* @__PURE__ */ new Date(), labels }
+  ]);
+  const setGauge = (name, value, labels = {}) => Ref3.update(metricsRef, (metrics) => [
+    ...metrics,
+    { name, type: "gauge", value, timestamp: /* @__PURE__ */ new Date(), labels }
+  ]);
+  const getMetrics = (filter) => Effect3.gen(function* () {
+    const metrics = yield* Ref3.get(metricsRef);
+    let filtered = metrics;
+    if (filter?.name) filtered = filtered.filter((m) => m.name === filter.name || m.name.startsWith(filter.name));
+    if (filter?.startTime) filtered = filtered.filter((m) => m.timestamp >= filter.startTime);
+    if (filter?.endTime) filtered = filtered.filter((m) => m.timestamp <= filter.endTime);
+    return filtered;
+  });
+  return { incrementCounter, recordHistogram, setGauge, getMetrics };
+});
+
+// src/debugging/state-inspector.ts
+import { Effect as Effect4, Ref as Ref4 } from "effect";
+var MAX_SNAPSHOTS = 1e3;
+var makeStateInspector = Effect4.gen(function* () {
+  const snapshotsRef = yield* Ref4.make([]);
+  const capture = (agentId, partialState) => Effect4.gen(function* () {
+    const snapshot = {
+      agentId,
+      timestamp: /* @__PURE__ */ new Date(),
+      workingMemory: partialState.workingMemory ?? [],
+      currentStrategy: partialState.currentStrategy,
+      reasoningStep: partialState.reasoningStep,
+      activeTools: partialState.activeTools ?? [],
+      tokenUsage: partialState.tokenUsage ?? {
+        inputTokens: 0,
+        outputTokens: 0,
+        contextWindowUsed: 0,
+        contextWindowMax: 2e5
+      },
+      costAccumulated: partialState.costAccumulated ?? 0
+    };
+    yield* Ref4.update(snapshotsRef, (snaps) => {
+      const updated = [...snaps, snapshot];
+      return updated.length > MAX_SNAPSHOTS ? updated.slice(-MAX_SNAPSHOTS) : updated;
+    });
+    return snapshot;
+  });
+  const getSnapshots = (agentId, limit = 50) => Effect4.gen(function* () {
+    const snapshots = yield* Ref4.get(snapshotsRef);
+    return snapshots.filter((s) => s.agentId === agentId).slice(-limit);
+  });
+  return { capture, getSnapshots };
+});
+
+// src/observability-service.ts
+import { Effect as Effect5, Context, Layer } from "effect";
+var ObservabilityService = class extends Context.Tag("ObservabilityService")() {
+};
+var ObservabilityServiceLive = Layer.effect(
+  ObservabilityService,
+  Effect5.gen(function* () {
+    const tracer = yield* makeTracer;
+    const logger = yield* makeStructuredLogger;
+    const metrics = yield* makeMetricsCollector;
+    const inspector = yield* makeStateInspector;
+    return {
+      withSpan: (name, effect, attributes) => tracer.withSpan(name, effect, attributes).pipe(
+        Effect5.tap(() => metrics.incrementCounter(`span.${name}.completed`)),
+        Effect5.tapError(() => metrics.incrementCounter(`span.${name}.errors`))
+      ),
+      getTraceContext: () => tracer.getTraceContext(),
+      log: (level, message, metadata) => logger.log(level, message, metadata),
+      debug: (msg, meta) => logger.debug(msg, meta),
+      info: (msg, meta) => logger.info(msg, meta),
+      warn: (msg, meta) => logger.warn(msg, meta),
+      error: (msg, err, meta) => logger.error(msg, err, meta),
+      incrementCounter: (name, value, labels) => metrics.incrementCounter(name, value, labels),
+      recordHistogram: (name, value, labels) => metrics.recordHistogram(name, value, labels),
+      setGauge: (name, value, labels) => metrics.setGauge(name, value, labels),
+      getMetrics: (filter) => metrics.getMetrics(filter),
+      captureSnapshot: (agentId, state) => inspector.capture(agentId, state),
+      getSnapshots: (agentId, limit) => inspector.getSnapshots(agentId, limit),
+      flush: () => Effect5.void
+    };
+  })
+);
+
+// src/runtime.ts
+var createObservabilityLayer = () => ObservabilityServiceLive;
+export {
+  AgentStateSnapshotSchema,
+  ExporterError,
+  LogEntrySchema,
+  LogLevel,
+  MetricSchema,
+  MetricType,
+  MetricsError,
+  ObservabilityService,
+  ObservabilityServiceLive,
+  SpanSchema,
+  SpanStatusSchema,
+  TracingError,
+  createObservabilityLayer,
+  makeMetricsCollector,
+  makeStateInspector,
+  makeStructuredLogger,
+  makeTracer
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts","../src/errors.ts","../src/tracing/tracer.ts","../src/logging/structured-logger.ts","../src/metrics/metrics-collector.ts","../src/debugging/state-inspector.ts","../src/observability-service.ts","../src/runtime.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\n// ─── Log Level (matches @reactive-agents/core) ───\n\nexport const LogLevel = Schema.Literal(\"debug\", \"info\", \"warn\", \"error\");\nexport type LogLevel = typeof LogLevel.Type;\n\n// ─── Structured Log Entry ───\n\nexport const LogEntrySchema = Schema.Struct({\n  timestamp: Schema.DateFromSelf,\n  level: LogLevel,\n  message: Schema.String,\n  agentId: Schema.optional(Schema.String),\n  sessionId: Schema.optional(Schema.String),\n  traceId: Schema.optional(Schema.String),\n  spanId: Schema.optional(Schema.String),\n  layer: Schema.optional(Schema.String),\n  operation: Schema.optional(Schema.String),\n  durationMs: Schema.optional(Schema.Number),\n  metadata: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Unknown })),\n});\nexport type LogEntry = typeof LogEntrySchema.Type;\n\n// ─── Span ───\n\nexport const SpanStatusSchema = Schema.Literal(\"ok\", \"error\", \"unset\");\nexport type SpanStatus = typeof SpanStatusSchema.Type;\n\nexport const SpanSchema = Schema.Struct({\n  traceId: Schema.String,\n  spanId: Schema.String,\n  parentSpanId: Schema.optional(Schema.String),\n  name: Schema.String,\n  startTime: Schema.DateFromSelf,\n  endTime: Schema.optional(Schema.DateFromSelf),\n  status: SpanStatusSchema,\n  attributes: Schema.Record({ key: Schema.String, value: Schema.Unknown }),\n  events: Schema.Array(Schema.Struct({\n    name: Schema.String,\n    timestamp: Schema.DateFromSelf,\n    attributes: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Unknown })),\n  })),\n});\nexport type Span = typeof SpanSchema.Type;\n\n// ─── Metric ───\n\nexport const MetricType = Schema.Literal(\"counter\", \"histogram\", \"gauge\");\nexport type MetricType = typeof MetricType.Type;\n\nexport const MetricSchema = Schema.Struct({\n  name: Schema.String,\n  type: MetricType,\n  value: Schema.Number,\n  timestamp: Schema.DateFromSelf,\n  labels: Schema.Record({ key: Schema.String, value: Schema.String }),\n  unit: Schema.optional(Schema.String),\n});\nexport type Metric = typeof MetricSchema.Type;\n\n// ─── Agent State Snapshot ───\n\nexport const AgentStateSnapshotSchema = Schema.Struct({\n  agentId: Schema.String,\n  timestamp: Schema.DateFromSelf,\n  workingMemory: Schema.Array(Schema.Unknown),\n  currentStrategy: Schema.optional(Schema.String),\n  reasoningStep: Schema.optional(Schema.Number),\n  activeTools: Schema.Array(Schema.String),\n  tokenUsage: Schema.Struct({\n    inputTokens: Schema.Number,\n    outputTokens: Schema.Number,\n    contextWindowUsed: Schema.Number,\n    contextWindowMax: Schema.Number,\n  }),\n  costAccumulated: Schema.Number,\n});\nexport type AgentStateSnapshot = typeof AgentStateSnapshotSchema.Type;\n","import { Data } from \"effect\";\n\nexport class TracingError extends Data.TaggedError(\"TracingError\")<{\n  readonly message: string;\n  readonly cause?: unknown;\n}> {}\n\nexport class MetricsError extends Data.TaggedError(\"MetricsError\")<{\n  readonly message: string;\n  readonly metricName?: string;\n}> {}\n\nexport class ExporterError extends Data.TaggedError(\"ExporterError\")<{\n  readonly message: string;\n  readonly exporter: string;\n  readonly cause?: unknown;\n}> {}\n","import { Effect, Ref } from \"effect\";\nimport type { Span, SpanStatus } from \"../types.js\";\n\nexport interface Tracer {\n  readonly withSpan: <A, E>(name: string, effect: Effect.Effect<A, E>, attributes?: Record<string, unknown>) => Effect.Effect<A, E>;\n  readonly getTraceContext: () => Effect.Effect<{ traceId: string; spanId: string }, never>;\n  readonly getSpans: (filter?: { name?: string; status?: SpanStatus }) => Effect.Effect<readonly Span[], never>;\n}\n\nconst generateId = (): string => {\n  const bytes = new Uint8Array(16);\n  crypto.getRandomValues(bytes);\n  return Array.from(bytes, (b) => b.toString(16).padStart(2, \"0\")).join(\"\");\n};\n\nconst generateSpanId = (): string => {\n  const bytes = new Uint8Array(8);\n  crypto.getRandomValues(bytes);\n  return Array.from(bytes, (b) => b.toString(16).padStart(2, \"0\")).join(\"\");\n};\n\nexport const makeTracer = Effect.gen(function* () {\n  const spansRef = yield* Ref.make<Span[]>([]);\n\n  const withSpan = <A, E>(\n    name: string,\n    effect: Effect.Effect<A, E>,\n    attributes?: Record<string, unknown>,\n  ): Effect.Effect<A, E> =>\n    Effect.gen(function* () {\n      const traceId = generateId();\n      const spanId = generateSpanId();\n      const startTime = performance.now();\n\n      const baseSpan: Span = {\n        traceId,\n        spanId,\n        name,\n        startTime: new Date(),\n        status: \"unset\",\n        attributes: { ...attributes, \"service.name\": \"reactive-agents\" },\n        events: [],\n      };\n\n      const result = yield* effect.pipe(\n        Effect.tap(() =>\n          Ref.update(spansRef, (spans) => [\n            ...spans,\n            {\n              ...baseSpan,\n              endTime: new Date(),\n              status: \"ok\" as const,\n              attributes: { ...baseSpan.attributes, duration_ms: performance.now() - startTime },\n            },\n          ]),\n        ),\n        Effect.tapError((error) =>\n          Ref.update(spansRef, (spans) => [\n            ...spans,\n            {\n              ...baseSpan,\n              endTime: new Date(),\n              status: \"error\" as const,\n              attributes: { ...baseSpan.attributes, duration_ms: performance.now() - startTime, \"error.message\": String(error) },\n              events: [{ name: \"exception\", timestamp: new Date(), attributes: { message: String(error) } }],\n            },\n          ]),\n        ),\n      );\n\n      return result;\n    });\n\n  const getTraceContext = (): Effect.Effect<{ traceId: string; spanId: string }, never> =>\n    Effect.succeed({ traceId: generateId(), spanId: generateSpanId() });\n\n  const getSpans = (filter?: { name?: string; status?: SpanStatus }): Effect.Effect<readonly Span[], never> =>\n    Effect.gen(function* () {\n      const spans = yield* Ref.get(spansRef);\n      let filtered = spans;\n      if (filter?.name) filtered = filtered.filter((s) => s.name.includes(filter.name!));\n      if (filter?.status) filtered = filtered.filter((s) => s.status === filter.status);\n      return filtered;\n    });\n\n  return { withSpan, getTraceContext, getSpans } satisfies Tracer;\n});\n","import { Effect, Ref } from \"effect\";\nimport type { LogEntry, LogLevel } from \"../types.js\";\n\nexport interface StructuredLogger {\n  readonly log: (level: LogLevel, message: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;\n  readonly debug: (message: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;\n  readonly info: (message: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;\n  readonly warn: (message: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;\n  readonly error: (message: string, err?: unknown, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;\n  readonly getLogs: (filter?: { level?: LogLevel; agentId?: string; limit?: number }) => Effect.Effect<readonly LogEntry[], never>;\n}\n\nconst LOG_LEVEL_ORDER: Record<LogLevel, number> = {\n  debug: 0,\n  info: 1,\n  warn: 2,\n  error: 3,\n};\n\nexport const makeStructuredLogger = Effect.gen(function* () {\n  const logsRef = yield* Ref.make<LogEntry[]>([]);\n\n  const log = (\n    level: LogLevel,\n    message: string,\n    metadata?: Record<string, unknown>,\n  ): Effect.Effect<void, never> =>\n    Ref.update(logsRef, (logs) => [\n      ...logs,\n      { timestamp: new Date(), level, message, metadata },\n    ]);\n\n  const debug = (msg: string, meta?: Record<string, unknown>) => log(\"debug\", msg, meta);\n  const info = (msg: string, meta?: Record<string, unknown>) => log(\"info\", msg, meta);\n  const warn = (msg: string, meta?: Record<string, unknown>) => log(\"warn\", msg, meta);\n  const error = (msg: string, err?: unknown, meta?: Record<string, unknown>) =>\n    log(\"error\", msg, {\n      ...meta,\n      error: err instanceof Error\n        ? { name: err.name, message: err.message, stack: err.stack }\n        : { message: String(err) },\n    });\n\n  const getLogs = (filter?: { level?: LogLevel; agentId?: string; limit?: number }): Effect.Effect<readonly LogEntry[], never> =>\n    Effect.gen(function* () {\n      const logs = yield* Ref.get(logsRef);\n      let filtered = logs;\n      if (filter?.level) filtered = filtered.filter((l) => LOG_LEVEL_ORDER[l.level] >= LOG_LEVEL_ORDER[filter.level!]);\n      if (filter?.agentId) filtered = filtered.filter((l) => l.agentId === filter.agentId);\n      if (filter?.limit) filtered = filtered.slice(-filter.limit);\n      return filtered;\n    });\n\n  return { log, debug, info, warn, error, getLogs } satisfies StructuredLogger;\n});\n","import { Effect, Ref } from \"effect\";\nimport type { Metric } from \"../types.js\";\n\nexport interface MetricsCollector {\n  readonly incrementCounter: (name: string, value?: number, labels?: Record<string, string>) => Effect.Effect<void, never>;\n  readonly recordHistogram: (name: string, value: number, labels?: Record<string, string>) => Effect.Effect<void, never>;\n  readonly setGauge: (name: string, value: number, labels?: Record<string, string>) => Effect.Effect<void, never>;\n  readonly getMetrics: (filter?: { name?: string; startTime?: Date; endTime?: Date }) => Effect.Effect<readonly Metric[], never>;\n}\n\nexport const makeMetricsCollector = Effect.gen(function* () {\n  const metricsRef = yield* Ref.make<Metric[]>([]);\n\n  const incrementCounter = (\n    name: string,\n    value: number = 1,\n    labels: Record<string, string> = {},\n  ): Effect.Effect<void, never> =>\n    Ref.update(metricsRef, (metrics) => [\n      ...metrics,\n      { name, type: \"counter\" as const, value, timestamp: new Date(), labels },\n    ]);\n\n  const recordHistogram = (\n    name: string,\n    value: number,\n    labels: Record<string, string> = {},\n  ): Effect.Effect<void, never> =>\n    Ref.update(metricsRef, (metrics) => [\n      ...metrics,\n      { name, type: \"histogram\" as const, value, timestamp: new Date(), labels },\n    ]);\n\n  const setGauge = (\n    name: string,\n    value: number,\n    labels: Record<string, string> = {},\n  ): Effect.Effect<void, never> =>\n    Ref.update(metricsRef, (metrics) => [\n      ...metrics,\n      { name, type: \"gauge\" as const, value, timestamp: new Date(), labels },\n    ]);\n\n  const getMetrics = (filter?: { name?: string; startTime?: Date; endTime?: Date }): Effect.Effect<readonly Metric[], never> =>\n    Effect.gen(function* () {\n      const metrics = yield* Ref.get(metricsRef);\n      let filtered = metrics;\n      if (filter?.name) filtered = filtered.filter((m) => m.name === filter.name || m.name.startsWith(filter.name!));\n      if (filter?.startTime) filtered = filtered.filter((m) => m.timestamp >= filter.startTime!);\n      if (filter?.endTime) filtered = filtered.filter((m) => m.timestamp <= filter.endTime!);\n      return filtered;\n    });\n\n  return { incrementCounter, recordHistogram, setGauge, getMetrics } satisfies MetricsCollector;\n});\n","import { Effect, Ref } from \"effect\";\nimport type { AgentStateSnapshot } from \"../types.js\";\n\nexport interface StateInspector {\n  readonly capture: (agentId: string, state: Partial<AgentStateSnapshot>) => Effect.Effect<AgentStateSnapshot, never>;\n  readonly getSnapshots: (agentId: string, limit?: number) => Effect.Effect<readonly AgentStateSnapshot[], never>;\n}\n\nconst MAX_SNAPSHOTS = 1000;\n\nexport const makeStateInspector = Effect.gen(function* () {\n  const snapshotsRef = yield* Ref.make<AgentStateSnapshot[]>([]);\n\n  const capture = (\n    agentId: string,\n    partialState: Partial<AgentStateSnapshot>,\n  ): Effect.Effect<AgentStateSnapshot, never> =>\n    Effect.gen(function* () {\n      const snapshot: AgentStateSnapshot = {\n        agentId,\n        timestamp: new Date(),\n        workingMemory: partialState.workingMemory ?? [],\n        currentStrategy: partialState.currentStrategy,\n        reasoningStep: partialState.reasoningStep,\n        activeTools: partialState.activeTools ?? [],\n        tokenUsage: partialState.tokenUsage ?? {\n          inputTokens: 0,\n          outputTokens: 0,\n          contextWindowUsed: 0,\n          contextWindowMax: 200_000,\n        },\n        costAccumulated: partialState.costAccumulated ?? 0,\n      };\n\n      yield* Ref.update(snapshotsRef, (snaps) => {\n        const updated = [...snaps, snapshot];\n        return updated.length > MAX_SNAPSHOTS ? updated.slice(-MAX_SNAPSHOTS) : updated;\n      });\n\n      return snapshot;\n    });\n\n  const getSnapshots = (\n    agentId: string,\n    limit: number = 50,\n  ): Effect.Effect<readonly AgentStateSnapshot[], never> =>\n    Effect.gen(function* () {\n      const snapshots = yield* Ref.get(snapshotsRef);\n      return snapshots.filter((s) => s.agentId === agentId).slice(-limit);\n    });\n\n  return { capture, getSnapshots } satisfies StateInspector;\n});\n","import { Effect, Context, Layer } from \"effect\";\nimport type { LogLevel, Metric, AgentStateSnapshot } from \"./types.js\";\nimport type { ExporterError } from \"./errors.js\";\nimport { makeTracer } from \"./tracing/tracer.js\";\nimport { makeStructuredLogger } from \"./logging/structured-logger.js\";\nimport { makeMetricsCollector } from \"./metrics/metrics-collector.js\";\nimport { makeStateInspector } from \"./debugging/state-inspector.js\";\n\n// ─── Service Tag ───\n\nexport class ObservabilityService extends Context.Tag(\"ObservabilityService\")<\n  ObservabilityService,\n  {\n    readonly withSpan: <A, E>(name: string, effect: Effect.Effect<A, E>, attributes?: Record<string, unknown>) => Effect.Effect<A, E>;\n    readonly getTraceContext: () => Effect.Effect<{ traceId: string; spanId: string }, never>;\n    readonly log: (level: LogLevel, message: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;\n    readonly debug: (message: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;\n    readonly info: (message: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;\n    readonly warn: (message: string, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;\n    readonly error: (message: string, error?: unknown, metadata?: Record<string, unknown>) => Effect.Effect<void, never>;\n    readonly incrementCounter: (name: string, value?: number, labels?: Record<string, string>) => Effect.Effect<void, never>;\n    readonly recordHistogram: (name: string, value: number, labels?: Record<string, string>) => Effect.Effect<void, never>;\n    readonly setGauge: (name: string, value: number, labels?: Record<string, string>) => Effect.Effect<void, never>;\n    readonly getMetrics: (filter?: { name?: string; startTime?: Date; endTime?: Date }) => Effect.Effect<readonly Metric[], never>;\n    readonly captureSnapshot: (agentId: string, state: Partial<AgentStateSnapshot>) => Effect.Effect<AgentStateSnapshot, never>;\n    readonly getSnapshots: (agentId: string, limit?: number) => Effect.Effect<readonly AgentStateSnapshot[], never>;\n    readonly flush: () => Effect.Effect<void, ExporterError>;\n  }\n>() {}\n\n// ─── Live Implementation ───\n\nexport const ObservabilityServiceLive = Layer.effect(\n  ObservabilityService,\n  Effect.gen(function* () {\n    const tracer = yield* makeTracer;\n    const logger = yield* makeStructuredLogger;\n    const metrics = yield* makeMetricsCollector;\n    const inspector = yield* makeStateInspector;\n\n    return {\n      withSpan: (name, effect, attributes) =>\n        tracer.withSpan(name, effect, attributes).pipe(\n          Effect.tap(() => metrics.incrementCounter(`span.${name}.completed`)),\n          Effect.tapError(() => metrics.incrementCounter(`span.${name}.errors`)),\n        ),\n      getTraceContext: () => tracer.getTraceContext(),\n      log: (level, message, metadata) => logger.log(level, message, metadata),\n      debug: (msg, meta) => logger.debug(msg, meta),\n      info: (msg, meta) => logger.info(msg, meta),\n      warn: (msg, meta) => logger.warn(msg, meta),\n      error: (msg, err, meta) => logger.error(msg, err, meta),\n      incrementCounter: (name, value, labels) => metrics.incrementCounter(name, value, labels),\n      recordHistogram: (name, value, labels) => metrics.recordHistogram(name, value, labels),\n      setGauge: (name, value, labels) => metrics.setGauge(name, value, labels),\n      getMetrics: (filter) => metrics.getMetrics(filter),\n      captureSnapshot: (agentId, state) => inspector.capture(agentId, state),\n      getSnapshots: (agentId, limit) => inspector.getSnapshots(agentId, limit),\n      flush: () => Effect.void as Effect.Effect<void, ExporterError>,\n    };\n  }),\n);\n","import { ObservabilityServiceLive } from \"./observability-service.js\";\n\nexport const createObservabilityLayer = () => ObservabilityServiceLive;\n"],"mappings":"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","names":["Effect","Ref","Effect","Ref","Effect","Ref","Effect","Effect"]}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@reactive-agents/observability",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsup --config ../../tsup.config.base.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "test:watch": "bun test --watch"
+  },
+  "dependencies": {
+    "effect": "^3.10.0",
+    "@reactive-agents/core": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "bun-types": "latest"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tylerjrbuell/reactive-agents-ts.git",
+    "directory": "packages/observability"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "description": "Observability for Reactive Agents — distributed tracing, metrics, and structured logging",
+  "homepage": "https://tylerjrbuell.github.io/reactive-agents-ts/",
+  "bugs": {
+    "url": "https://github.com/tylerjrbuell/reactive-agents-ts/issues"
+  }
+}