overai 1.4.0

package/dist/observability/adapters/console.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Console Observability Adapter
+ * Logs traces and spans to console for debugging
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleObservabilityAdapter = void 0;
+exports.createConsoleAdapter = createConsoleAdapter;
+const memory_1 = require("./memory");
+/**
+ * Console Observability Adapter
+ * Wraps memory adapter and logs all operations to console
+ */
+class ConsoleObservabilityAdapter {
+    constructor(options = {}) {
+        this.name = 'console';
+        this.isEnabled = true;
+        this.memory = new memory_1.MemoryObservabilityAdapter();
+        this.verbose = options.verbose ?? false;
+    }
+    async initialize() {
+        console.log('[OBSERVABILITY] Console adapter initialized');
+    }
+    async shutdown() {
+        console.log('[OBSERVABILITY] Console adapter shutdown');
+        await this.memory.shutdown();
+    }
+    startTrace(name, metadata, attribution) {
+        const ctx = this.memory.startTrace(name, metadata, attribution);
+        console.log(`[TRACE START] ${name}`, this.verbose ? { traceId: ctx.traceId, metadata, attribution } : '');
+        return ctx;
+    }
+    endTrace(traceId, status) {
+        console.log(`[TRACE END] ${traceId} - ${status || 'completed'}`);
+        this.memory.endTrace(traceId, status);
+    }
+    startSpan(traceId, name, kind, parentId) {
+        const ctx = this.memory.startSpan(traceId, name, kind, parentId);
+        console.log(`  [SPAN START] ${name} (${kind})`, this.verbose ? { spanId: ctx.spanId, parentId } : '');
+        return ctx;
+    }
+    endSpan(spanId, status, attributes) {
+        console.log(`  [SPAN END] ${spanId} - ${status || 'completed'}`, this.verbose && attributes ? attributes : '');
+        this.memory.endSpan(spanId, status, attributes);
+    }
+    addEvent(spanId, name, attributes) {
+        console.log(`    [EVENT] ${name}`, this.verbose && attributes ? attributes : '');
+        this.memory.addEvent(spanId, name, attributes);
+    }
+    recordError(spanId, error) {
+        console.error(`    [ERROR] ${error.message}`, this.verbose ? error.stack : '');
+        this.memory.recordError(spanId, error);
+    }
+    async flush() {
+        await this.memory.flush();
+    }
+    // Expose memory adapter methods for testing
+    getTrace(traceId) {
+        return this.memory.getTrace(traceId);
+    }
+    getAllTraces() {
+        return this.memory.getAllTraces();
+    }
+    clear() {
+        this.memory.clear();
+    }
+}
+exports.ConsoleObservabilityAdapter = ConsoleObservabilityAdapter;
+function createConsoleAdapter(options) {
+    return new ConsoleObservabilityAdapter(options);
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Arize (Phoenix) Observability Adapter
+ */
+import type { ObservabilityAdapter, TraceContext, SpanContext, SpanKind, SpanStatus, AttributionContext, ObservabilityToolConfig } from '../../types';
+export declare class ArizeObservabilityAdapter implements ObservabilityAdapter {
+    readonly name = "arize";
+    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/arize.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArizeObservabilityAdapter = void 0;
+const memory_1 = require("../memory");
+class ArizeObservabilityAdapter {
+    constructor(config) {
+        this.name = 'arize';
+        this.isEnabled = true;
+        this.memory = new memory_1.MemoryObservabilityAdapter();
+        this.config = config || { name: 'arize' };
+    }
+    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.ArizeObservabilityAdapter = ArizeObservabilityAdapter;

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

@@ -0,0 +1,20 @@
+/**
+ * Axiom Observability Adapter
+ */
+import type { ObservabilityAdapter, TraceContext, SpanContext, SpanKind, SpanStatus, AttributionContext, ObservabilityToolConfig } from '../../types';
+export declare class AxiomObservabilityAdapter implements ObservabilityAdapter {
+    readonly name = "axiom";
+    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/axiom.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxiomObservabilityAdapter = void 0;
+const memory_1 = require("../memory");
+class AxiomObservabilityAdapter {
+    constructor(config) {
+        this.name = 'axiom';
+        this.isEnabled = true;
+        this.memory = new memory_1.MemoryObservabilityAdapter();
+        this.config = config || { name: 'axiom' };
+    }
+    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.AxiomObservabilityAdapter = AxiomObservabilityAdapter;

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

@@ -0,0 +1,20 @@
+/**
+ * Braintrust Observability Adapter
+ */
+import type { ObservabilityAdapter, TraceContext, SpanContext, SpanKind, SpanStatus, AttributionContext, ObservabilityToolConfig } from '../../types';
+export declare class BraintrustObservabilityAdapter implements ObservabilityAdapter {
+    readonly name = "braintrust";
+    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/braintrust.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BraintrustObservabilityAdapter = void 0;
+const memory_1 = require("../memory");
+class BraintrustObservabilityAdapter {
+    constructor(config) {
+        this.name = 'braintrust';
+        this.isEnabled = true;
+        this.memory = new memory_1.MemoryObservabilityAdapter();
+        this.config = config || { name: 'braintrust' };
+    }
+    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.BraintrustObservabilityAdapter = BraintrustObservabilityAdapter;

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

@@ -0,0 +1,20 @@
+/**
+ * Helicone Observability Adapter
+ */
+import type { ObservabilityAdapter, TraceContext, SpanContext, SpanKind, SpanStatus, AttributionContext, ObservabilityToolConfig } from '../../types';
+export declare class HeliconeObservabilityAdapter implements ObservabilityAdapter {
+    readonly name = "helicone";
+    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/helicone.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeliconeObservabilityAdapter = void 0;
+const memory_1 = require("../memory");
+class HeliconeObservabilityAdapter {
+    constructor(config) {
+        this.name = 'helicone';
+        this.isEnabled = true;
+        this.memory = new memory_1.MemoryObservabilityAdapter();
+        this.config = config || { name: 'helicone' };
+    }
+    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.HeliconeObservabilityAdapter = HeliconeObservabilityAdapter;

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

@@ -0,0 +1,20 @@
+/**
+ * Laminar Observability Adapter
+ */
+import type { ObservabilityAdapter, TraceContext, SpanContext, SpanKind, SpanStatus, AttributionContext, ObservabilityToolConfig } from '../../types';
+export declare class LaminarObservabilityAdapter implements ObservabilityAdapter {
+    readonly name = "laminar";
+    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/laminar.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LaminarObservabilityAdapter = void 0;
+const memory_1 = require("../memory");
+class LaminarObservabilityAdapter {
+    constructor(config) {
+        this.name = 'laminar';
+        this.isEnabled = true;
+        this.memory = new memory_1.MemoryObservabilityAdapter();
+        this.config = config || { name: 'laminar' };
+    }
+    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.LaminarObservabilityAdapter = LaminarObservabilityAdapter;

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

@@ -0,0 +1,28 @@
+/**
+ * Langfuse Observability Adapter
+ * Integrates with Langfuse for production observability
+ */
+import type { ObservabilityAdapter, TraceContext, SpanContext, SpanKind, SpanStatus, AttributionContext, ObservabilityToolConfig } from '../../types';
+/**
+ * Langfuse Observability Adapter
+ * Wraps Langfuse SDK for trace/span management
+ */
+export declare class LangfuseObservabilityAdapter implements ObservabilityAdapter {
+    readonly name = "langfuse";
+    readonly isEnabled = true;
+    private client;
+    private memory;
+    private config;
+    private traces;
+    private spans;
+    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/langfuse.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * Langfuse Observability Adapter
+ * Integrates with Langfuse for production observability
+ */
+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.LangfuseObservabilityAdapter = void 0;
+const memory_1 = require("../memory");
+/**
+ * Langfuse Observability Adapter
+ * Wraps Langfuse SDK for trace/span management
+ */
+class LangfuseObservabilityAdapter {
+    constructor(config) {
+        this.name = 'langfuse';
+        this.isEnabled = true;
+        this.traces = new Map();
+        this.spans = new Map();
+        this.config = config || { name: 'langfuse' };
+        this.memory = new memory_1.MemoryObservabilityAdapter();
+    }
+    async initialize() {
+        try {
+            // Dynamic import for optional dependency
+            const langfuseModule = await Promise.resolve(`${'langfuse'}`).then(s => __importStar(require(s)));
+            const Langfuse = langfuseModule.Langfuse || langfuseModule.default;
+            this.client = new Langfuse({
+                secretKey: this.config.apiKey || process.env.LANGFUSE_SECRET_KEY,
+                publicKey: process.env.LANGFUSE_PUBLIC_KEY,
+                baseUrl: this.config.baseUrl || process.env.LANGFUSE_HOST,
+            });
+        }
+        catch (error) {
+            console.warn('Langfuse SDK not available, falling back to memory adapter');
+            this.client = null;
+        }
+    }
+    async shutdown() {
+        if (this.client) {
+            await this.client.shutdownAsync();
+        }
+    }
+    startTrace(name, metadata, attribution) {
+        const memoryCtx = this.memory.startTrace(name, metadata, attribution);
+        if (this.client) {
+            const trace = this.client.trace({
+                name,
+                metadata,
+                userId: attribution?.userId,
+                sessionId: attribution?.sessionId,
+                tags: attribution?.agentId ? [`agent:${attribution.agentId}`] : undefined,
+            });
+            this.traces.set(memoryCtx.traceId, trace);
+        }
+        return {
+            traceId: memoryCtx.traceId,
+            startSpan: (spanName, kind, parentId) => {
+                return this.startSpan(memoryCtx.traceId, spanName, kind, parentId);
+            },
+            end: (status) => {
+                this.endTrace(memoryCtx.traceId, status);
+            }
+        };
+    }
+    endTrace(traceId, status) {
+        this.memory.endTrace(traceId, status);
+        // Langfuse traces auto-complete
+    }
+    startSpan(traceId, name, kind, parentId) {
+        const memoryCtx = this.memory.startSpan(traceId, name, kind, parentId);
+        if (this.client) {
+            const trace = this.traces.get(traceId);
+            if (trace) {
+                const parentSpan = parentId ? this.spans.get(parentId) : null;
+                const span = kind === 'llm'
+                    ? (parentSpan || trace).generation({ name })
+                    : (parentSpan || trace).span({ name });
+                this.spans.set(memoryCtx.spanId, span);
+            }
+        }
+        const self = this;
+        return {
+            spanId: memoryCtx.spanId,
+            traceId,
+            addEvent(eventName, attributes) {
+                self.addEvent(memoryCtx.spanId, eventName, attributes);
+            },
+            setAttributes(attributes) {
+                const span = self.spans.get(memoryCtx.spanId);
+                if (span) {
+                    span.update({ metadata: attributes });
+                }
+            },
+            setProviderMetadata(metadata) {
+                const span = self.spans.get(memoryCtx.spanId);
+                if (span && span.update) {
+                    span.update({
+                        model: metadata.model,
+                        usage: metadata.totalTokens ? {
+                            promptTokens: metadata.promptTokens,
+                            completionTokens: metadata.completionTokens,
+                            totalTokens: metadata.totalTokens,
+                        } : undefined,
+                        metadata: {
+                            provider: metadata.provider,
+                            latencyMs: metadata.latencyMs,
+                            retryCount: metadata.retryCount,
+                        }
+                    });
+                }
+            },
+            recordError(error) {
+                self.recordError(memoryCtx.spanId, error);
+            },
+            end(status) {
+                self.endSpan(memoryCtx.spanId, status);
+            }
+        };
+    }
+    endSpan(spanId, status, attributes) {
+        this.memory.endSpan(spanId, status, attributes);
+        const span = this.spans.get(spanId);
+        if (span) {
+            span.end({
+                level: status === 'failed' ? 'ERROR' : undefined,
+                metadata: attributes,
+            });
+        }
+    }
+    addEvent(spanId, name, attributes) {
+        this.memory.addEvent(spanId, name, attributes);
+        const span = this.spans.get(spanId);
+        if (span) {
+            span.event({ name, metadata: attributes });
+        }
+    }
+    recordError(spanId, error) {
+        this.memory.recordError(spanId, error);
+        const span = this.spans.get(spanId);
+        if (span) {
+            span.update({
+                level: 'ERROR',
+                statusMessage: error.message,
+            });
+        }
+    }
+    async flush() {
+        if (this.client) {
+            await this.client.flushAsync();
+        }
+    }
+}
+exports.LangfuseObservabilityAdapter = LangfuseObservabilityAdapter;

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

@@ -0,0 +1,21 @@
+/**
+ * LangSmith Observability Adapter
+ */
+import type { ObservabilityAdapter, TraceContext, SpanContext, SpanKind, SpanStatus, AttributionContext, ObservabilityToolConfig } from '../../types';
+export declare class LangSmithObservabilityAdapter implements ObservabilityAdapter {
+    readonly name = "langsmith";
+    readonly isEnabled = true;
+    private client;
+    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/langsmith.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * LangSmith Observability Adapter
+ */
+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.LangSmithObservabilityAdapter = void 0;
+const memory_1 = require("../memory");
+class LangSmithObservabilityAdapter {
+    constructor(config) {
+        this.name = 'langsmith';
+        this.isEnabled = true;
+        this.config = config || { name: 'langsmith' };
+        this.memory = new memory_1.MemoryObservabilityAdapter();
+    }
+    async initialize() {
+        try {
+            // Dynamic import for optional dependency
+            const langsmithModule = await Promise.resolve(`${'langsmith'}`).then(s => __importStar(require(s)));
+            const Client = langsmithModule.Client || langsmithModule.default;
+            this.client = new Client({
+                apiKey: this.config.apiKey || process.env.LANGCHAIN_API_KEY,
+                apiUrl: this.config.baseUrl,
+            });
+        }
+        catch {
+            this.client = null;
+        }
+    }
+    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.LangSmithObservabilityAdapter = LangSmithObservabilityAdapter;

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

@@ -0,0 +1,20 @@
+/**
+ * LangWatch Observability Adapter
+ */
+import type { ObservabilityAdapter, TraceContext, SpanContext, SpanKind, SpanStatus, AttributionContext, ObservabilityToolConfig } from '../../types';
+export declare class LangWatchObservabilityAdapter implements ObservabilityAdapter {
+    readonly name = "langwatch";
+    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/langwatch.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangWatchObservabilityAdapter = void 0;
+const memory_1 = require("../memory");
+class LangWatchObservabilityAdapter {
+    constructor(config) {
+        this.name = 'langwatch';
+        this.isEnabled = true;
+        this.memory = new memory_1.MemoryObservabilityAdapter();
+        this.config = config || { name: 'langwatch' };
+    }
+    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.LangWatchObservabilityAdapter = LangWatchObservabilityAdapter;