@mastra/langfuse 0.0.5-alpha.0 → 0.0.5-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @mastra/langfuse
 
+## 0.0.5-alpha.1
+
+### Patch Changes
+
+- [#7343](https://github.com/mastra-ai/mastra/pull/7343) [`de3cbc6`](https://github.com/mastra-ai/mastra/commit/de3cbc61079211431bd30487982ea3653517278e) Thanks [@LekoArts](https://github.com/LekoArts)! - Update the `package.json` file to include additional fields like `repository`, `homepage` or `files`.
+
+- Updated dependencies [[`85ef90b`](https://github.com/mastra-ai/mastra/commit/85ef90bb2cd4ae4df855c7ac175f7d392c55c1bf), [`de3cbc6`](https://github.com/mastra-ai/mastra/commit/de3cbc61079211431bd30487982ea3653517278e)]:
+  - @mastra/core@0.15.3-alpha.5
+
 ## 0.0.5-alpha.0
 
 ### Patch Changes

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@mastra/langfuse",
-  "version": "0.0.5-alpha.0",
+  "version": "0.0.5-alpha.1",
   "description": "Langfuse observability provider for Mastra - includes AI tracing and future observability features",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
   "exports": {
     ".": {
       "import": {
@@ -29,13 +33,22 @@
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
+    "@mastra/core": "0.15.3-alpha.5",
     "@internal/lint": "0.0.34",
-    "@internal/types-builder": "0.0.9",
-    "@mastra/core": "0.15.3-alpha.4"
+    "@internal/types-builder": "0.0.9"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.15.3-0 <0.16.0-0"
   },
+  "homepage": "https://mastra.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mastra-ai/mastra.git",
+    "directory": "observability/langfuse"
+  },
+  "bugs": {
+    "url": "https://github.com/mastra-ai/mastra/issues"
+  },
   "scripts": {
     "build": "tsup --silent --config tsup.config.ts",
     "build:watch": "pnpm build --watch",

package/.turbo/turbo-build.log

@@ -1,4 +0,0 @@
-
-> @mastra/langfuse@0.0.5-alpha.0 build /home/runner/work/mastra/mastra/observability/langfuse
-> tsup --silent --config tsup.config.ts
-

package/eslint.config.js

@@ -1,6 +0,0 @@
-import { createConfig } from '@internal/lint/eslint';
-
-const config = await createConfig();
-
-/** @type {import("eslint").Linter.Config[]} */
-export default config;

package/src/ai-tracing.test.ts

@@ -1,829 +0,0 @@
-/**
- * Langfuse Exporter Tests
- *
- * These tests focus on Langfuse-specific functionality:
- * - Langfuse client interactions
- * - Mapping logic (spans -> traces/generations/spans)
- * - Type-specific metadata extraction
- * - Langfuse-specific error handling
- */
-
-import type { AITracingEvent, AnyAISpan, LLMGenerationAttributes, ToolCallAttributes } from '@mastra/core/ai-tracing';
-import { AISpanType, AITracingEventType } from '@mastra/core/ai-tracing';
-import { Langfuse } from 'langfuse';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { LangfuseExporter } from './ai-tracing';
-import type { LangfuseExporterConfig } from './ai-tracing';
-
-// Mock Langfuse constructor (must be at the top level)
-vi.mock('langfuse');
-
-describe('LangfuseExporter', () => {
-  // Mock objects
-  let mockGeneration: any;
-  let mockSpan: any;
-  let mockTrace: any;
-  let mockLangfuseClient: any;
-  let LangfuseMock: any;
-
-  let exporter: LangfuseExporter;
-  let config: LangfuseExporterConfig;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    // Set up mocks
-    mockGeneration = {
-      update: vi.fn(),
-      event: vi.fn(),
-    };
-
-    mockSpan = {
-      update: vi.fn(),
-      generation: vi.fn().mockReturnValue(mockGeneration),
-      span: vi.fn(),
-      event: vi.fn(),
-    };
-
-    mockTrace = {
-      generation: vi.fn().mockReturnValue(mockGeneration),
-      span: vi.fn().mockReturnValue(mockSpan),
-      update: vi.fn(),
-      event: vi.fn(),
-    };
-
-    // Set up circular reference
-    mockSpan.span.mockReturnValue(mockSpan);
-
-    mockLangfuseClient = {
-      trace: vi.fn().mockReturnValue(mockTrace),
-      shutdownAsync: vi.fn().mockResolvedValue(undefined),
-    };
-
-    // Get the mocked Langfuse constructor and configure it
-    LangfuseMock = vi.mocked(Langfuse);
-    LangfuseMock.mockImplementation(() => mockLangfuseClient);
-
-    config = {
-      publicKey: 'test-public-key',
-      secretKey: 'test-secret-key',
-      baseUrl: 'https://test-langfuse.com',
-      options: {
-        debug: false,
-        flushAt: 1,
-        flushInterval: 1000,
-      },
-    };
-
-    exporter = new LangfuseExporter(config);
-  });
-
-  describe('Initialization', () => {
-    it('should initialize with correct configuration', () => {
-      expect(exporter.name).toBe('langfuse');
-      // Verify Langfuse client was created with correct config
-      expect(LangfuseMock).toHaveBeenCalledWith({
-        publicKey: 'test-public-key',
-        secretKey: 'test-secret-key',
-        baseUrl: 'https://test-langfuse.com',
-        debug: false,
-        flushAt: 1,
-        flushInterval: 1000,
-      });
-    });
-  });
-
-  describe('Trace Creation', () => {
-    it('should create Langfuse trace for root spans', async () => {
-      const rootSpan = createMockSpan({
-        id: 'root-span-id',
-        name: 'root-agent',
-        type: AISpanType.AGENT_RUN,
-        isRoot: true,
-        attributes: {
-          agentId: 'agent-123',
-          instructions: 'Test agent',
-          spanType: 'agent_run',
-        },
-        metadata: { userId: 'user-456', sessionId: 'session-789' },
-      });
-
-      const event: AITracingEvent = {
-        type: AITracingEventType.SPAN_STARTED,
-        span: rootSpan,
-      };
-
-      await exporter.exportEvent(event);
-
-      // Should create Langfuse trace with correct parameters
-      expect(mockLangfuseClient.trace).toHaveBeenCalledWith({
-        id: 'root-span-id', // Uses span.trace.id
-        name: 'root-agent',
-        userId: 'user-456',
-        sessionId: 'session-789',
-        metadata: {
-          agentId: 'agent-123',
-          instructions: 'Test agent',
-          spanType: 'agent_run',
-        },
-      });
-    });
-
-    it('should not create trace for child spans', async () => {
-      const childSpan = createMockSpan({
-        id: 'child-span-id',
-        name: 'child-tool',
-        type: AISpanType.TOOL_CALL,
-        isRoot: false,
-        attributes: { toolId: 'calculator' },
-      });
-
-      const event: AITracingEvent = {
-        type: AITracingEventType.SPAN_STARTED,
-        span: childSpan,
-      };
-
-      await exporter.exportEvent(event);
-
-      // Should not create trace for child spans
-      expect(mockLangfuseClient.trace).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('LLM Generation Mapping', () => {
-    it('should create Langfuse generation for LLM_GENERATION spans', async () => {
-      const llmSpan = createMockSpan({
-        id: 'llm-span-id',
-        name: 'gpt-4-call',
-        type: AISpanType.LLM_GENERATION,
-        isRoot: true,
-        input: { messages: [{ role: 'user', content: 'Hello' }] },
-        output: { content: 'Hi there!' },
-        attributes: {
-          model: 'gpt-4',
-          provider: 'openai',
-          usage: {
-            promptTokens: 10,
-            completionTokens: 5,
-            totalTokens: 15,
-          },
-          parameters: {
-            temperature: 0.7,
-            maxTokens: 100,
-            topP: 0.9,
-          },
-          streaming: false,
-          resultType: 'response_generation',
-        },
-      });
-
-      const event: AITracingEvent = {
-        type: AITracingEventType.SPAN_STARTED,
-        span: llmSpan,
-      };
-
-      await exporter.exportEvent(event);
-
-      // Should create Langfuse generation with LLM-specific fields
-      expect(mockTrace.generation).toHaveBeenCalledWith({
-        id: 'llm-span-id',
-        name: 'gpt-4-call',
-        startTime: llmSpan.startTime,
-        model: 'gpt-4',
-        modelParameters: {
-          temperature: 0.7,
-          maxTokens: 100,
-          topP: 0.9,
-        },
-        input: { messages: [{ role: 'user', content: 'Hello' }] },
-        output: { content: 'Hi there!' },
-        usage: {
-          promptTokens: 10,
-          completionTokens: 5,
-          totalTokens: 15,
-        },
-        metadata: {
-          provider: 'openai',
-          resultType: 'response_generation',
-          spanType: 'llm_generation',
-          streaming: false,
-        },
-      });
-    });
-
-    it('should handle LLM spans without optional fields', async () => {
-      const minimalLlmSpan = createMockSpan({
-        id: 'minimal-llm',
-        name: 'simple-llm',
-        type: AISpanType.LLM_GENERATION,
-        isRoot: true,
-        attributes: {
-          model: 'gpt-3.5-turbo',
-          // No usage, parameters, input, output, etc.
-        },
-      });
-
-      const event: AITracingEvent = {
-        type: AITracingEventType.SPAN_STARTED,
-        span: minimalLlmSpan,
-      };
-
-      await exporter.exportEvent(event);
-
-      expect(mockTrace.generation).toHaveBeenCalledWith({
-        id: 'minimal-llm',
-        name: 'simple-llm',
-        startTime: minimalLlmSpan.startTime,
-        model: 'gpt-3.5-turbo',
-        metadata: {
-          spanType: 'llm_generation',
-        },
-      });
-    });
-  });
-
-  describe('Regular Span Mapping', () => {
-    it('should create Langfuse span for non-LLM span types', async () => {
-      const toolSpan = createMockSpan({
-        id: 'tool-span-id',
-        name: 'calculator-tool',
-        type: AISpanType.TOOL_CALL,
-        isRoot: true,
-        input: { operation: 'add', a: 2, b: 3 },
-        output: { result: 5 },
-        attributes: {
-          toolId: 'calculator',
-          success: true,
-        },
-      });
-
-      const event: AITracingEvent = {
-        type: AITracingEventType.SPAN_STARTED,
-        span: toolSpan,
-      };
-
-      await exporter.exportEvent(event);
-
-      expect(mockTrace.span).toHaveBeenCalledWith({
-        id: 'tool-span-id',
-        name: 'calculator-tool',
-        startTime: toolSpan.startTime,
-        input: { operation: 'add', a: 2, b: 3 },
-        output: { result: 5 },
-        metadata: {
-          spanType: 'tool_call',
-          toolId: 'calculator',
-          success: true,
-        },
-      });
-    });
-  });
-
-  describe('Type-Specific Metadata Extraction', () => {
-    it('should extract agent-specific metadata', async () => {
-      const agentSpan = createMockSpan({
-        id: 'agent-span',
-        name: 'customer-agent',
-        type: AISpanType.AGENT_RUN,
-        isRoot: true,
-        attributes: {
-          agentId: 'agent-456',
-          availableTools: ['search', 'calculator'],
-          maxSteps: 10,
-          currentStep: 3,
-          instructions: 'Help customers',
-        },
-      });
-
-      const event: AITracingEvent = {
-        type: AITracingEventType.SPAN_STARTED,
-        span: agentSpan,
-      };
-
-      await exporter.exportEvent(event);
-
-      expect(mockTrace.span).toHaveBeenCalledWith(
-        expect.objectContaining({
-          metadata: expect.objectContaining({
-            spanType: 'agent_run',
-            agentId: 'agent-456',
-            availableTools: ['search', 'calculator'],
-            maxSteps: 10,
-            currentStep: 3,
-          }),
-        }),
-      );
-    });
-
-    it('should extract MCP tool-specific metadata', async () => {
-      const mcpSpan = createMockSpan({
-        id: 'mcp-span',
-        name: 'mcp-tool-call',
-        type: AISpanType.MCP_TOOL_CALL,
-        isRoot: true,
-        attributes: {
-          toolId: 'file-reader',
-          mcpServer: 'filesystem-mcp',
-          serverVersion: '1.0.0',
-          success: true,
-        },
-      });
-
-      const event: AITracingEvent = {
-        type: AITracingEventType.SPAN_STARTED,
-        span: mcpSpan,
-      };
-
-      await exporter.exportEvent(event);
-
-      expect(mockTrace.span).toHaveBeenCalledWith(
-        expect.objectContaining({
-          metadata: expect.objectContaining({
-            spanType: 'mcp_tool_call',
-            toolId: 'file-reader',
-            mcpServer: 'filesystem-mcp',
-            serverVersion: '1.0.0',
-            success: true,
-          }),
-        }),
-      );
-    });
-
-    it('should extract workflow-specific metadata', async () => {
-      const workflowSpan = createMockSpan({
-        id: 'workflow-span',
-        name: 'data-processing-workflow',
-        type: AISpanType.WORKFLOW_RUN,
-        isRoot: true,
-        attributes: {
-          workflowId: 'wf-123',
-          status: 'running',
-        },
-      });
-
-      const event: AITracingEvent = {
-        type: AITracingEventType.SPAN_STARTED,
-        span: workflowSpan,
-      };
-
-      await exporter.exportEvent(event);
-
-      expect(mockTrace.span).toHaveBeenCalledWith(
-        expect.objectContaining({
-          metadata: expect.objectContaining({
-            spanType: 'workflow_run',
-            workflowId: 'wf-123',
-            status: 'running',
-          }),
-        }),
-      );
-    });
-  });
-
-  describe('Span Updates', () => {
-    it('should update LLM generation with new data', async () => {
-      // First, start a span
-      const llmSpan = createMockSpan({
-        id: 'llm-span',
-        name: 'gpt-4-call',
-        type: AISpanType.LLM_GENERATION,
-        isRoot: true,
-        attributes: { model: 'gpt-4' },
-      });
-
-      await exporter.exportEvent({
-        type: AITracingEventType.SPAN_STARTED,
-        span: llmSpan,
-      });
-
-      // Then update it
-      llmSpan.attributes = {
-        ...llmSpan.attributes,
-        usage: { totalTokens: 150 },
-      } as LLMGenerationAttributes;
-      llmSpan.output = { content: 'Updated response' };
-
-      await exporter.exportEvent({
-        type: AITracingEventType.SPAN_UPDATED,
-        span: llmSpan,
-      });
-
-      expect(mockGeneration.update).toHaveBeenCalledWith({
-        metadata: expect.objectContaining({
-          spanType: 'llm_generation',
-        }),
-        model: 'gpt-4',
-        output: { content: 'Updated response' },
-        usage: {
-          totalTokens: 150,
-        },
-      });
-    });
-
-    it('should update regular spans', async () => {
-      const toolSpan = createMockSpan({
-        id: 'tool-span',
-        name: 'calculator',
-        type: AISpanType.TOOL_CALL,
-        isRoot: true,
-        attributes: { toolId: 'calc', success: false },
-      });
-
-      await exporter.exportEvent({
-        type: AITracingEventType.SPAN_STARTED,
-        span: toolSpan,
-      });
-
-      // Update with success
-      toolSpan.attributes = {
-        ...toolSpan.attributes,
-        success: true,
-      } as ToolCallAttributes;
-      toolSpan.output = { result: 42 };
-
-      await exporter.exportEvent({
-        type: AITracingEventType.SPAN_UPDATED,
-        span: toolSpan,
-      });
-
-      expect(mockSpan.update).toHaveBeenCalledWith({
-        metadata: expect.objectContaining({
-          spanType: 'tool_call',
-          success: true,
-        }),
-        output: { result: 42 },
-      });
-    });
-  });
-
-  describe('Span Ending', () => {
-    it('should update span with endTime on span end', async () => {
-      const span = createMockSpan({
-        id: 'test-span',
-        name: 'test',
-        type: AISpanType.GENERIC,
-        isRoot: true,
-        attributes: {},
-      });
-
-      await exporter.exportEvent({
-        type: AITracingEventType.SPAN_STARTED,
-        span,
-      });
-
-      span.endTime = new Date();
-
-      await exporter.exportEvent({
-        type: AITracingEventType.SPAN_ENDED,
-        span,
-      });
-
-      expect(mockSpan.update).toHaveBeenCalledWith({
-        endTime: span.endTime,
-        metadata: expect.objectContaining({
-          spanType: 'generic',
-        }),
-      });
-    });
-
-    it('should update span with error information on span end', async () => {
-      const errorSpan = createMockSpan({
-        id: 'error-span',
-        name: 'failing-operation',
-        type: AISpanType.TOOL_CALL,
-        isRoot: true,
-        attributes: {
-          toolId: 'failing-tool',
-        },
-        errorInfo: {
-          message: 'Tool execution failed',
-          id: 'TOOL_ERROR',
-          category: 'EXECUTION',
-        },
-      });
-
-      errorSpan.endTime = new Date();
-
-      await exporter.exportEvent({
-        type: AITracingEventType.SPAN_STARTED,
-        span: errorSpan,
-      });
-
-      await exporter.exportEvent({
-        type: AITracingEventType.SPAN_ENDED,
-        span: errorSpan,
-      });
-
-      expect(mockSpan.update).toHaveBeenCalledWith({
-        endTime: errorSpan.endTime,
-        metadata: expect.objectContaining({
-          spanType: 'tool_call',
-          toolId: 'failing-tool',
-        }),
-        level: 'ERROR',
-        statusMessage: 'Tool execution failed',
-      });
-    });
-
-    it('should update root trace and delete from traceMap when root span ends', async () => {
-      const rootSpan = createMockSpan({
-        id: 'root-span-id',
-        name: 'root-span',
-        type: AISpanType.AGENT_RUN,
-        isRoot: true,
-        attributes: {},
-      });
-
-      rootSpan.output = { result: 'success' };
-      rootSpan.endTime = new Date();
-
-      await exporter.exportEvent({
-        type: AITracingEventType.SPAN_STARTED,
-        span: rootSpan,
-      });
-
-      // Verify trace was created
-      expect((exporter as any).traceMap.has('root-span-id')).toBe(true);
-
-      await exporter.exportEvent({
-        type: AITracingEventType.SPAN_ENDED,
-        span: rootSpan,
-      });
-
-      // Should update trace with output
-      expect(mockTrace.update).toHaveBeenCalledWith({
-        output: { result: 'success' },
-      });
-
-      // Should remove trace from traceMap
-      expect((exporter as any).traceMap.has('root-span-id')).toBe(false);
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle missing traces gracefully', async () => {
-      const orphanSpan = createMockSpan({
-        id: 'orphan-span',
-        name: 'orphan',
-        type: AISpanType.TOOL_CALL,
-        isRoot: false, // Child span without parent trace
-        attributes: { toolId: 'orphan-tool' },
-      });
-
-      // Should not throw when trying to create child span without trace
-      await expect(
-        exporter.exportEvent({
-          type: AITracingEventType.SPAN_STARTED,
-          span: orphanSpan,
-        }),
-      ).resolves.not.toThrow();
-
-      // Should not create Langfuse span
-      expect(mockTrace.span).not.toHaveBeenCalled();
-      expect(mockTrace.generation).not.toHaveBeenCalled();
-    });
-
-    it('should handle missing Langfuse objects gracefully', async () => {
-      const span = createMockSpan({
-        id: 'missing-span',
-        name: 'missing',
-        type: AISpanType.GENERIC,
-        isRoot: true,
-        attributes: {},
-      });
-
-      // Try to update non-existent span
-      await expect(
-        exporter.exportEvent({
-          type: AITracingEventType.SPAN_UPDATED,
-          span,
-        }),
-      ).resolves.not.toThrow();
-
-      // Try to end non-existent span
-      await expect(
-        exporter.exportEvent({
-          type: AITracingEventType.SPAN_ENDED,
-          span,
-        }),
-      ).resolves.not.toThrow();
-    });
-  });
-
-  describe('Event Span Handling', () => {
-    let mockEvent: any;
-
-    beforeEach(() => {
-      mockEvent = {
-        update: vi.fn(),
-      };
-      mockTrace.event.mockReturnValue(mockEvent);
-      mockSpan.event.mockReturnValue(mockEvent);
-      mockGeneration.event.mockReturnValue(mockEvent);
-    });
-
-    it('should create Langfuse event for root event spans', async () => {
-      const eventSpan = createMockSpan({
-        id: 'event-span-id',
-        name: 'user-feedback',
-        type: AISpanType.GENERIC,
-        isRoot: true,
-        attributes: {
-          eventType: 'user_feedback',
-          rating: 5,
-        },
-        input: { message: 'Great response!' },
-      });
-      eventSpan.isEvent = true;
-
-      await exporter.exportEvent({
-        type: AITracingEventType.SPAN_STARTED,
-        span: eventSpan,
-      });
-
-      // Should create trace for root event span
-      expect(mockLangfuseClient.trace).toHaveBeenCalledWith({
-        id: 'event-span-id',
-        name: 'user-feedback',
-        input: { message: 'Great response!' },
-        metadata: {
-          spanType: 'generic',
-          eventType: 'user_feedback',
-          rating: 5,
-        },
-      });
-
-      // Should create Langfuse event
-      expect(mockTrace.event).toHaveBeenCalledWith({
-        id: 'event-span-id',
-        name: 'user-feedback',
-        startTime: eventSpan.startTime,
-        input: { message: 'Great response!' },
-        metadata: {
-          spanType: 'generic',
-          eventType: 'user_feedback',
-          rating: 5,
-        },
-      });
-    });
-
-    it('should create Langfuse event for child event spans', async () => {
-      // First create a root span
-      const rootSpan = createMockSpan({
-        id: 'root-span-id',
-        name: 'root-agent',
-        type: AISpanType.AGENT_RUN,
-        isRoot: true,
-        attributes: {},
-      });
-
-      await exporter.exportEvent({
-        type: AITracingEventType.SPAN_STARTED,
-        span: rootSpan,
-      });
-
-      // Then create a child event span
-      const childEventSpan = createMockSpan({
-        id: 'child-event-id',
-        name: 'tool-result',
-        type: AISpanType.GENERIC,
-        isRoot: false,
-        attributes: {
-          toolName: 'calculator',
-          success: true,
-        },
-        output: { result: 42 },
-      });
-      childEventSpan.isEvent = true;
-      childEventSpan.traceId = 'root-span-id';
-      childEventSpan.parent = { id: 'root-span-id' };
-
-      await exporter.exportEvent({
-        type: AITracingEventType.SPAN_STARTED,
-        span: childEventSpan,
-      });
-
-      // Should create event under the parent span
-      expect(mockSpan.event).toHaveBeenCalledWith({
-        id: 'child-event-id',
-        name: 'tool-result',
-        startTime: childEventSpan.startTime,
-        output: { result: 42 },
-        metadata: {
-          spanType: 'generic',
-          toolName: 'calculator',
-          success: true,
-        },
-      });
-    });
-
-    it('should handle event spans with missing parent gracefully', async () => {
-      const orphanEventSpan = createMockSpan({
-        id: 'orphan-event-id',
-        name: 'orphan-event',
-        type: AISpanType.GENERIC,
-        isRoot: false,
-        attributes: {},
-      });
-      orphanEventSpan.isEvent = true;
-      orphanEventSpan.traceId = 'missing-trace-id';
-
-      // Should not throw
-      await expect(
-        exporter.exportEvent({
-          type: AITracingEventType.SPAN_STARTED,
-          span: orphanEventSpan,
-        }),
-      ).resolves.not.toThrow();
-
-      // Should not create any Langfuse objects
-      expect(mockTrace.event).not.toHaveBeenCalled();
-      expect(mockSpan.event).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('Shutdown', () => {
-    it('should shutdown Langfuse client and clear maps', async () => {
-      // Add some data to internal maps
-      const span = createMockSpan({
-        id: 'test-span',
-        name: 'test',
-        type: AISpanType.GENERIC,
-        isRoot: true,
-        attributes: {},
-      });
-
-      await exporter.exportEvent({
-        type: AITracingEventType.SPAN_STARTED,
-        span,
-      });
-
-      // Verify maps have data
-      expect((exporter as any).traceMap.size).toBeGreaterThan(0);
-      expect((exporter as any).traceMap.get('test-span').spans.size).toBeGreaterThan(0);
-
-      // Shutdown
-      await exporter.shutdown();
-
-      // Verify Langfuse client shutdown was called
-      expect(mockLangfuseClient.shutdownAsync).toHaveBeenCalled();
-
-      // Verify maps were cleared
-      expect((exporter as any).traceMap.size).toBe(0);
-    });
-  });
-});
-
-// Helper function to create mock spans
-function createMockSpan({
-  id,
-  name,
-  type,
-  isRoot,
-  attributes,
-  metadata,
-  input,
-  output,
-  errorInfo,
-}: {
-  id: string;
-  name: string;
-  type: AISpanType;
-  isRoot: boolean;
-  attributes: any;
-  metadata?: Record<string, any>;
-  input?: any;
-  output?: any;
-  errorInfo?: any;
-}): AnyAISpan {
-  const mockSpan = {
-    id,
-    name,
-    type,
-    attributes,
-    metadata,
-    input,
-    output,
-    errorInfo,
-    startTime: new Date(),
-    endTime: undefined,
-    traceId: isRoot ? id : 'parent-trace-id',
-    get isRootSpan() {
-      return isRoot;
-    },
-    trace: {
-      id: isRoot ? id : 'parent-trace-id',
-      traceId: isRoot ? id : 'parent-trace-id',
-    } as AnyAISpan,
-    parent: isRoot ? undefined : { id: 'parent-id' },
-    aiTracing: {} as any,
-    end: vi.fn(),
-    error: vi.fn(),
-    update: vi.fn(),
-    createChildSpan: vi.fn(),
-    createEventSpan: vi.fn(),
-    isEvent: false,
-  } as AnyAISpan;
-
-  return mockSpan;
-}

package/src/ai-tracing.ts

@@ -1,291 +0,0 @@
-/**
- * Langfuse Exporter for Mastra AI Tracing
- *
- * This exporter sends tracing data to Langfuse for AI observability.
- * Root spans start traces in Langfuse.
- * LLM_GENERATION spans become Langfuse generations, all others become spans.
- */
-
-import type { AITracingExporter, AITracingEvent, AnyAISpan, LLMGenerationAttributes } from '@mastra/core/ai-tracing';
-import { AISpanType, omitKeys } from '@mastra/core/ai-tracing';
-import { ConsoleLogger } from '@mastra/core/logger';
-import { Langfuse } from 'langfuse';
-import type { LangfuseTraceClient, LangfuseSpanClient, LangfuseGenerationClient, LangfuseEventClient } from 'langfuse';
-
-export interface LangfuseExporterConfig {
-  /** Langfuse API key */
-  publicKey: string;
-  /** Langfuse secret key */
-  secretKey: string;
-  /** Langfuse host URL */
-  baseUrl: string;
-  /** Enable realtime mode - flushes after each event for immediate visibility */
-  realtime?: boolean;
-  /** Logger level for diagnostic messages (default: 'warn') */
-  logLevel?: 'debug' | 'info' | 'warn' | 'error';
-  /** Additional options to pass to the Langfuse client */
-  options?: any;
-}
-
-type TraceData = {
-  trace: LangfuseTraceClient; // Langfuse trace object
-  spans: Map<string, LangfuseSpanClient | LangfuseGenerationClient>; // Maps span.id to Langfuse span/generation
-  events: Map<string, LangfuseEventClient>; // Maps span.id to Langfuse event
-};
-
-type LangfuseParent = LangfuseTraceClient | LangfuseSpanClient | LangfuseGenerationClient | LangfuseEventClient;
-
-export class LangfuseExporter implements AITracingExporter {
-  name = 'langfuse';
-  private client: Langfuse;
-  private realtime: boolean;
-  private traceMap = new Map<string, TraceData>();
-  private logger: ConsoleLogger;
-
-  constructor(config: LangfuseExporterConfig) {
-    this.realtime = config.realtime ?? false;
-    this.logger = new ConsoleLogger({ level: config.logLevel ?? 'warn' });
-    this.client = new Langfuse({
-      publicKey: config.publicKey,
-      secretKey: config.secretKey,
-      baseUrl: config.baseUrl,
-      ...config.options,
-    });
-  }
-
-  async exportEvent(event: AITracingEvent): Promise<void> {
-    if (event.span.isEvent) {
-      await this.handleEventSpan(event.span);
-      return;
-    }
-
-    switch (event.type) {
-      case 'span_started':
-        await this.handleSpanStarted(event.span);
-        break;
-      case 'span_updated':
-        await this.handleSpanUpdateOrEnd(event.span, false);
-        break;
-      case 'span_ended':
-        await this.handleSpanUpdateOrEnd(event.span, true);
-        break;
-    }
-
-    // Flush immediately in realtime mode for instant visibility
-    if (this.realtime) {
-      await this.client.flushAsync();
-    }
-  }
-
-  private async handleSpanStarted(span: AnyAISpan): Promise<void> {
-    if (span.isRootSpan) {
-      this.initTrace(span);
-    }
-    const method = 'handleSpanStarted';
-
-    const traceData = this.getTraceData({ span, method });
-    if (!traceData) {
-      return;
-    }
-
-    const langfuseParent = this.getLangfuseParent({ traceData, span, method });
-    if (!langfuseParent) {
-      return;
-    }
-
-    const payload = this.buildSpanPayload(span, true);
-
-    const langfuseSpan =
-      span.type === AISpanType.LLM_GENERATION ? langfuseParent.generation(payload) : langfuseParent.span(payload);
-
-    traceData.spans.set(span.id, langfuseSpan);
-  }
-
-  private async handleSpanUpdateOrEnd(span: AnyAISpan, isEnd: boolean): Promise<void> {
-    const method = isEnd ? 'handleSpanEnd' : 'handleSpanUpdate';
-
-    const traceData = this.getTraceData({ span, method });
-    if (!traceData) {
-      return;
-    }
-
-    const langfuseSpan = traceData.spans.get(span.id);
-    if (!langfuseSpan) {
-      this.logger.warn('Langfuse exporter: No Langfuse span found for span update/end', {
-        traceId: span.traceId,
-        spanId: span.id,
-        spanName: span.name,
-        spanType: span.type,
-        isRootSpan: span.isRootSpan,
-        parentSpanId: span.parent?.id,
-        availableSpanIds: Array.from(traceData.spans.keys()),
-        method,
-      });
-      return;
-    }
-
-    // use update for both update & end, so that we can use the
-    // end time we set when ending the span.
-    langfuseSpan.update(this.buildSpanPayload(span, false));
-
-    if (isEnd && span.isRootSpan) {
-      traceData.trace.update({ output: span.output });
-      this.traceMap.delete(span.traceId);
-    }
-  }
-
-  private async handleEventSpan(span: AnyAISpan): Promise<void> {
-    if (span.isRootSpan) {
-      this.logger.debug('Langfuse exporter: Creating trace', {
-        traceId: span.traceId,
-        spanId: span.id,
-        spanName: span.name,
-        method: 'handleEventSpan',
-      });
-      this.initTrace(span);
-    }
-    const method = 'handleEventSpan';
-
-    const traceData = this.getTraceData({ span, method });
-    if (!traceData) {
-      return;
-    }
-
-    const langfuseParent = this.getLangfuseParent({ traceData, span, method });
-    if (!langfuseParent) {
-      return;
-    }
-
-    const payload = this.buildSpanPayload(span, true);
-
-    const langfuseEvent = langfuseParent.event(payload);
-
-    traceData.events.set(span.id, langfuseEvent);
-  }
-
-  private initTrace(span: AnyAISpan): void {
-    const trace = this.client.trace(this.buildTracePayload(span));
-    this.traceMap.set(span.traceId, { trace, spans: new Map(), events: new Map() });
-  }
-
-  private getTraceData(options: { span: AnyAISpan; method: string }): TraceData | undefined {
-    const { span, method } = options;
-    if (this.traceMap.has(span.traceId)) {
-      return this.traceMap.get(span.traceId);
-    }
-    this.logger.warn('Langfuse exporter: No trace data found for span', {
-      traceId: span.traceId,
-      spanId: span.id,
-      spanName: span.name,
-      spanType: span.type,
-      isRootSpan: span.isRootSpan,
-      parentSpanId: span.parent?.id,
-      method,
-    });
-  }
-
-  private getLangfuseParent(options: {
-    traceData: TraceData;
-    span: AnyAISpan;
-    method: string;
-  }): LangfuseParent | undefined {
-    const { traceData, span, method } = options;
-
-    const parentId = span.parent?.id;
-    if (!parentId) {
-      return traceData.trace;
-    }
-    if (traceData.spans.has(parentId)) {
-      return traceData.spans.get(parentId);
-    }
-    if (traceData.events.has(parentId)) {
-      return traceData.events.get(parentId);
-    }
-    this.logger.warn('Langfuse exporter: No parent data found for span', {
-      traceId: span.traceId,
-      spanId: span.id,
-      spanName: span.name,
-      spanType: span.type,
-      isRootSpan: span.isRootSpan,
-      parentSpanId: span.parent?.id,
-      method,
-    });
-  }
-
-  private buildTracePayload(span: AnyAISpan): Record<string, any> {
-    const payload: Record<string, any> = {
-      id: span.traceId,
-      name: span.name,
-    };
-
-    const { userId, sessionId, ...remainingMetadata } = span.metadata ?? {};
-
-    if (userId) payload.userId = userId;
-    if (sessionId) payload.sessionId = sessionId;
-    if (span.input) payload.input = span.input;
-
-    payload.metadata = {
-      spanType: span.type,
-      ...span.attributes,
-      ...remainingMetadata,
-    };
-
-    return payload;
-  }
-
-  private buildSpanPayload(span: AnyAISpan, isCreate: boolean): Record<string, any> {
-    const payload: Record<string, any> = {};
-
-    if (isCreate) {
-      payload.id = span.id;
-      payload.name = span.name;
-      payload.startTime = span.startTime;
-      if (span.input !== undefined) payload.input = span.input;
-    }
-
-    if (span.output !== undefined) payload.output = span.output;
-    if (span.endTime !== undefined) payload.endTime = span.endTime;
-
-    const attributes = (span.attributes ?? {}) as Record<string, any>;
-
-    // Strip special fields from metadata if used in top-level keys
-    const attributesToOmit: string[] = [];
-
-    if (span.type === AISpanType.LLM_GENERATION) {
-      const llmAttr = attributes as LLMGenerationAttributes;
-
-      if (llmAttr.model !== undefined) {
-        payload.model = llmAttr.model;
-        attributesToOmit.push('model');
-      }
-
-      if (llmAttr.usage !== undefined) {
-        payload.usage = llmAttr.usage;
-        attributesToOmit.push('usage');
-      }
-
-      if (llmAttr.parameters !== undefined) {
-        payload.modelParameters = llmAttr.parameters;
-        attributesToOmit.push('parameters');
-      }
-    }
-
-    payload.metadata = {
-      spanType: span.type,
-      ...omitKeys(attributes, attributesToOmit),
-      ...span.metadata,
-    };
-
-    if (span.errorInfo) {
-      payload.level = 'ERROR';
-      payload.statusMessage = span.errorInfo.message;
-    }
-
-    return payload;
-  }
-
-  async shutdown(): Promise<void> {
-    await this.client.shutdownAsync();
-    this.traceMap.clear();
-  }
-}

package/src/index.ts

@@ -1,9 +0,0 @@
-/**
- * Langfuse Observability Provider for Mastra
- *
- * This package provides Langfuse-specific observability features for Mastra applications.
- * Currently includes AI tracing support with plans for additional observability features.
- */
-
-// AI Tracing
-export * from './ai-tracing';

package/tsconfig.build.json

@@ -1,9 +0,0 @@
-{
-  "extends": ["./tsconfig.json", "../../tsconfig.build.json"],
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "**/*.test.ts", "src/**/*.mock.ts"]
-}

package/tsconfig.json

@@ -1,5 +0,0 @@
-{
-  "extends": "../../tsconfig.node.json",
-  "include": ["src/**/*", "tsup.config.ts"],
-  "exclude": ["node_modules", "**/*.test.ts"]
-}

package/tsup.config.ts

@@ -1,17 +0,0 @@
-import { generateTypes } from '@internal/types-builder';
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  format: ['esm', 'cjs'],
-  clean: true,
-  dts: false,
-  splitting: true,
-  treeshake: {
-    preset: 'smallest',
-  },
-  sourcemap: true,
-  onSuccess: async () => {
-    await generateTypes(process.cwd());
-  },
-});

package/vitest.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    environment: 'node',
-    include: ['src/**/*.test.ts'],
-    coverage: {
-      reporter: ['text', 'json', 'html'],
-    },
-  },
-});