langwatch 0.3.0-prerelease.1 → 0.3.0-prerelease.2

package/src/observability/__tests__/integration/multiple-setup-attempts.test.ts

@@ -1,27 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { setupLangWatch } from "../../../client-node";
-import { getLangWatchTracer } from "../../trace";
-
-describe("Multiple setup attempts and error handling", () => {
-  it("should throw error when multiple LangWatch setups are called", async () => {
-    // First setup
-    await setupLangWatch({
-      apiKey: "test-key-1",
-      endpoint: "http://localhost:9999",
-      skipOpenTelemetrySetup: false,
-    });
-
-    // Second setup should throw an error
-    await expect(setupLangWatch({
-      apiKey: "test-key-2",
-      endpoint: "http://localhost:9999",
-      skipOpenTelemetrySetup: false,
-    })).rejects.toThrow("LangWatch setup has already been called");
-
-    // Test that LangWatch still works
-    const tracer = getLangWatchTracer("multiple-setup-test");
-    await tracer.withActiveSpan("test span", async () => {
-      expect(true).toBe(true);
-    });
-  });
-});

package/src/observability/__tests__/integration/otel-ordering.test.ts

@@ -1,27 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { registerOTel } from '@vercel/otel'
-import { getLangWatchTracer } from "../../trace";
-import { setupLangWatch } from "../../../client-node";
-import { isOtelInitialized } from "../../../client-shared";
-
-describe("SDK compatibility with Vercel AI OpenTelemetry", () => {
-  it("should work when Vercel AI is set up first, then LangWatch", async () => {
-    // Setup Vercel AI first
-    registerOTel({ serviceName: 'vercel-first' });
-
-    expect(isOtelInitialized()).toBe(true);
-
-    // Then setup LangWatch
-    await setupLangWatch({
-      apiKey: "test-key",
-      endpoint: "http://localhost:9999",
-      skipOpenTelemetrySetup: false,
-    });
-
-    // Test that LangWatch still works
-    const tracer = getLangWatchTracer("vercel-first-test");
-    await tracer.withActiveSpan("test span", async () => {
-      expect(true).toBe(true);
-    });
-  });
-});

package/src/observability/__tests__/integration/vercel-configurations.test.ts

@@ -1,20 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { registerOTel } from '@vercel/otel';
-import { setupLangWatch } from "../../../client-node";
-import { getLangWatchTracer } from "../../trace";
-
-describe("Different Vercel AI configurations", () => {
-  it("should work with a specific Vercel AI configuration", async () => {
-    registerOTel({ serviceName: 'config-1', version: '1.0.0' });
-    await setupLangWatch({
-      apiKey: "test-key",
-      endpoint: "http://localhost:9999",
-      skipOpenTelemetrySetup: false,
-    });
-
-    const tracer = getLangWatchTracer("config-test");
-    await tracer.withActiveSpan("test span", async () => {
-      expect(true).toBe(true);
-    });
-  });
-});

package/src/observability/__tests__/integration/vercel-first-then-langwatch.test.ts

@@ -1,27 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { registerOTel } from '@vercel/otel';
-import { setupLangWatch } from "../../../client-node";
-import { getLangWatchTracer } from "../../trace";
-import { isOtelInitialized } from "../../../client-shared";
-
-describe("Vercel AI setup first, then LangWatch", () => {
-  it("should work when Vercel AI is set up first, then LangWatch", async () => {
-    // Setup Vercel AI first
-    registerOTel({ serviceName: 'vercel-first' });
-
-    expect(isOtelInitialized()).toBe(true);
-
-    // Then setup LangWatch
-    await setupLangWatch({
-      apiKey: "test-key",
-      endpoint: "http://localhost:9999",
-      skipOpenTelemetrySetup: false,
-    });
-
-    // Test that LangWatch still works
-    const tracer = getLangWatchTracer("vercel-first-test");
-    await tracer.withActiveSpan("test span", async () => {
-      expect(true).toBe(true);
-    });
-  });
-});

package/src/observability/__tests__/span.test.ts

@@ -1,214 +0,0 @@
-vi.mock('../../evaluation/record-evaluation', () => ({
-  recordEvaluation: vi.fn(),
-}));
-
-import { createLangWatchSpan } from '../span';
-import { recordEvaluation } from '../../evaluation/record-evaluation';
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-const makeMockSpan = () => {
-  const calls: any = { addEvent: [], setAttribute: [], end: 0, setAttributes: [], recordException: [], setStatus: [], updateName: [] };
-  return {
-    addEvent: vi.fn((...args) => { calls.addEvent.push(args); }),
-    setAttribute: vi.fn((...args) => { calls.setAttribute.push(args); }),
-    setAttributes: vi.fn((...args) => { calls.setAttributes.push(args); }),
-    end: vi.fn(() => { calls.end++; }),
-    recordException: vi.fn((...args) => { calls.recordException.push(args); }),
-    setStatus: vi.fn((...args) => { calls.setStatus.push(args); }),
-    updateName: vi.fn((...args) => { calls.updateName.push(args); }),
-    calls,
-  };
-};
-
-describe('createLangWatchSpan', () => {
-  let span: ReturnType<typeof makeMockSpan>;
-  let lwSpan: ReturnType<typeof createLangWatchSpan>;
-  let intSemconv: any;
-  let semconv: any;
-
-  beforeEach(async () => {
-    span = makeMockSpan();
-    lwSpan = createLangWatchSpan(span as any);
-    intSemconv = await import('../semconv/index.js');
-    semconv = await import('@opentelemetry/semantic-conventions/incubating');
-  });
-
-  it('setType sets the span type attribute', () => {
-    lwSpan.setType('llm');
-    expect(span.setAttribute).toHaveBeenCalledWith(intSemconv.ATTR_LANGWATCH_SPAN_TYPE, 'llm');
-  });
-
-  it('setRequestModel sets the request model attribute', () => {
-    lwSpan.setRequestModel('gpt-4');
-    expect(span.setAttribute).toHaveBeenCalledWith(semconv.ATTR_GEN_AI_REQUEST_MODEL, 'gpt-4');
-  });
-
-  it('setResponseModel sets the response model attribute', () => {
-    lwSpan.setResponseModel('gpt-4');
-    expect(span.setAttribute).toHaveBeenCalledWith(semconv.ATTR_GEN_AI_RESPONSE_MODEL, 'gpt-4');
-  });
-
-  it('setRAGContexts sets the rag contexts attribute as JSON', () => {
-    const ctxs = [{ document_id: 'd', chunk_id: 'c', content: 'x' }];
-    lwSpan.setRAGContexts(ctxs);
-    expect(span.setAttribute).toHaveBeenCalledWith(intSemconv.ATTR_LANGWATCH_RAG_CONTEXTS, JSON.stringify({ type: 'json', value: ctxs }));
-  });
-
-  it('setRAGContext sets a single rag context as JSON array', () => {
-    const ctx = { document_id: 'd', chunk_id: 'c', content: 'x' };
-    lwSpan.setRAGContext(ctx);
-    expect(span.setAttribute).toHaveBeenCalledWith(intSemconv.ATTR_LANGWATCH_RAG_CONTEXTS, JSON.stringify({ type: 'json', value: [ctx] }));
-  });
-
-  it('setMetrics sets the metrics attribute as JSON', () => {
-    const metrics = { promptTokens: 1, completionTokens: 2, cost: 3 };
-    lwSpan.setMetrics(metrics);
-    expect(span.setAttribute).toHaveBeenCalledWith(intSemconv.ATTR_LANGWATCH_METRICS, JSON.stringify({ type: 'json', value: metrics }));
-  });
-
-  it('setInput sets the input attribute as JSON', () => {
-    lwSpan.setInput({ foo: 'bar' });
-    expect(span.setAttribute).toHaveBeenCalledWith(intSemconv.ATTR_LANGWATCH_INPUT, JSON.stringify({ type: 'json', value: { foo: 'bar' } }));
-  });
-
-  it('setInputString sets the input attribute as text', () => {
-    lwSpan.setInputString('prompt');
-    expect(span.setAttribute).toHaveBeenCalledWith(intSemconv.ATTR_LANGWATCH_INPUT, JSON.stringify({ type: 'text', value: 'prompt' }));
-  });
-
-  it('setOutput sets the output attribute as JSON', () => {
-    lwSpan.setOutput({ foo: 'bar' });
-    expect(span.setAttribute).toHaveBeenCalledWith(intSemconv.ATTR_LANGWATCH_OUTPUT, JSON.stringify({ type: 'json', value: { foo: 'bar' } }));
-  });
-
-  it('setOutputString sets the output attribute as text', () => {
-    lwSpan.setOutputString('completion');
-    expect(span.setAttribute).toHaveBeenCalledWith(intSemconv.ATTR_LANGWATCH_OUTPUT, JSON.stringify({ type: 'text', value: 'completion' }));
-  });
-
-  it('setOutputEvaluation sets the output attribute as guardrail/evaluation result', () => {
-    lwSpan.setOutputEvaluation(true, { status: 'processed', passed: true });
-    expect(span.setAttribute).toHaveBeenCalledWith(intSemconv.ATTR_LANGWATCH_OUTPUT, JSON.stringify({ type: 'guardrail_result', value: { status: 'processed', passed: true } }));
-    lwSpan.setOutputEvaluation(false, { status: 'processed', passed: false });
-    expect(span.setAttribute).toHaveBeenCalledWith(intSemconv.ATTR_LANGWATCH_OUTPUT, JSON.stringify({ type: 'evaluation_result', value: { status: 'processed', passed: false } }));
-  });
-
-  it('addGenAISystemMessageEvent sets default role and adds event', () => {
-    lwSpan.addGenAISystemMessageEvent({ content: 'hi' });
-    expect(span.addEvent).toHaveBeenCalledWith(intSemconv.LOG_EVNT_GEN_AI_SYSTEM_MESSAGE, expect.objectContaining({
-      [semconv.ATTR_GEN_AI_SYSTEM]: undefined,
-      [intSemconv.ATTR_LANGWATCH_GEN_AI_LOG_EVENT_BODY]: JSON.stringify({ content: 'hi', role: 'system' }),
-      [intSemconv.ATTR_LANGWATCH_GEN_AI_LOG_EVENT_IMPOSTER]: true,
-    }));
-  });
-
-  it('addGenAIUserMessageEvent sets default role and adds event', () => {
-    lwSpan.addGenAIUserMessageEvent({ content: 'hi' });
-    expect(span.addEvent).toHaveBeenCalledWith(intSemconv.LOG_EVNT_GEN_AI_USER_MESSAGE, expect.objectContaining({
-      [semconv.ATTR_GEN_AI_SYSTEM]: undefined,
-      [intSemconv.ATTR_LANGWATCH_GEN_AI_LOG_EVENT_BODY]: JSON.stringify({ content: 'hi', role: 'user' }),
-      [intSemconv.ATTR_LANGWATCH_GEN_AI_LOG_EVENT_IMPOSTER]: true,
-    }));
-  });
-
-  it('addGenAIAssistantMessageEvent sets default role and adds event', () => {
-    lwSpan.addGenAIAssistantMessageEvent({ content: 'hi' });
-    expect(span.addEvent).toHaveBeenCalledWith(intSemconv.LOG_EVNT_GEN_AI_ASSISTANT_MESSAGE, expect.objectContaining({
-      [semconv.ATTR_GEN_AI_SYSTEM]: undefined,
-      [intSemconv.ATTR_LANGWATCH_GEN_AI_LOG_EVENT_BODY]: JSON.stringify({ content: 'hi', role: 'assistant' }),
-      [intSemconv.ATTR_LANGWATCH_GEN_AI_LOG_EVENT_IMPOSTER]: true,
-    }));
-  });
-
-  it('addGenAIToolMessageEvent sets default role and adds event', () => {
-    lwSpan.addGenAIToolMessageEvent({ content: 'hi', id: 't1' });
-    expect(span.addEvent).toHaveBeenCalledWith(intSemconv.LOG_EVNT_GEN_AI_TOOL_MESSAGE, expect.objectContaining({
-      [semconv.ATTR_GEN_AI_SYSTEM]: undefined,
-      [intSemconv.ATTR_LANGWATCH_GEN_AI_LOG_EVENT_BODY]: JSON.stringify({ content: 'hi', id: 't1', role: 'tool' }),
-      [intSemconv.ATTR_LANGWATCH_GEN_AI_LOG_EVENT_IMPOSTER]: true,
-    }));
-  });
-
-  it('addGenAIChoiceEvent sets default message.role and adds event', () => {
-    lwSpan.addGenAIChoiceEvent({ finish_reason: 'stop', index: 0, message: { content: 'x' } });
-    expect(span.addEvent).toHaveBeenCalledWith(intSemconv.LOG_EVNT_GEN_AI_CHOICE, expect.objectContaining({
-      [semconv.ATTR_GEN_AI_SYSTEM]: undefined,
-      [intSemconv.ATTR_LANGWATCH_GEN_AI_LOG_EVENT_BODY]: JSON.stringify({ finish_reason: 'stop', index: 0, message: { content: 'x', role: 'assistant' } }),
-      [intSemconv.ATTR_LANGWATCH_GEN_AI_LOG_EVENT_IMPOSTER]: true,
-    }));
-  });
-
-  it('recordEvaluation calls recordEvaluation util', () => {
-    const details = { name: 'eval', status: 'processed' as const };
-    const attributes = { foo: 'bar' };
-    const span = makeMockSpan();
-    const lwSpan2 = createLangWatchSpan(span as any);
-    lwSpan2.recordEvaluation(details, attributes);
-    expect(recordEvaluation).toHaveBeenCalledWith(details, attributes);
-  });
-
-  it('supports fluent API chaining', () => {
-    // Test that methods can be chained and each returns the LangWatchSpan instance
-    const result = lwSpan
-      .setType('llm')
-      .setRequestModel('gpt-4')
-      .setInputString('Hello')
-      .addGenAIUserMessageEvent({ content: 'Hello' })
-      .addGenAIAssistantMessageEvent({ content: 'Hi!' })
-      .setOutputString('Hi!')
-      .recordEvaluation({ name: 'test', status: 'processed' });
-
-    // Verify that the result is the same LangWatchSpan instance
-    expect(result).toBe(lwSpan);
-
-    // Verify that all the expected methods were called
-    expect(span.setAttribute).toHaveBeenCalledWith(intSemconv.ATTR_LANGWATCH_SPAN_TYPE, 'llm');
-    expect(span.setAttribute).toHaveBeenCalledWith(semconv.ATTR_GEN_AI_REQUEST_MODEL, 'gpt-4');
-    expect(span.setAttribute).toHaveBeenCalledWith(intSemconv.ATTR_LANGWATCH_INPUT, JSON.stringify({ type: 'text', value: 'Hello' }));
-    expect(span.setAttribute).toHaveBeenCalledWith(intSemconv.ATTR_LANGWATCH_OUTPUT, JSON.stringify({ type: 'text', value: 'Hi!' }));
-    expect(span.addEvent).toHaveBeenCalledWith(intSemconv.LOG_EVNT_GEN_AI_USER_MESSAGE, expect.any(Object));
-    expect(span.addEvent).toHaveBeenCalledWith(intSemconv.LOG_EVNT_GEN_AI_ASSISTANT_MESSAGE, expect.any(Object));
-    expect(recordEvaluation).toHaveBeenCalledWith({ name: 'test', status: 'processed' }, undefined);
-  });
-
-  it('maintains fluent API when mixing LangWatch and original span methods', () => {
-    // Test that we can chain LangWatch methods with original span methods
-    const result = lwSpan
-      .setType('llm')
-      .setAttribute('custom.attr', 'value') // Original span method
-      .setInputString('Hello')
-      .setAttributes({ 'another.attr': 'value' }) // Original span method
-      .setOutputString('Hi!');
-
-    // Verify that the result is the same LangWatchSpan instance
-    expect(result).toBe(lwSpan);
-
-    // Verify that both LangWatch and original span methods were called
-    expect(span.setAttribute).toHaveBeenCalledWith(intSemconv.ATTR_LANGWATCH_SPAN_TYPE, 'llm');
-    expect(span.setAttribute).toHaveBeenCalledWith('custom.attr', 'value');
-    expect(span.setAttributes).toHaveBeenCalledWith({ 'another.attr': 'value' });
-    expect(span.setAttribute).toHaveBeenCalledWith(intSemconv.ATTR_LANGWATCH_INPUT, JSON.stringify({ type: 'text', value: 'Hello' }));
-    expect(span.setAttribute).toHaveBeenCalledWith(intSemconv.ATTR_LANGWATCH_OUTPUT, JSON.stringify({ type: 'text', value: 'Hi!' }));
-  });
-
-  it('forwards original span methods correctly', () => {
-    // Test that original span methods work and return the LangWatchSpan for chaining
-    const result = lwSpan
-      .setAttribute('test', 'value')
-      .setAttributes({ 'test2': 'value2' })
-      .addEvent('test-event', { 'event-attr': 'value' })
-      .setStatus({ code: 0 })
-      .updateName('new-name');
-
-    // Verify that the result is the same LangWatchSpan instance
-    expect(result).toBe(lwSpan);
-
-    // Verify that all the original span methods were called
-    expect(span.setAttribute).toHaveBeenCalledWith('test', 'value');
-    expect(span.setAttributes).toHaveBeenCalledWith({ 'test2': 'value2' });
-    expect(span.addEvent).toHaveBeenCalledWith('test-event', { 'event-attr': 'value' });
-    expect(span.setStatus).toHaveBeenCalledWith({ code: 0 });
-    expect(span.updateName).toHaveBeenCalledWith('new-name');
-  });
-});

package/src/observability/__tests__/trace.test.ts

@@ -1,180 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { getLangWatchTracer } from '../trace';
-import type { Tracer, Span, SpanOptions, Context } from '@opentelemetry/api';
-
-// Mock createLangWatchSpan to just tag the span for test visibility
-vi.mock('../span', () => ({
-  createLangWatchSpan: (span: Span) => ({
-    __isLangWatch: true,
-    ...span,
-    end: vi.fn(),
-    setStatus: vi.fn(),
-    recordException: vi.fn(),
-  }),
-}));
-
-// Helper to create a mock Tracer
-function makeMockTracer() {
-  return {
-    startSpan: vi.fn((name, options, context) => ({ name, options, context })),
-    startActiveSpan: vi.fn((...args: any[]) => {
-      // OpenTelemetry's startActiveSpan calls the callback with the span
-      const fn = args[args.length - 1];
-      const span = { name: args[0], options: args[1], context: args[2] };
-      return fn(span);
-    }),
-    someOtherMethod: vi.fn(() => 'other'),
-  } as unknown as Tracer;
-}
-
-describe('getTracer', () => {
-  const origGetTracer = vi.hoisted(() => vi.fn());
-  let otelTrace: { getTracer: typeof origGetTracer };
-
-  beforeEach(() => {
-    otelTrace = require('@opentelemetry/api').trace;
-    otelTrace.getTracer = vi.fn(() => makeMockTracer());
-  });
-
-  it('returns a proxy with startSpan wrapping the span', () => {
-    const tracer = getLangWatchTracer('test');
-    const span = tracer.startSpan('my-span', { foo: 'bar' } as SpanOptions, {} as Context);
-    expect(span).toMatchObject({ __isLangWatch: true, name: 'my-span', options: { foo: 'bar' } });
-  });
-
-  it('returns a proxy with startActiveSpan wrapping the span in the callback', () => {
-    const tracer = getLangWatchTracer('test');
-    const result = tracer.startActiveSpan('active-span', (span: any) => {
-      expect(span).toMatchObject({ __isLangWatch: true, name: 'active-span' });
-      return 'done';
-    });
-    expect(result).toBe('done');
-  });
-
-  it('supports startActiveSpan with options and context overloads', () => {
-    const tracer = getLangWatchTracer('test');
-    let called = 0;
-    tracer.startActiveSpan('span1', { foo: 1 } as SpanOptions, (span: any) => {
-      expect(span).toMatchObject({ __isLangWatch: true, name: 'span1', options: { foo: 1 } });
-      called++;
-    });
-    tracer.startActiveSpan('span2', { foo: 2 } as SpanOptions, {} as Context, (span: any) => {
-      expect(span).toMatchObject({ __isLangWatch: true, name: 'span2', options: { foo: 2 }, context: {} });
-      called++;
-    });
-    expect(called).toBe(2);
-  });
-
-  it('supports startActiveSpan with a callback that returns a Promise', async () => {
-    const tracer = getLangWatchTracer('test');
-    const result = await tracer.startActiveSpan('promise-span', async (span: any) => {
-      expect(span).toMatchObject({ __isLangWatch: true, name: 'promise-span' });
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      return 'async-done';
-    });
-    expect(result).toBe('async-done');
-  });
-
-  it('supports startActiveSpan with a callback that returns a thenable (Promise-like)', async () => {
-    const tracer = getLangWatchTracer('test');
-    const thenable = {
-      then: (resolve: (v: string) => void) => setTimeout(() => resolve('thenable-done'), 10),
-    };
-    const result = await tracer.startActiveSpan('thenable-span', (_span: any) => thenable);
-    expect(result).toBe('thenable-done');
-  });
-
-  it('forwards unknown methods to the underlying tracer', () => {
-    const tracer = getLangWatchTracer('test');
-    // @ts-expect-error
-    expect(tracer.someOtherMethod()).toBe('other');
-  });
-
-  it('throws if startActiveSpan is called without a function', () => {
-    const tracer = getLangWatchTracer('test');
-    // @ts-expect-error
-    expect(() => tracer.startActiveSpan('no-fn')).toThrow(/function as the last argument/);
-  });
-});
-
-describe('getTracer (withActiveSpan)', () => {
-  let tracer: ReturnType<typeof getLangWatchTracer>;
-  beforeEach(() => {
-    tracer = getLangWatchTracer('test');
-  });
-
-  it('returns a proxy with withActiveSpan wrapping the span', async () => {
-    const result = await tracer.withActiveSpan('my-span', (span: any) => {
-      expect(span).toMatchObject({ __isLangWatch: true, name: 'my-span' });
-      return 'done';
-    });
-    expect(result).toBe('done');
-  });
-
-  it('supports withActiveSpan with options and context overloads', async () => {
-    let called = 0;
-    await tracer.withActiveSpan('span1', { foo: 1 } as SpanOptions, (span: any) => {
-      expect(span).toMatchObject({ __isLangWatch: true, name: 'span1', options: { foo: 1 } });
-      called++;
-    });
-    await tracer.withActiveSpan('span2', { foo: 2 } as SpanOptions, {} as Context, (span: any) => {
-      expect(span).toMatchObject({ __isLangWatch: true, name: 'span2', options: { foo: 2 }, context: {} });
-      called++;
-    });
-    expect(called).toBe(2);
-  });
-
-  it('supports withActiveSpan with a callback that returns a Promise', async () => {
-    const result = await tracer.withActiveSpan('promise-span', async (span: any) => {
-      expect(span).toMatchObject({ __isLangWatch: true, name: 'promise-span' });
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      return 'async-done';
-    });
-    expect(result).toBe('async-done');
-  });
-
-  it('supports withActiveSpan with a callback that returns a thenable (Promise-like)', async () => {
-    const thenable = {
-      then: (resolve: (v: string) => void) => setTimeout(() => resolve('thenable-done'), 10),
-    };
-    const result = await tracer.withActiveSpan('thenable-span', (_span: any) => thenable as any);
-    expect(result).toBe('thenable-done');
-  });
-
-  it('calls setStatus and recordException on error', async () => {
-    const error = new Error('fail!');
-    let spanRef: any = null;
-    const resultPromise = tracer.withActiveSpan('err-span', (span: any) => {
-      span.setStatus = vi.fn();
-      span.recordException = vi.fn();
-      spanRef = span;
-      throw error;
-    });
-    await expect(resultPromise).rejects.toThrow('fail!');
-    expect(spanRef.setStatus).toHaveBeenCalledWith({ code: expect.any(Number), message: 'fail!' });
-    expect(spanRef.recordException).toHaveBeenCalledWith(error);
-  });
-
-  it('throws if withActiveSpan is called without a function', async () => {
-    // @ts-expect-error
-    await expect(tracer.withActiveSpan('no-fn')).rejects.toThrow(/function as the last argument/);
-  });
-
-  it('ensures nested withActiveSpan calls propagate context (parent-child)', async () => {
-    const tracer = getLangWatchTracer('test');
-    let parentSpanRef: any = null;
-    let childSpanRef: any = null;
-    await tracer.withActiveSpan('parent-span', (parentSpan: any) => {
-      parentSpanRef = parentSpan;
-      return tracer.withActiveSpan('child-span', (childSpan: any) => {
-        childSpanRef = childSpan;
-        return 'nested';
-      });
-    });
-    // In the mock, context is just passed through, so we can check the parent/child linkage
-    expect(childSpanRef.context).toBe(parentSpanRef.context);
-    // Removed assertion on childSpanRef.options, as the mock does not reflect real OTel behavior
-    expect(childSpanRef.name).toBe('child-span');
-    expect(parentSpanRef.name).toBe('parent-span');
-  });
-});

package/src/observability/exporters/index.ts

@@ -1 +0,0 @@
-export * from "./langwatch-exporter";

package/src/observability/index.ts

@@ -1,4 +0,0 @@
-export * from "./span";
-export * from "./trace";
-export * from "./processors";
-export * as semconv from "./semconv";

package/src/observability/instrumentation/langchain/__tests__/integration/langchain-chatbot.test.ts

@@ -1,112 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { ChatOpenAI } from "@langchain/openai";
-import { LangWatchCallbackHandler } from "../../../langchain";
-import { setupLangWatch } from "../../../../../client-node";
-import { DynamicTool } from "@langchain/core/tools";
-import { AgentExecutor, createToolCallingAgent, initializeAgentExecutorWithOptions } from "langchain/agents";
-import { getLangWatchTracer } from "../../../../trace";
-import { ChatPromptTemplate } from "@langchain/core/prompts";
-import { beforeEach } from "node:test";
-
-beforeEach(async () => {
-  await setupLangWatch();
-});
-
-describe("langchain chatbots", () => {
-  it("it should be able to do a simple question/response", async () => {
-    const tracer = getLangWatchTracer("langchain-chatbot.test");
-    await tracer.withActiveSpan("simple question/response", { root: true }, async () => {
-      const llm = new ChatOpenAI({
-        model: "gpt-4o-mini",
-        temperature: 0,
-      });
-
-      const result = await llm.invoke([
-        { role: "user", content: "Hi im Bob" },
-      ], { callbacks: [new LangWatchCallbackHandler()] });
-      expect(result.content).toContain("Bob");
-    });
-  });
-
-  it("it should be able to handle tool calls", async () => {
-    const tools = [
-      new DynamicTool({
-        name: "get_current_time",
-        description: "Returns the current time in ISO-8601 format.",
-        func: async () => new Date().toISOString(),
-      }),
-
-      new DynamicTool({
-        name: "multiply",
-        description: 'Multiply two numbers, provide input like "a,b".',
-        func: async (input: string) => {
-          const [a, b] = input.split(",").map(Number);
-
-          if (a === void 0 || b === void 0) {
-            throw new Error("Invalid input");
-          }
-
-          return String(a * b);
-        },
-      }),
-    ];
-
-    const tracer = getLangWatchTracer("langchain-chatbot.test");
-    await tracer.withActiveSpan(
-      "langchain tool call",
-      { root: true },
-      async () => {
-        const llm = new ChatOpenAI({
-          model: "gpt-4.1-mini",
-          temperature: 0,
-        });
-
-        const prompt = ChatPromptTemplate.fromMessages([
-          ["system", "You are a helpful assistant"],
-          ["placeholder", "{chat_history}"],
-          ["human", "{input}"],
-          ["placeholder", "{agent_scratchpad}"],
-        ]);
-
-        const agent = createToolCallingAgent({
-          llm,
-          tools,
-          prompt,
-        });
-        const agentExecutor = new AgentExecutor({
-          agent,
-          tools,
-        });
-
-        const tracingCallback = new LangWatchCallbackHandler();
-        const result = await agentExecutor.invoke({ input: "What time is it and what is 12 times 8?" }, { callbacks: [tracingCallback] });
-        expect(result.output).toContain("96");
-      },
-    );
-  });
-
-  it("should understand context grouping", async () => {
-    const tracer = getLangWatchTracer("langchain-chatbot.test");
-    await tracer.withActiveSpan(
-      "context grouping",
-      { root: true },
-      async () => {
-        const llm = new ChatOpenAI({
-          model: "gpt-4o-mini",
-          temperature: 0,
-        });
-
-        const tracingCallback = new LangWatchCallbackHandler();
-        const result1 = await llm.invoke([
-          { role: "user", content: "Hi im Alice" },
-        ], { callbacks: [tracingCallback] });
-        const result2 = await llm.invoke([
-          { role: "user", content: "Hi im Bob" },
-        ], { callbacks: [tracingCallback] });
-
-        expect(result1.content).toContain("Alice");
-        expect(result2.content).toContain("Bob");
-      },
-    );
-  });
-});