@elsium-ai/observe 0.2.3 → 0.4.0

package/README.md

@@ -1171,6 +1171,125 @@ await tracer.flush()
 
 ---
 
+## Experiments Persistence
+
+### `createFileExperimentStore`
+
+Creates a file-based storage adapter for saving and loading experiment results to disk. Experiment data is serialized as JSON files in the specified directory.
+
+```ts
+function createFileExperimentStore(dir: string): ExperimentStore
+```
+
+| Parameter | Type | Description |
+|---|---|---|
+| `dir` | `string` | Directory path where experiment result files will be stored |
+
+**Returns:** `ExperimentStore`
+
+```ts
+interface ExperimentStore {
+  save(experiment: ExperimentResults): Promise<void>
+  load(experimentId: string): Promise<ExperimentResults | null>
+  list(): Promise<string[]>
+}
+```
+
+```ts
+import { createExperiment, createFileExperimentStore } from 'elsium-ai/observe'
+
+const store = createFileExperimentStore('./experiments')
+
+const experiment = createExperiment({
+  name: 'prompt-comparison',
+  variants: [
+    { name: 'concise', config: { system: 'Be brief.' } },
+    { name: 'detailed', config: { system: 'Be thorough.' } },
+  ],
+})
+
+const results = await experiment.run(evaluator)
+
+// Persist results to disk
+await store.save(results)
+
+// Load results later
+const loaded = await store.load(results.id)
+```
+
+---
+
+## Auto-Instrumentation
+
+### `instrumentComplete`
+
+Wraps an LLM completion function with automatic span creation. Every call produces a span with model, token, cost, and latency metadata.
+
+```ts
+function instrumentComplete(
+  complete: (request: CompletionRequest) => Promise<LLMResponse>,
+  tracer: Tracer,
+): (request: CompletionRequest) => Promise<LLMResponse>
+```
+
+| Parameter | Type | Description |
+|---|---|---|
+| `complete` | `(request: CompletionRequest) => Promise<LLMResponse>` | The LLM completion function to instrument |
+| `tracer` | `Tracer` | The tracer instance to record spans to |
+
+**Returns:** A wrapped completion function with the same signature.
+
+```ts
+import { observe, instrumentComplete } from 'elsium-ai/observe'
+
+const tracer = observe()
+
+const tracedComplete = instrumentComplete(
+  (req) => llm.complete(req),
+  tracer,
+)
+
+// Every call now creates an 'llm' span automatically
+const response = await tracedComplete({ model: 'gpt-4o', messages })
+```
+
+### `instrumentAgent`
+
+Wraps an agent's `run` method with automatic span creation. Produces an `agent` span that captures the agent name, input, output, token usage, and tool calls.
+
+```ts
+function instrumentAgent(
+  agent: Agent,
+  tracer: Tracer,
+): Agent
+```
+
+| Parameter | Type | Description |
+|---|---|---|
+| `agent` | `Agent` | The agent to instrument |
+| `tracer` | `Tracer` | The tracer instance to record spans to |
+
+**Returns:** A new `Agent` with the same interface, where `run` and `chat` are automatically traced.
+
+```ts
+import { observe, instrumentAgent } from 'elsium-ai/observe'
+import { defineAgent } from 'elsium-ai/agents'
+
+const tracer = observe()
+
+const agent = defineAgent(
+  { name: 'assistant', system: 'You are helpful.' },
+  { complete: (req) => llm.complete(req) },
+)
+
+const tracedAgent = instrumentAgent(agent, tracer)
+
+// Every run/chat call now creates an 'agent' span automatically
+const result = await tracedAgent.run('Hello')
+```
+
+---
+
 ## Part of ElsiumAI
 
 This package is the observability layer of the [ElsiumAI](https://github.com/elsium-ai/elsium-ai) framework. See the [full documentation](https://github.com/elsium-ai/elsium-ai) for guides and examples.

package/dist/experiment.d.ts

@@ -0,0 +1,34 @@
+export interface ExperimentVariant {
+    name: string;
+    weight: number;
+    config: Record<string, unknown>;
+}
+export interface ExperimentResults {
+    name: string;
+    totalAssignments: number;
+    variants: Record<string, {
+        assignments: number;
+        metrics: Record<string, {
+            sum: number;
+            count: number;
+            avg: number;
+        }>;
+    }>;
+}
+export interface Experiment {
+    assign(userId?: string): ExperimentVariant;
+    record(variant: string, metrics: Record<string, number>): void;
+    results(): ExperimentResults;
+}
+export interface ExperimentStore {
+    save(name: string, data: ExperimentResults): void;
+    load(name: string): ExperimentResults | null;
+}
+export interface ExperimentConfig {
+    name: string;
+    variants: ExperimentVariant[];
+    store?: ExperimentStore;
+}
+export declare function createFileExperimentStore(dir: string): ExperimentStore;
+export declare function createExperiment(config: ExperimentConfig): Experiment;
+//# sourceMappingURL=experiment.d.ts.map

package/dist/experiment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"experiment.d.ts","sourceRoot":"","sources":["../src/experiment.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,iBAAiB;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B;AAED,MAAM,WAAW,iBAAiB;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,gBAAgB,EAAE,MAAM,CAAA;IACxB,QAAQ,EAAE,MAAM,CACf,MAAM,EACN;QACC,WAAW,EAAE,MAAM,CAAA;QACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KACpE,CACD,CAAA;CACD;AAED,MAAM,WAAW,UAAU;IAC1B,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,iBAAiB,CAAA;IAC1C,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;IAC9D,OAAO,IAAI,iBAAiB,CAAA;CAC5B;AAED,MAAM,WAAW,eAAe;IAC/B,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,GAAG,IAAI,CAAA;IACjD,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAAA;CAC5C;AAED,MAAM,WAAW,gBAAgB;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,iBAAiB,EAAE,CAAA;IAC7B,KAAK,CAAC,EAAE,eAAe,CAAA;CACvB;AAED,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CA4BtE;AAyDD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,UAAU,CAmErE"}

package/dist/index.d.ts

@@ -10,6 +10,10 @@ export { createAuditTrail, auditMiddleware } from './audit';
 export type { AuditEventType, AuditEvent, AuditStorageAdapter, AuditQueryFilter, AuditIntegrityResult, AuditTrailConfig, AuditTrail, } from './audit';
 export { createProvenanceTracker } from './provenance';
 export type { ProvenanceRecord, ProvenanceTracker } from './provenance';
+export { createExperiment, createFileExperimentStore } from './experiment';
+export type { Experiment, ExperimentConfig, ExperimentVariant, ExperimentResults, ExperimentStore, } from './experiment';
+export { instrumentComplete, instrumentAgent } from './instrument';
+export type { InstrumentableAgent } from './instrument';
 export { toOTelSpan, toOTelExportRequest, toTraceparent, parseTraceparent, injectTraceContext, extractTraceContext, createOTLPExporter, } from './otel';
 export type { OTelSpan, OTelSpanKind, OTelStatusCode, OTelAttribute, OTelAttributeValue, OTelEvent, OTelResource, OTelExportRequest, TraceContext, OTLPExporterConfig, } from './otel';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACnC,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AAG1F,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AACnE,YAAY,EACX,UAAU,EACV,gBAAgB,EAChB,YAAY,EACZ,mBAAmB,EACnB,SAAS,EACT,aAAa,EACb,sBAAsB,EACtB,eAAe,EACf,cAAc,GACd,MAAM,eAAe,CAAA;AAGtB,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAClC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAG9F,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACzC,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAG9D,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAC3D,YAAY,EACX,cAAc,EACd,UAAU,EACV,mBAAmB,EACnB,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,UAAU,GACV,MAAM,SAAS,CAAA;AAGhB,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAA;AACtD,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAGvE,OAAO,EACN,UAAU,EACV,mBAAmB,EACnB,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,GAClB,MAAM,QAAQ,CAAA;AACf,YAAY,EACX,QAAQ,EACR,YAAY,EACZ,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,GAClB,MAAM,QAAQ,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACnC,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AAG1F,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AACnE,YAAY,EACX,UAAU,EACV,gBAAgB,EAChB,YAAY,EACZ,mBAAmB,EACnB,SAAS,EACT,aAAa,EACb,sBAAsB,EACtB,eAAe,EACf,cAAc,GACd,MAAM,eAAe,CAAA;AAGtB,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAClC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAG9F,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACzC,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAG9D,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAC3D,YAAY,EACX,cAAc,EACd,UAAU,EACV,mBAAmB,EACnB,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,UAAU,GACV,MAAM,SAAS,CAAA;AAGhB,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAA;AACtD,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAGvE,OAAO,EAAE,gBAAgB,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAA;AAC1E,YAAY,EACX,UAAU,EACV,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,GACf,MAAM,cAAc,CAAA;AAGrB,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAClE,YAAY,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAGvD,OAAO,EACN,UAAU,EACV,mBAAmB,EACnB,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,GAClB,MAAM,QAAQ,CAAA;AACf,YAAY,EACX,QAAQ,EACR,YAAY,EACZ,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,GAClB,MAAM,QAAQ,CAAA"}

package/dist/index.js

@@ -140,6 +140,11 @@ function createLogger(options = {}) {
     }
   };
 }
+// ../core/src/schema.ts
+var log = createLogger();
+// ../core/src/registry.ts
+var log2 = createLogger();
+var BLOCKED_KEYS = new Set(["__proto__", "constructor", "prototype"]);
 // src/span.ts
 function createSpan(name, options = {}) {
   const id = generateId("spn");
@@ -492,7 +497,7 @@ function createCostEngine(config = {}) {
 }
 // src/tracer.ts
 import { writeFileSync } from "node:fs";
-var log = createLogger();
+var log3 = createLogger();
 function observe(config = {}) {
   const {
     output = ["console"],
@@ -515,7 +520,7 @@ function observe(config = {}) {
           try {
             writeFileSync(filename, JSON.stringify(spansToExport, null, 2));
           } catch (err2) {
-            log.error("Failed to write trace file", {
+            log3.error("Failed to write trace file", {
               error: err2 instanceof Error ? err2.message : String(err2)
             });
           }
@@ -590,7 +595,7 @@ function observe(config = {}) {
 function consoleHandler(span) {
   const duration = span.durationMs !== undefined ? `${span.durationMs}ms` : "running";
   const status = span.status === "error" ? "[ERROR]" : span.status === "ok" ? "[OK]" : "[...]";
-  log.info("span", {
+  log3.info("span", {
     trace: span.traceId,
     span: span.name,
     kind: span.kind,
@@ -920,8 +925,190 @@ function createProvenanceTracker(options) {
     }
   };
 }
+// src/experiment.ts
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join } from "node:path";
+var log4 = createLogger();
+function createFileExperimentStore(dir) {
+  return {
+    save(name, data) {
+      try {
+        if (!existsSync(dir)) {
+          mkdirSync(dir, { recursive: true });
+        }
+        const filePath = join(dir, `${name}.json`);
+        writeFileSync2(filePath, JSON.stringify(data, null, 2));
+      } catch (err2) {
+        log4.error("Failed to save experiment", {
+          name,
+          error: err2 instanceof Error ? err2.message : String(err2)
+        });
+      }
+    },
+    load(name) {
+      try {
+        const filePath = join(dir, `${name}.json`);
+        if (!existsSync(filePath))
+          return null;
+        const raw = readFileSync(filePath, "utf-8");
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+function loadFromStore(store, name, stats) {
+  const saved = store.load(name);
+  if (!saved)
+    return;
+  for (const [vName, vData] of Object.entries(saved.variants)) {
+    if (!stats[vName])
+      continue;
+    stats[vName].assignments = vData.assignments;
+    for (const [key, m] of Object.entries(vData.metrics)) {
+      stats[vName].metrics[key] = { sum: m.sum, count: m.count };
+    }
+  }
+  log4.debug("Loaded experiment state", { name, totalAssignments: saved.totalAssignments });
+}
+function recordMetrics(s, metrics) {
+  for (const [key, value] of Object.entries(metrics)) {
+    if (!s.metrics[key]) {
+      s.metrics[key] = { sum: 0, count: 0 };
+    }
+    s.metrics[key].sum += value;
+    s.metrics[key].count++;
+  }
+}
+function buildResults(name, stats) {
+  let totalAssignments = 0;
+  const variantResults = {};
+  for (const [vName, s] of Object.entries(stats)) {
+    totalAssignments += s.assignments;
+    const metricsResult = {};
+    for (const [key, m] of Object.entries(s.metrics)) {
+      metricsResult[key] = {
+        sum: m.sum,
+        count: m.count,
+        avg: m.count > 0 ? m.sum / m.count : 0
+      };
+    }
+    variantResults[vName] = {
+      assignments: s.assignments,
+      metrics: metricsResult
+    };
+  }
+  return { name, totalAssignments, variants: variantResults };
+}
+function createExperiment(config) {
+  const { name, variants, store } = config;
+  if (variants.length === 0) {
+    throw new Error("Experiment must have at least one variant");
+  }
+  const totalWeight = variants.reduce((sum, v) => sum + v.weight, 0);
+  const stats = {};
+  for (const v of variants) {
+    stats[v.name] = { assignments: 0, metrics: {} };
+  }
+  if (store) {
+    loadFromStore(store, name, stats);
+  }
+  function hashAssign(userId) {
+    const hash = createHash3("sha256").update(`${name}:${userId}`).digest();
+    const value = hash.readUInt32BE(0) % 1e4 / 1e4;
+    return pickVariant(value);
+  }
+  function randomAssign() {
+    const value = Math.random();
+    return pickVariant(value);
+  }
+  function pickVariant(value) {
+    let cumulative = 0;
+    for (const v of variants) {
+      cumulative += v.weight / totalWeight;
+      if (value < cumulative)
+        return v;
+    }
+    return variants[variants.length - 1];
+  }
+  return {
+    assign(userId) {
+      const variant = userId ? hashAssign(userId) : randomAssign();
+      const s = stats[variant.name];
+      if (s)
+        s.assignments++;
+      log4.debug("Experiment assignment", {
+        experiment: name,
+        variant: variant.name,
+        userId
+      });
+      return variant;
+    },
+    record(variant, metrics) {
+      const s = stats[variant];
+      if (!s)
+        return;
+      recordMetrics(s, metrics);
+      if (store) {
+        store.save(name, this.results());
+      }
+    },
+    results() {
+      return buildResults(name, stats);
+    }
+  };
+}
+// src/instrument.ts
+function instrumentComplete(complete, tracer) {
+  return async (request) => {
+    const span = tracer.startSpan("llm.complete", "llm");
+    span.setMetadata("model", request.model ?? "default");
+    span.setMetadata("messageCount", request.messages.length);
+    try {
+      const response = await complete(request);
+      span.setMetadata("inputTokens", response.usage.inputTokens);
+      span.setMetadata("outputTokens", response.usage.outputTokens);
+      span.setMetadata("totalCost", response.cost.totalCost);
+      span.setMetadata("provider", response.provider);
+      span.setMetadata("latencyMs", response.latencyMs);
+      tracer.trackLLMCall({
+        model: response.model,
+        inputTokens: response.usage.inputTokens,
+        outputTokens: response.usage.outputTokens,
+        cost: response.cost.totalCost,
+        latencyMs: response.latencyMs
+      });
+      span.end({ status: "ok" });
+      return response;
+    } catch (error) {
+      span.setMetadata("error", error instanceof Error ? error.message : String(error));
+      span.end({ status: "error" });
+      throw error;
+    }
+  };
+}
+function instrumentAgent(agent, tracer) {
+  const originalRun = agent.run.bind(agent);
+  const instrumented = Object.create(agent);
+  instrumented.run = async (input, options) => {
+    const span = tracer.startSpan(`agent.${agent.name}`, "agent");
+    span.setMetadata("agentName", agent.name);
+    try {
+      const result = await originalRun(input, options);
+      span.end({ status: "ok" });
+      return result;
+    } catch (error) {
+      span.setMetadata("error", error instanceof Error ? error.message : String(error));
+      span.end({ status: "error" });
+      throw error;
+    }
+  };
+  return instrumented;
+}
 // src/otel.ts
-var log2 = createLogger();
+var log5 = createLogger();
 var SPAN_KIND_MAP = {
   llm: 3,
   tool: 1,
@@ -1062,10 +1249,10 @@ function createOTLPExporter(config) {
         body: JSON.stringify(payload)
       });
       if (!response.ok) {
-        log2.error(`OTLP export failed: ${response.status} ${response.statusText}`);
+        log5.error(`OTLP export failed: ${response.status} ${response.statusText}`);
       }
     } catch (err2) {
-      log2.error("OTLP export error", { error: err2 instanceof Error ? err2.message : String(err2) });
+      log5.error("OTLP export error", { error: err2 instanceof Error ? err2.message : String(err2) });
     }
   }
   function startAutoFlush() {
@@ -1108,12 +1295,16 @@ export {
   registerModelTier,
   parseTraceparent,
   observe,
+  instrumentComplete,
+  instrumentAgent,
   injectTraceContext,
   extractTraceContext,
   createSpan,
   createProvenanceTracker,
   createOTLPExporter,
   createMetrics,
+  createFileExperimentStore,
+  createExperiment,
   createCostEngine,
   createAuditTrail,
   auditMiddleware

package/dist/instrument.d.ts

@@ -0,0 +1,9 @@
+import type { CompletionRequest, LLMResponse } from '@elsium-ai/core';
+import type { Tracer } from './tracer';
+export declare function instrumentComplete(complete: (request: CompletionRequest) => Promise<LLMResponse>, tracer: Tracer): (request: CompletionRequest) => Promise<LLMResponse>;
+export interface InstrumentableAgent {
+    readonly name: string;
+    run(input: string, options?: Record<string, unknown>): Promise<unknown>;
+}
+export declare function instrumentAgent<T extends InstrumentableAgent>(agent: T, tracer: Tracer): T;
+//# sourceMappingURL=instrument.d.ts.map

package/dist/instrument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrument.d.ts","sourceRoot":"","sources":["../src/instrument.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AACrE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEtC,wBAAgB,kBAAkB,CACjC,QAAQ,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,WAAW,CAAC,EAC9D,MAAM,EAAE,MAAM,GACZ,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,WAAW,CAAC,CAgCtD;AAED,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;CACvE;AAED,wBAAgB,eAAe,CAAC,CAAC,SAAS,mBAAmB,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,CAuB1F"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@elsium-ai/observe",
-	"version": "0.2.3",
+	"version": "0.4.0",
 	"description": "Observability, tracing, and cost tracking for ElsiumAI",
 	"license": "MIT",
 	"author": "Eric Utrera <ebutrera9103@gmail.com>",
@@ -26,7 +26,7 @@
 		"dev": "bun --watch src/index.ts"
 	},
 	"dependencies": {
-		"@elsium-ai/core": "^0.2.3"
+		"@elsium-ai/core": "^0.4.0"
 	},
 	"devDependencies": {
 		"typescript": "^5.7.0"