langwatch 0.1.7 → 0.3.0-prerelease.1

package/src/internal/api/client.ts

@@ -0,0 +1,30 @@
+import openApiCreateClient from "openapi-fetch";
+import type { paths } from "../generated/openapi/api-client";
+import { z } from "zod";
+import { getApiKey, getEndpoint } from "../../client";
+
+// Define the client type explicitly to avoid naming issues
+export type LangwatchApiClient = ReturnType<typeof openApiCreateClient<paths>>;
+
+const configSchema = z.object({
+  apiKey: z.string().min(1, "API key is required"),
+  endpoint: z.string().url("Endpoint must be a valid URL"),
+});
+
+export function createLangWatchApiClient(apiKey?: string | undefined, endpoint?: string | undefined ): LangwatchApiClient {
+  // This will error if the config is invalid
+  const config = configSchema.parse({
+    apiKey: apiKey ?? getApiKey(),
+    endpoint: endpoint ?? getEndpoint(),
+  });
+
+  return openApiCreateClient<paths>({
+    baseUrl: config.endpoint,
+    headers: {
+      "X-Auth-Token": config.apiKey,
+      "Content-Type": "application/json",
+    },
+  });
+}
+
+

package/src/internal/api/errors.ts

@@ -0,0 +1,32 @@
+export class LangWatchApiError extends Error {
+  public readonly httpStatus: number;
+  public readonly httpStatusText: string;
+  public apiError: string | undefined;
+  public body: unknown;
+
+  constructor(message: string, response: Response) {
+    super(message);
+    this.httpStatus = response.status;
+    this.httpStatusText = response.statusText;
+  }
+
+  async safeParseBody(response: Response): Promise<void> {
+    try {
+      if (response.headers.get("Content-Type")?.includes("application/json")) {
+        const json = await response.json();
+
+        this.body = json;
+
+        if (json.error && typeof json.error === "string") {
+          this.apiError = json.error;
+        }
+
+        return;
+      }
+
+      this.body = await response.text();
+    } catch {
+      this.body = null;
+    }
+  }
+}

package/src/observability/__tests__/integration/base.test.ts

@@ -0,0 +1,74 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { setupLangWatch } from "../../../client-node";
+import { getLangWatchTracer } from "../../trace";
+
+const tracerName = "basic-observability.test";
+
+describe("basic observability tests around tracing", () => {
+  beforeAll(async () => {
+    await setupLangWatch();
+  });
+
+  it("traces should be sent", async () => {
+    const tracer = getLangWatchTracer(tracerName);
+    await tracer.withActiveSpan(
+      "basic trace",
+      async () => { },
+    );
+  });
+
+  it("traces should be sent with complex arguments", async () => {
+    const tracer = getLangWatchTracer(tracerName);
+    await tracer.withActiveSpan(
+      "complex argument trace",
+      { attributes: { foo: "bar" }, root: true },
+      async (span) => {
+        span.setAttributes({
+          bar: "bas",
+        });
+        span.addEvent("test event", {
+          foo: "bar",
+        });
+      },
+    );
+  });
+
+  it("traces exceptions", async () => {
+    const tracer = getLangWatchTracer(tracerName);
+
+    await expect(
+      tracer.withActiveSpan(
+        "trace exception",
+        async () => {
+          throw new Error("this is meant to error");
+        },
+      )
+    ).rejects.toThrow("this is meant to error");
+  });
+
+  it("traces handle complex nesting", async () => {
+    const tracer = getLangWatchTracer(tracerName);
+    await tracer.withActiveSpan(
+      "complex nesting trace",
+      async () => {
+        await tracer.withActiveSpan(
+          "nested trace alpha",
+          async () => { },
+        );
+        await tracer.withActiveSpan(
+          "nested trace beta",
+          async () => { },
+        );
+        await tracer.withActiveSpan(
+          "nested trace gamma",
+          async () => {
+            await tracer.withActiveSpan(
+              "nested trace gamma child",
+              async () => { },
+            );
+          },
+        );
+      },
+    );
+  });
+});

package/src/observability/__tests__/integration/browser-setup-ordering.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect, vi } from "vitest";
+import { setupLangWatch as setupBrowser } from "../../../client-browser";
+import { getLangWatchTracer } from "../../trace";
+
+// Mock window object for Node.js test environment
+const mockWindow = {
+  addEventListener: vi.fn(),
+  removeEventListener: vi.fn(),
+};
+global.window = mockWindow as any;
+
+describe("Browser SDK setup ordering", () => {
+  it("should work when LangWatch browser setup is called multiple times", async () => {
+    // First setup
+    await setupBrowser({
+      apiKey: "test-key-1",
+      endpoint: "http://localhost:9999",
+      skipOpenTelemetrySetup: false,
+    });
+
+    // Second setup should work (browser doesn't have the same restriction as node)
+    await setupBrowser({
+      apiKey: "test-key-2",
+      endpoint: "http://localhost:9999",
+      skipOpenTelemetrySetup: false,
+    });
+
+    // Test that LangWatch still works
+    const tracer = getLangWatchTracer("browser-multiple-test");
+    await tracer.withActiveSpan("test span", async () => {
+      expect(true).toBe(true);
+    });
+  });
+
+  it("should work when LangWatch is set up with skipOpenTelemetrySetup=true", async () => {
+    // Setup LangWatch with automatic setup disabled
+    await setupBrowser({
+      apiKey: "test-key",
+      endpoint: "http://localhost:9999",
+      skipOpenTelemetrySetup: true,
+    });
+
+    // Test that LangWatch still works
+    const tracer = getLangWatchTracer("browser-disabled-test");
+    await tracer.withActiveSpan("test span", async () => {
+      expect(true).toBe(true);
+    });
+  });
+
+  it("should handle window event listeners correctly", async () => {
+    await setupBrowser({
+      apiKey: "test-key",
+      endpoint: "http://localhost:9999",
+      skipOpenTelemetrySetup: false,
+    });
+
+    // Check that window event listeners were added
+    expect(mockWindow.addEventListener).toHaveBeenCalled();
+  });
+});

package/src/observability/__tests__/integration/complex-nested-spans.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect } from "vitest";
+import { registerOTel } from '@vercel/otel';
+import { setupLangWatch } from "../../../client-node";
+import { getLangWatchTracer } from "../../trace";
+
+describe("Complex nested spans with Vercel AI", () => {
+  it("should work with complex nested spans when Vercel AI is set up first", async () => {
+    registerOTel({ serviceName: 'complex-test' });
+    await setupLangWatch({
+      apiKey: "test-key",
+      endpoint: "http://localhost:9999",
+      skipOpenTelemetrySetup: false,
+    });
+
+    const tracer = getLangWatchTracer("complex-otel-test");
+
+    await tracer.withActiveSpan("root span", async () => {
+      await tracer.withActiveSpan("child span 1", async () => {
+        await tracer.withActiveSpan("grandchild span", async () => {
+          expect(true).toBe(true);
+        });
+      });
+
+      await tracer.withActiveSpan("child span 2", async () => {
+        expect(true).toBe(true);
+      });
+    });
+  });
+});

package/src/observability/__tests__/integration/error-handling.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from "vitest";
+import { registerOTel } from '@vercel/otel';
+import { setupLangWatch } from "../../../client-node";
+import { getLangWatchTracer } from "../../trace";
+
+describe("Error handling with Vercel AI", () => {
+  it("should handle errors gracefully when both are set up", async () => {
+    registerOTel({ serviceName: 'error-test' });
+    await setupLangWatch({
+      apiKey: "test-key",
+      endpoint: "http://localhost:9999",
+      skipOpenTelemetrySetup: false,
+    });
+
+    const tracer = getLangWatchTracer("error-otel-test");
+
+    // Test that exceptions in spans are properly handled
+    await expect(
+      tracer.withActiveSpan("error span", async () => {
+        throw new Error("Test error");
+      })
+    ).rejects.toThrow("Test error");
+  });
+});

package/src/observability/__tests__/integration/langwatch-disabled-otel.test.ts

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

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

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

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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,214 @@
+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');
+  });
+});