overai 1.4.0

package/dist/observability/adapters/external/maxim.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Maxim Observability Adapter
+ */
+import type { ObservabilityAdapter, TraceContext, SpanContext, SpanKind, SpanStatus, AttributionContext, ObservabilityToolConfig } from '../../types';
+export declare class MaximObservabilityAdapter implements ObservabilityAdapter {
+    readonly name = "maxim";
+    readonly isEnabled = true;
+    private memory;
+    private config;
+    constructor(config?: ObservabilityToolConfig);
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    startTrace(name: string, metadata?: Record<string, unknown>, attribution?: AttributionContext): TraceContext;
+    endTrace(traceId: string, status?: SpanStatus): void;
+    startSpan(traceId: string, name: string, kind: SpanKind, parentId?: string): SpanContext;
+    endSpan(spanId: string, status?: SpanStatus, attributes?: Record<string, unknown>): void;
+    addEvent(spanId: string, name: string, attributes?: Record<string, unknown>): void;
+    recordError(spanId: string, error: Error): void;
+    flush(): Promise<void>;
+}

package/dist/observability/adapters/external/maxim.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaximObservabilityAdapter = void 0;
+const memory_1 = require("../memory");
+class MaximObservabilityAdapter {
+    constructor(config) {
+        this.name = 'maxim';
+        this.isEnabled = true;
+        this.memory = new memory_1.MemoryObservabilityAdapter();
+        this.config = config || { name: 'maxim' };
+    }
+    async initialize() { }
+    async shutdown() { }
+    startTrace(name, metadata, attribution) { return this.memory.startTrace(name, metadata, attribution); }
+    endTrace(traceId, status) { this.memory.endTrace(traceId, status); }
+    startSpan(traceId, name, kind, parentId) { return this.memory.startSpan(traceId, name, kind, parentId); }
+    endSpan(spanId, status, attributes) { this.memory.endSpan(spanId, status, attributes); }
+    addEvent(spanId, name, attributes) { this.memory.addEvent(spanId, name, attributes); }
+    recordError(spanId, error) { this.memory.recordError(spanId, error); }
+    async flush() { }
+}
+exports.MaximObservabilityAdapter = MaximObservabilityAdapter;

package/dist/observability/adapters/external/patronus.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Patronus Observability Adapter
+ */
+import type { ObservabilityAdapter, TraceContext, SpanContext, SpanKind, SpanStatus, AttributionContext, ObservabilityToolConfig } from '../../types';
+export declare class PatronusObservabilityAdapter implements ObservabilityAdapter {
+    readonly name = "patronus";
+    readonly isEnabled = true;
+    private memory;
+    private config;
+    constructor(config?: ObservabilityToolConfig);
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    startTrace(name: string, metadata?: Record<string, unknown>, attribution?: AttributionContext): TraceContext;
+    endTrace(traceId: string, status?: SpanStatus): void;
+    startSpan(traceId: string, name: string, kind: SpanKind, parentId?: string): SpanContext;
+    endSpan(spanId: string, status?: SpanStatus, attributes?: Record<string, unknown>): void;
+    addEvent(spanId: string, name: string, attributes?: Record<string, unknown>): void;
+    recordError(spanId: string, error: Error): void;
+    flush(): Promise<void>;
+}

package/dist/observability/adapters/external/patronus.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatronusObservabilityAdapter = void 0;
+const memory_1 = require("../memory");
+class PatronusObservabilityAdapter {
+    constructor(config) {
+        this.name = 'patronus';
+        this.isEnabled = true;
+        this.memory = new memory_1.MemoryObservabilityAdapter();
+        this.config = config || { name: 'patronus' };
+    }
+    async initialize() { }
+    async shutdown() { }
+    startTrace(name, metadata, attribution) { return this.memory.startTrace(name, metadata, attribution); }
+    endTrace(traceId, status) { this.memory.endTrace(traceId, status); }
+    startSpan(traceId, name, kind, parentId) { return this.memory.startSpan(traceId, name, kind, parentId); }
+    endSpan(spanId, status, attributes) { this.memory.endSpan(spanId, status, attributes); }
+    addEvent(spanId, name, attributes) { this.memory.addEvent(spanId, name, attributes); }
+    recordError(spanId, error) { this.memory.recordError(spanId, error); }
+    async flush() { }
+}
+exports.PatronusObservabilityAdapter = PatronusObservabilityAdapter;

package/dist/observability/adapters/external/scorecard.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Scorecard Observability Adapter
+ */
+import type { ObservabilityAdapter, TraceContext, SpanContext, SpanKind, SpanStatus, AttributionContext, ObservabilityToolConfig } from '../../types';
+export declare class ScorecardObservabilityAdapter implements ObservabilityAdapter {
+    readonly name = "scorecard";
+    readonly isEnabled = true;
+    private memory;
+    private config;
+    constructor(config?: ObservabilityToolConfig);
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    startTrace(name: string, metadata?: Record<string, unknown>, attribution?: AttributionContext): TraceContext;
+    endTrace(traceId: string, status?: SpanStatus): void;
+    startSpan(traceId: string, name: string, kind: SpanKind, parentId?: string): SpanContext;
+    endSpan(spanId: string, status?: SpanStatus, attributes?: Record<string, unknown>): void;
+    addEvent(spanId: string, name: string, attributes?: Record<string, unknown>): void;
+    recordError(spanId: string, error: Error): void;
+    flush(): Promise<void>;
+}

package/dist/observability/adapters/external/scorecard.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScorecardObservabilityAdapter = void 0;
+const memory_1 = require("../memory");
+class ScorecardObservabilityAdapter {
+    constructor(config) {
+        this.name = 'scorecard';
+        this.isEnabled = true;
+        this.memory = new memory_1.MemoryObservabilityAdapter();
+        this.config = config || { name: 'scorecard' };
+    }
+    async initialize() { }
+    async shutdown() { }
+    startTrace(name, metadata, attribution) { return this.memory.startTrace(name, metadata, attribution); }
+    endTrace(traceId, status) { this.memory.endTrace(traceId, status); }
+    startSpan(traceId, name, kind, parentId) { return this.memory.startSpan(traceId, name, kind, parentId); }
+    endSpan(spanId, status, attributes) { this.memory.endSpan(spanId, status, attributes); }
+    addEvent(spanId, name, attributes) { this.memory.addEvent(spanId, name, attributes); }
+    recordError(spanId, error) { this.memory.recordError(spanId, error); }
+    async flush() { }
+}
+exports.ScorecardObservabilityAdapter = ScorecardObservabilityAdapter;

package/dist/observability/adapters/external/signoz.d.ts

@@ -0,0 +1,20 @@
+/**
+ * SigNoz Observability Adapter (OpenTelemetry)
+ */
+import type { ObservabilityAdapter, TraceContext, SpanContext, SpanKind, SpanStatus, AttributionContext, ObservabilityToolConfig } from '../../types';
+export declare class SigNozObservabilityAdapter implements ObservabilityAdapter {
+    readonly name = "signoz";
+    readonly isEnabled = true;
+    private memory;
+    private config;
+    constructor(config?: ObservabilityToolConfig);
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    startTrace(name: string, metadata?: Record<string, unknown>, attribution?: AttributionContext): TraceContext;
+    endTrace(traceId: string, status?: SpanStatus): void;
+    startSpan(traceId: string, name: string, kind: SpanKind, parentId?: string): SpanContext;
+    endSpan(spanId: string, status?: SpanStatus, attributes?: Record<string, unknown>): void;
+    addEvent(spanId: string, name: string, attributes?: Record<string, unknown>): void;
+    recordError(spanId: string, error: Error): void;
+    flush(): Promise<void>;
+}

package/dist/observability/adapters/external/signoz.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SigNozObservabilityAdapter = void 0;
+const memory_1 = require("../memory");
+class SigNozObservabilityAdapter {
+    constructor(config) {
+        this.name = 'signoz';
+        this.isEnabled = true;
+        this.memory = new memory_1.MemoryObservabilityAdapter();
+        this.config = config || { name: 'signoz' };
+    }
+    async initialize() { }
+    async shutdown() { }
+    startTrace(name, metadata, attribution) { return this.memory.startTrace(name, metadata, attribution); }
+    endTrace(traceId, status) { this.memory.endTrace(traceId, status); }
+    startSpan(traceId, name, kind, parentId) { return this.memory.startSpan(traceId, name, kind, parentId); }
+    endSpan(spanId, status, attributes) { this.memory.endSpan(spanId, status, attributes); }
+    addEvent(spanId, name, attributes) { this.memory.addEvent(spanId, name, attributes); }
+    recordError(spanId, error) { this.memory.recordError(spanId, error); }
+    async flush() { }
+}
+exports.SigNozObservabilityAdapter = SigNozObservabilityAdapter;

package/dist/observability/adapters/external/traceloop.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Traceloop Observability Adapter (OpenLLMetry)
+ */
+import type { ObservabilityAdapter, TraceContext, SpanContext, SpanKind, SpanStatus, AttributionContext, ObservabilityToolConfig } from '../../types';
+export declare class TraceloopObservabilityAdapter implements ObservabilityAdapter {
+    readonly name = "traceloop";
+    readonly isEnabled = true;
+    private memory;
+    private config;
+    constructor(config?: ObservabilityToolConfig);
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    startTrace(name: string, metadata?: Record<string, unknown>, attribution?: AttributionContext): TraceContext;
+    endTrace(traceId: string, status?: SpanStatus): void;
+    startSpan(traceId: string, name: string, kind: SpanKind, parentId?: string): SpanContext;
+    endSpan(spanId: string, status?: SpanStatus, attributes?: Record<string, unknown>): void;
+    addEvent(spanId: string, name: string, attributes?: Record<string, unknown>): void;
+    recordError(spanId: string, error: Error): void;
+    flush(): Promise<void>;
+}

package/dist/observability/adapters/external/traceloop.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceloopObservabilityAdapter = void 0;
+const memory_1 = require("../memory");
+class TraceloopObservabilityAdapter {
+    constructor(config) {
+        this.name = 'traceloop';
+        this.isEnabled = true;
+        this.memory = new memory_1.MemoryObservabilityAdapter();
+        this.config = config || { name: 'traceloop' };
+    }
+    async initialize() { }
+    async shutdown() { }
+    startTrace(name, metadata, attribution) { return this.memory.startTrace(name, metadata, attribution); }
+    endTrace(traceId, status) { this.memory.endTrace(traceId, status); }
+    startSpan(traceId, name, kind, parentId) { return this.memory.startSpan(traceId, name, kind, parentId); }
+    endSpan(spanId, status, attributes) { this.memory.endSpan(spanId, status, attributes); }
+    addEvent(spanId, name, attributes) { this.memory.addEvent(spanId, name, attributes); }
+    recordError(spanId, error) { this.memory.recordError(spanId, error); }
+    async flush() { }
+}
+exports.TraceloopObservabilityAdapter = TraceloopObservabilityAdapter;

package/dist/observability/adapters/external/weave.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Weave (Weights & Biases) Observability Adapter
+ */
+import type { ObservabilityAdapter, TraceContext, SpanContext, SpanKind, SpanStatus, AttributionContext, ObservabilityToolConfig } from '../../types';
+export declare class WeaveObservabilityAdapter implements ObservabilityAdapter {
+    readonly name = "weave";
+    readonly isEnabled = true;
+    private memory;
+    private config;
+    constructor(config?: ObservabilityToolConfig);
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    startTrace(name: string, metadata?: Record<string, unknown>, attribution?: AttributionContext): TraceContext;
+    endTrace(traceId: string, status?: SpanStatus): void;
+    startSpan(traceId: string, name: string, kind: SpanKind, parentId?: string): SpanContext;
+    endSpan(spanId: string, status?: SpanStatus, attributes?: Record<string, unknown>): void;
+    addEvent(spanId: string, name: string, attributes?: Record<string, unknown>): void;
+    recordError(spanId: string, error: Error): void;
+    flush(): Promise<void>;
+}

package/dist/observability/adapters/external/weave.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeaveObservabilityAdapter = void 0;
+const memory_1 = require("../memory");
+class WeaveObservabilityAdapter {
+    constructor(config) {
+        this.name = 'weave';
+        this.isEnabled = true;
+        this.memory = new memory_1.MemoryObservabilityAdapter();
+        this.config = config || { name: 'weave' };
+    }
+    async initialize() { }
+    async shutdown() { }
+    startTrace(name, metadata, attribution) { return this.memory.startTrace(name, metadata, attribution); }
+    endTrace(traceId, status) { this.memory.endTrace(traceId, status); }
+    startSpan(traceId, name, kind, parentId) { return this.memory.startSpan(traceId, name, kind, parentId); }
+    endSpan(spanId, status, attributes) { this.memory.endSpan(spanId, status, attributes); }
+    addEvent(spanId, name, attributes) { this.memory.addEvent(spanId, name, attributes); }
+    recordError(spanId, error) { this.memory.recordError(spanId, error); }
+    async flush() { }
+}
+exports.WeaveObservabilityAdapter = WeaveObservabilityAdapter;

package/dist/observability/adapters/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Observability Adapters Index
+ * Exports all built-in adapters and lazy loaders for external adapters
+ */
+export { NoopObservabilityAdapter, noopAdapter } from './noop';
+export { MemoryObservabilityAdapter, createMemoryAdapter } from './memory';
+export { ConsoleObservabilityAdapter, createConsoleAdapter } from './console';
+export type { ObservabilityAdapter, TraceContext, SpanContext, SpanKind, SpanStatus, SpanData, TraceData, SpanEvent, AttributionContext, ProviderMetadata, ObservabilityToolConfig, ObservabilityToolName, ObservabilityToolInfo } from '../types';
+export { OBSERVABILITY_TOOLS, getObservabilityToolInfo, listObservabilityTools, hasObservabilityToolEnvVar } from '../types';
+import type { ObservabilityAdapter, ObservabilityToolConfig, ObservabilityToolName } from '../types';
+/**
+ * Create an observability adapter by name
+ * Uses lazy loading for external adapters to avoid bundling dependencies
+ */
+export declare function createObservabilityAdapter(name: ObservabilityToolName, config?: ObservabilityToolConfig): Promise<ObservabilityAdapter>;
+/**
+ * Clear adapter cache (for testing)
+ */
+export declare function clearAdapterCache(): void;

package/dist/observability/adapters/index.js

@@ -0,0 +1,289 @@
+"use strict";
+/**
+ * Observability Adapters Index
+ * Exports all built-in adapters and lazy loaders for external adapters
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasObservabilityToolEnvVar = exports.listObservabilityTools = exports.getObservabilityToolInfo = exports.OBSERVABILITY_TOOLS = exports.createConsoleAdapter = exports.ConsoleObservabilityAdapter = exports.createMemoryAdapter = exports.MemoryObservabilityAdapter = exports.noopAdapter = exports.NoopObservabilityAdapter = void 0;
+exports.createObservabilityAdapter = createObservabilityAdapter;
+exports.clearAdapterCache = clearAdapterCache;
+// Built-in adapters
+var noop_1 = require("./noop");
+Object.defineProperty(exports, "NoopObservabilityAdapter", { enumerable: true, get: function () { return noop_1.NoopObservabilityAdapter; } });
+Object.defineProperty(exports, "noopAdapter", { enumerable: true, get: function () { return noop_1.noopAdapter; } });
+var memory_1 = require("./memory");
+Object.defineProperty(exports, "MemoryObservabilityAdapter", { enumerable: true, get: function () { return memory_1.MemoryObservabilityAdapter; } });
+Object.defineProperty(exports, "createMemoryAdapter", { enumerable: true, get: function () { return memory_1.createMemoryAdapter; } });
+var console_1 = require("./console");
+Object.defineProperty(exports, "ConsoleObservabilityAdapter", { enumerable: true, get: function () { return console_1.ConsoleObservabilityAdapter; } });
+Object.defineProperty(exports, "createConsoleAdapter", { enumerable: true, get: function () { return console_1.createConsoleAdapter; } });
+var types_1 = require("../types");
+Object.defineProperty(exports, "OBSERVABILITY_TOOLS", { enumerable: true, get: function () { return types_1.OBSERVABILITY_TOOLS; } });
+Object.defineProperty(exports, "getObservabilityToolInfo", { enumerable: true, get: function () { return types_1.getObservabilityToolInfo; } });
+Object.defineProperty(exports, "listObservabilityTools", { enumerable: true, get: function () { return types_1.listObservabilityTools; } });
+Object.defineProperty(exports, "hasObservabilityToolEnvVar", { enumerable: true, get: function () { return types_1.hasObservabilityToolEnvVar; } });
+const noop_2 = require("./noop");
+const memory_2 = require("./memory");
+const console_2 = require("./console");
+/**
+ * Adapter factory cache for lazy loading
+ */
+const adapterCache = new Map();
+/**
+ * Create an observability adapter by name
+ * Uses lazy loading for external adapters to avoid bundling dependencies
+ */
+async function createObservabilityAdapter(name, config) {
+    // Check cache first
+    const cacheKey = `${name}:${JSON.stringify(config || {})}`;
+    const cached = adapterCache.get(cacheKey);
+    if (cached)
+        return cached;
+    let adapter;
+    switch (name) {
+        case 'noop':
+            adapter = noop_2.noopAdapter;
+            break;
+        case 'memory':
+            adapter = new memory_2.MemoryObservabilityAdapter();
+            break;
+        case 'console':
+            adapter = new console_2.ConsoleObservabilityAdapter({ verbose: config?.debug });
+            break;
+        case 'langfuse':
+            adapter = await createLangfuseAdapter(config);
+            break;
+        case 'langsmith':
+            adapter = await createLangSmithAdapter(config);
+            break;
+        case 'langwatch':
+            adapter = await createLangWatchAdapter(config);
+            break;
+        case 'arize':
+            adapter = await createArizeAdapter(config);
+            break;
+        case 'axiom':
+            adapter = await createAxiomAdapter(config);
+            break;
+        case 'braintrust':
+            adapter = await createBraintrustAdapter(config);
+            break;
+        case 'helicone':
+            adapter = await createHeliconeAdapter(config);
+            break;
+        case 'laminar':
+            adapter = await createLaminarAdapter(config);
+            break;
+        case 'maxim':
+            adapter = await createMaximAdapter(config);
+            break;
+        case 'patronus':
+            adapter = await createPatronusAdapter(config);
+            break;
+        case 'scorecard':
+            adapter = await createScorecardAdapter(config);
+            break;
+        case 'signoz':
+            adapter = await createSigNozAdapter(config);
+            break;
+        case 'traceloop':
+            adapter = await createTraceloopAdapter(config);
+            break;
+        case 'weave':
+            adapter = await createWeaveAdapter(config);
+            break;
+        default:
+            console.warn(`Unknown observability tool: ${name}, using noop adapter`);
+            adapter = noop_2.noopAdapter;
+    }
+    // Initialize if needed
+    if (adapter.initialize) {
+        await adapter.initialize();
+    }
+    // Cache the adapter
+    adapterCache.set(cacheKey, adapter);
+    return adapter;
+}
+/**
+ * Clear adapter cache (for testing)
+ */
+function clearAdapterCache() {
+    adapterCache.clear();
+}
+// ============================================================================
+// Lazy-loaded external adapter factories
+// These create wrapper adapters that delegate to external SDKs
+// ============================================================================
+async function createLangfuseAdapter(config) {
+    try {
+        const { LangfuseObservabilityAdapter } = await Promise.resolve().then(() => __importStar(require('./external/langfuse')));
+        return new LangfuseObservabilityAdapter(config);
+    }
+    catch (error) {
+        console.warn('Langfuse not available, using memory adapter. Install with: npm install langfuse');
+        return new memory_2.MemoryObservabilityAdapter();
+    }
+}
+async function createLangSmithAdapter(config) {
+    try {
+        const { LangSmithObservabilityAdapter } = await Promise.resolve().then(() => __importStar(require('./external/langsmith')));
+        return new LangSmithObservabilityAdapter(config);
+    }
+    catch (error) {
+        console.warn('LangSmith not available, using memory adapter. Install with: npm install langsmith');
+        return new memory_2.MemoryObservabilityAdapter();
+    }
+}
+async function createLangWatchAdapter(config) {
+    try {
+        const { LangWatchObservabilityAdapter } = await Promise.resolve().then(() => __importStar(require('./external/langwatch')));
+        return new LangWatchObservabilityAdapter(config);
+    }
+    catch (error) {
+        console.warn('LangWatch not available, using memory adapter. Install with: npm install langwatch');
+        return new memory_2.MemoryObservabilityAdapter();
+    }
+}
+async function createArizeAdapter(config) {
+    try {
+        const { ArizeObservabilityAdapter } = await Promise.resolve().then(() => __importStar(require('./external/arize')));
+        return new ArizeObservabilityAdapter(config);
+    }
+    catch (error) {
+        console.warn('Arize not available, using memory adapter. Install with: npm install arize-phoenix');
+        return new memory_2.MemoryObservabilityAdapter();
+    }
+}
+async function createAxiomAdapter(config) {
+    try {
+        const { AxiomObservabilityAdapter } = await Promise.resolve().then(() => __importStar(require('./external/axiom')));
+        return new AxiomObservabilityAdapter(config);
+    }
+    catch (error) {
+        console.warn('Axiom not available, using memory adapter. Install with: npm install @axiomhq/js');
+        return new memory_2.MemoryObservabilityAdapter();
+    }
+}
+async function createBraintrustAdapter(config) {
+    try {
+        const { BraintrustObservabilityAdapter } = await Promise.resolve().then(() => __importStar(require('./external/braintrust')));
+        return new BraintrustObservabilityAdapter(config);
+    }
+    catch (error) {
+        console.warn('Braintrust not available, using memory adapter. Install with: npm install braintrust');
+        return new memory_2.MemoryObservabilityAdapter();
+    }
+}
+async function createHeliconeAdapter(config) {
+    try {
+        const { HeliconeObservabilityAdapter } = await Promise.resolve().then(() => __importStar(require('./external/helicone')));
+        return new HeliconeObservabilityAdapter(config);
+    }
+    catch (error) {
+        console.warn('Helicone not available, using memory adapter. Install with: npm install @helicone/helicone');
+        return new memory_2.MemoryObservabilityAdapter();
+    }
+}
+async function createLaminarAdapter(config) {
+    try {
+        const { LaminarObservabilityAdapter } = await Promise.resolve().then(() => __importStar(require('./external/laminar')));
+        return new LaminarObservabilityAdapter(config);
+    }
+    catch (error) {
+        console.warn('Laminar not available, using memory adapter. Install with: npm install @lmnr-ai/lmnr');
+        return new memory_2.MemoryObservabilityAdapter();
+    }
+}
+async function createMaximAdapter(config) {
+    try {
+        const { MaximObservabilityAdapter } = await Promise.resolve().then(() => __importStar(require('./external/maxim')));
+        return new MaximObservabilityAdapter(config);
+    }
+    catch (error) {
+        console.warn('Maxim not available, using memory adapter. Install with: npm install @maximai/maxim-js');
+        return new memory_2.MemoryObservabilityAdapter();
+    }
+}
+async function createPatronusAdapter(config) {
+    try {
+        const { PatronusObservabilityAdapter } = await Promise.resolve().then(() => __importStar(require('./external/patronus')));
+        return new PatronusObservabilityAdapter(config);
+    }
+    catch (error) {
+        console.warn('Patronus not available, using memory adapter. Install with: npm install patronus');
+        return new memory_2.MemoryObservabilityAdapter();
+    }
+}
+async function createScorecardAdapter(config) {
+    try {
+        const { ScorecardObservabilityAdapter } = await Promise.resolve().then(() => __importStar(require('./external/scorecard')));
+        return new ScorecardObservabilityAdapter(config);
+    }
+    catch (error) {
+        console.warn('Scorecard not available, using memory adapter. Install with: npm install @scorecard-ai/sdk');
+        return new memory_2.MemoryObservabilityAdapter();
+    }
+}
+async function createSigNozAdapter(config) {
+    try {
+        const { SigNozObservabilityAdapter } = await Promise.resolve().then(() => __importStar(require('./external/signoz')));
+        return new SigNozObservabilityAdapter(config);
+    }
+    catch (error) {
+        console.warn('SigNoz not available, using memory adapter. Install with: npm install @opentelemetry/api');
+        return new memory_2.MemoryObservabilityAdapter();
+    }
+}
+async function createTraceloopAdapter(config) {
+    try {
+        const { TraceloopObservabilityAdapter } = await Promise.resolve().then(() => __importStar(require('./external/traceloop')));
+        return new TraceloopObservabilityAdapter(config);
+    }
+    catch (error) {
+        console.warn('Traceloop not available, using memory adapter. Install with: npm install @traceloop/node-server-sdk');
+        return new memory_2.MemoryObservabilityAdapter();
+    }
+}
+async function createWeaveAdapter(config) {
+    try {
+        const { WeaveObservabilityAdapter } = await Promise.resolve().then(() => __importStar(require('./external/weave')));
+        return new WeaveObservabilityAdapter(config);
+    }
+    catch (error) {
+        console.warn('Weave not available, using memory adapter. Install with: npm install weave');
+        return new memory_2.MemoryObservabilityAdapter();
+    }
+}

package/dist/observability/adapters/memory.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Memory Observability Adapter
+ * In-memory storage for development and testing
+ */
+import type { ObservabilityAdapter, TraceContext, SpanContext, SpanKind, SpanStatus, SpanData, TraceData, AttributionContext } from '../types';
+/**
+ * Memory Observability Adapter
+ * Stores all traces and spans in memory for development/testing
+ */
+export declare class MemoryObservabilityAdapter implements ObservabilityAdapter {
+    readonly name = "memory";
+    readonly isEnabled = true;
+    private traces;
+    private spans;
+    private maxTraces;
+    constructor(options?: {
+        maxTraces?: number;
+    });
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    startTrace(name: string, metadata?: Record<string, unknown>, attribution?: AttributionContext): TraceContext;
+    endTrace(traceId: string, status?: SpanStatus): void;
+    startSpan(traceId: string, name: string, kind: SpanKind, parentId?: string): SpanContext;
+    endSpan(spanId: string, status?: SpanStatus, attributes?: Record<string, unknown>): void;
+    addEvent(spanId: string, name: string, attributes?: Record<string, unknown>): void;
+    recordError(spanId: string, error: Error): void;
+    flush(): Promise<void>;
+    getTrace(traceId: string): TraceData | undefined;
+    getSpan(spanId: string): SpanData | undefined;
+    getAllTraces(): TraceData[];
+    getAllSpans(): SpanData[];
+    getTraceSpans(traceId: string): SpanData[];
+    clear(): void;
+    getStats(): {
+        traces: number;
+        spans: number;
+    };
+}
+export declare function createMemoryAdapter(options?: {
+    maxTraces?: number;
+}): MemoryObservabilityAdapter;