@traccia2/sdk 0.0.1 → 0.0.2

package/README.md

@@ -1,11 +1,12 @@
 # Traccia SDK for TypeScript
 
-Production-grade distributed tracing SDK for agent applications. Built with TypeScript and designed for high performance, reliability, and ease of integration.
+Distributed tracing SDK for agent applications. Built with TypeScript and designed for high performance, reliability, and ease of integration.
 
 ## Features
 
 - **Distributed Tracing**: Create, propagate, and manage spans across service boundaries
 - **Automatic Instrumentation**: Optional auto-instrumentation for popular LLM libraries (OpenAI, Anthropic)
+- **Framework Integrations**: Built-in support for LangChain (callbacks) and LangGraph (instrumentation)
 - **Span Processors**: Built-in processors for sampling, batching, token counting, and cost analysis
 - **Token & Cost Tracking**: Automatic token counting and cost calculation for LLM calls
 - **Flexible Exporters**: Export spans via HTTP, console, or custom exporters
@@ -327,6 +328,239 @@ await stopTracing();
 
 ## Advanced Usage
 
+### Framework Integrations
+
+#### LangChain with Callback Handler
+
+The SDK provides a `TraciaCallbackHandler` for seamless integration with LangChain:
+
+```typescript
+import { startTracing, getTracer } from '@traccia/sdk';
+import { TraciaCallbackHandler } from '@traccia/sdk/integrations/langchain-callback';
+import { ChatOpenAI } from '@langchain/openai';
+import { AgentExecutor, createOpenAIToolsAgent } from 'langchain/agents';
+
+// Initialize tracing
+await startTracing({
+  apiKey: 'your-api-key',
+  enableConsoleExporter: true,
+});
+
+// Create callback handler for tracing
+const traciaHandler = new TraciaCallbackHandler();
+
+// Use with LangChain models and agents
+const model = new ChatOpenAI({ 
+  modelName: 'gpt-4',
+  callbacks: [traciaHandler],
+});
+
+const agent = await createOpenAIToolsAgent({
+  llmWithTools: model,
+  tools: [yourTools],
+  callbacks: [traciaHandler],
+});
+
+const executor = new AgentExecutor({
+  agent,
+  tools: [yourTools],
+  callbacks: [traciaHandler],
+});
+
+// Run with automatic tracing
+const result = await executor.invoke({
+  input: 'Your prompt here',
+});
+```
+
+The `TraciaCallbackHandler` automatically traces:
+
+- **LLM Calls**: Model name, token counts, latency
+- **Agent Actions**: Tool selection and execution
+- **Chain Steps**: Multi-step reasoning and intermediate results
+- **Tool Usage**: Tool names, inputs, and outputs
+- **Errors & Exceptions**: Automatic error recording
+
+**Traced Metrics:**
+
+```typescript
+// Automatically captured attributes:
+{
+  'llm.model': 'gpt-4',
+  'llm.tokens.prompt': 150,
+  'llm.tokens.completion': 75,
+  'llm.tokens.total': 225,
+  'agent.action': 'tool_use',
+  'agent.tool': 'calculator',
+  'agent.tool.input': '{"expression": "2 + 2"}',
+  'agent.tool.output': '4',
+  'chain.steps': 3,
+  'error.type': 'ValidationError', // if applicable
+  'error.message': 'Invalid input', // if applicable
+}
+```
+
+#### LangGraph with Instrumentation
+
+For LangGraph, use the `instrumentLangGraph` utility:
+
+```typescript
+import { startTracing } from '@traccia/sdk';
+import { instrumentLangGraph, createTracedNode, createTracedConditional } from '@traccia/sdk/integrations/langgraph-instrumentation';
+import { StateGraph } from '@langchain/langgraph';
+
+// Initialize tracing
+await startTracing({
+  apiKey: 'your-api-key',
+  enableConsoleExporter: true,
+});
+
+// Wrap your graph with instrumentation
+const graph = new StateGraph(/* ... */);
+
+// Option 1: Instrument entire graph
+const instrumentedGraph = instrumentLangGraph(graph, {
+  traceGraphExecution: true,
+  traceNodeExecution: true,
+  captureGraphState: true,
+});
+
+// Option 2: Wrap individual nodes
+const processNode = createTracedNode(
+  'process-step',
+  async (state) => {
+    // Node logic
+    return { result: 'done' };
+  }
+);
+
+graph.addNode('process', processNode);
+
+// Option 3: Trace conditional logic
+const router = createTracedConditional(
+  'route-decision',
+  (state) => {
+    return state.requiresApproval ? 'approval' : 'processing';
+  }
+);
+
+graph.addConditionalEdges('decide', router);
+```
+
+**Captured Graph Metrics:**
+
+```typescript
+// Automatically traced:
+{
+  'graph.name': 'my-agent-graph',
+  'graph.step': 2,
+  'node.name': 'process-step',
+  'node.type': 'regular|start|end',
+  'node.duration_ms': 250,
+  'edge.from': 'start',
+  'edge.to': 'process',
+  'conditional.decision': 'approval',
+  'graph.state': { /* full state if enabled */ },
+  'error.type': 'NodeExecutionError', // if applicable
+}
+```
+
+#### Ollama Integration
+
+Run local LLMs with Ollama and automatic tracing:
+
+```typescript
+import { startTracing } from '@traccia/sdk';
+import { createOllamaChatbot, getOllamaSetupInstructions } from '@traccia/sdk/integrations';
+
+// Initialize tracing
+await startTracing({
+  enableConsoleExporter: true,
+});
+
+// Create a chatbot using local Ollama model
+const chatbot = await createOllamaChatbot({
+  model: 'mistral',                    // Download with: ollama pull mistral
+  baseUrl: 'http://localhost:11434',   // Default Ollama port
+  systemPrompt: 'You are a helpful assistant.',
+  temperature: 0.7,
+});
+
+// Use the chatbot - fully traced!
+const response = await chatbot('What is machine learning?');
+console.log(response);
+```
+
+**Setup Instructions:**
+
+```typescript
+import { getOllamaSetupInstructions } from '@traccia/sdk/integrations';
+
+console.log(getOllamaSetupInstructions());
+// Prints installation and setup steps
+```
+
+**Quick Start:**
+
+1. Install Ollama: https://ollama.ai/download
+2. Start Ollama: `ollama serve`
+3. Pull a model: `ollama pull mistral`
+4. Use in code:
+
+```typescript
+import { createOllamaChatbot } from '@traccia/sdk/integrations';
+
+const chatbot = await createOllamaChatbot({
+  model: 'mistral',
+});
+
+const response = await chatbot('Hello!');
+// Automatically traced!
+```
+
+**Popular Ollama Models:**
+
+```typescript
+import { POPULAR_OLLAMA_MODELS } from '@traccia/sdk/integrations';
+
+// mistral - Fast 7B model (recommended for speed)
+// neural-chat - Optimized for conversations
+// llama2 - Versatile 7B model
+// orca-mini - Small 3B model (fastest)
+// dolphin-mixtral - High quality but larger
+// opencodeup - Specialized for code
+
+for (const model of POPULAR_OLLAMA_MODELS) {
+  console.log(`${model.name}: ${model.description}`);
+  console.log(`Size: ${model.size}`);
+  console.log(`Install: ${model.command}`);
+}
+```
+
+**Streaming Responses:**
+
+For models that support streaming, stream responses as they're generated:
+
+```typescript
+import { createOllamaStreamingChatbot } from '@traccia/sdk/integrations';
+
+const chatbot = await createOllamaStreamingChatbot({
+  model: 'mistral',
+  onChunk: (chunk) => process.stdout.write(chunk), // Print as it arrives
+});
+
+await chatbot('Write a story about a robot');
+// Output streams in real-time!
+```
+
+**Automatic Tracing Features:**
+
+- Model name and configuration tracking
+- Input/output length tracking
+- Latency measurement
+- Error recording
+- Streaming span management
+
 ### Custom Exporters
 
 Implement the `ISpanExporter` interface:

package/dist/integrations/auto-langchain.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Automatic LangChain instrumentation - simple one-line setup.
+ *
+ * Instead of manually passing callbacks to every component, use these
+ * convenience functions for automatic instrumentation with zero boilerplate.
+ */
+import { TraciaCallbackHandler } from './langchain-callback';
+/**
+ * Get or create the global Traccia callback handler.
+ *
+ * @example
+ * // Instead of:
+ * const handler = new TraciaCallbackHandler();
+ * const model = new ChatOpenAI({ callbacks: [handler] });
+ *
+ * // Just do:
+ * const model = new ChatOpenAI({ callbacks: [getTraciaHandler()] });
+ */
+export declare function getTraciaHandler(): TraciaCallbackHandler;
+/**
+ * Wrap any LangChain model/chain/agent with automatic tracing.
+ *
+ * @example
+ * const model = new ChatOpenAI({ modelName: 'gpt-4' });
+ * const tracedModel = withTracing(model);
+ *
+ * const response = await tracedModel.invoke({ input: 'Hello' });
+ * // Automatically traced!
+ */
+export declare function withTracing<T extends any>(component: T): T;
+/**
+ * Create a traced ChatOpenAI model with one line.
+ *
+ * @example
+ * const model = createTracedOpenAI({ modelName: 'gpt-4' });
+ * const response = await model.invoke({ input: 'Hello' });
+ */
+export declare function createTracedOpenAI(config: any): Promise<any>;
+/**
+ * Create a traced agent executor with one line.
+ *
+ * @example
+ * const executor = createTracedAgentExecutor({
+ *   agent,
+ *   tools,
+ *   agentExecutorOptions: { maxIterations: 10 }
+ * });
+ *
+ * const result = await executor.invoke({ input: 'What time is it?' });
+ */
+export declare function createTracedAgentExecutor(options: {
+    agent: any;
+    tools: any[];
+    agentExecutorOptions?: Record<string, any>;
+}): Promise<any>;
+/**
+ * Create a traced LLMChain with one line.
+ *
+ * @example
+ * const chain = createTracedLLMChain({
+ *   llm: new ChatOpenAI(),
+ *   prompt: chatPrompt
+ * });
+ *
+ * const result = await chain.invoke({ question: 'Hello?' });
+ */
+export declare function createTracedLLMChain(options: {
+    llm: any;
+    prompt: any;
+}): Promise<any>;
+/**
+ * Decorator for methods that should be traced.
+ *
+ * @example
+ * class MyAgent {
+ *   @traced('agent-process')
+ *   async process(input: string) {
+ *     return await this.llm.invoke({ input });
+ *   }
+ * }
+ *
+ * const agent = new MyAgent();
+ * const result = await agent.process('Hello'); // Automatically traced!
+ */
+export declare function traced(spanName: string): (_target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * Simple configuration helper for common LangChain setup patterns.
+ *
+ * @example
+ * const { model, executor } = await setupLangChainWithTracing({
+ *   modelName: 'gpt-4',
+ *   tools: [weatherTool, calculatorTool],
+ *   systemPrompt: 'You are a helpful assistant.'
+ * });
+ *
+ * const result = await executor.invoke({ input: 'What is the weather?' });
+ */
+export declare function setupLangChainWithTracing(options: {
+    modelName?: string;
+    modelConfig?: Record<string, any>;
+    tools?: any[];
+    systemPrompt?: string;
+}): Promise<{
+    model: any;
+    executor: any;
+    handler: TraciaCallbackHandler;
+}>;
+//# sourceMappingURL=auto-langchain.d.ts.map

package/dist/integrations/auto-langchain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-langchain.d.ts","sourceRoot":"","sources":["../../src/integrations/auto-langchain.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAO7D;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,IAAI,qBAAqB,CAKxD;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,GAAG,EAAE,SAAS,EAAE,CAAC,GAAG,CAAC,CAkB1D;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAWlE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,yBAAyB,CAAC,OAAO,EAAE;IACvD,KAAK,EAAE,GAAG,CAAC;IACX,KAAK,EAAE,GAAG,EAAE,CAAC;IACb,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC5C,GAAG,OAAO,CAAC,GAAG,CAAC,CAmBf;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE;IAClD,GAAG,EAAE,GAAG,CAAC;IACT,MAAM,EAAE,GAAG,CAAC;CACb,GAAG,OAAO,CAAC,GAAG,CAAC,CAkBf;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,IAEnC,SAAS,GAAG,EACZ,aAAa,MAAM,EACnB,YAAY,kBAAkB,wBA0BjC;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,yBAAyB,CAAC,OAAO,EAAE;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAClC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG,OAAO,CAAC;IACV,KAAK,EAAE,GAAG,CAAC;IACX,QAAQ,EAAE,GAAG,CAAC;IACd,OAAO,EAAE,qBAAqB,CAAC;CAChC,CAAC,CA8DD"}

package/dist/integrations/auto-langchain.js

@@ -0,0 +1,276 @@
+"use strict";
+/**
+ * Automatic LangChain instrumentation - simple one-line setup.
+ *
+ * Instead of manually passing callbacks to every component, use these
+ * convenience functions for automatic instrumentation with zero boilerplate.
+ */
+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.getTraciaHandler = getTraciaHandler;
+exports.withTracing = withTracing;
+exports.createTracedOpenAI = createTracedOpenAI;
+exports.createTracedAgentExecutor = createTracedAgentExecutor;
+exports.createTracedLLMChain = createTracedLLMChain;
+exports.traced = traced;
+exports.setupLangChainWithTracing = setupLangChainWithTracing;
+const langchain_callback_1 = require("./langchain-callback");
+/**
+ * Global handler instance to avoid creating multiple handlers
+ */
+let globalTraciaHandler = null;
+/**
+ * Get or create the global Traccia callback handler.
+ *
+ * @example
+ * // Instead of:
+ * const handler = new TraciaCallbackHandler();
+ * const model = new ChatOpenAI({ callbacks: [handler] });
+ *
+ * // Just do:
+ * const model = new ChatOpenAI({ callbacks: [getTraciaHandler()] });
+ */
+function getTraciaHandler() {
+    if (!globalTraciaHandler) {
+        globalTraciaHandler = new langchain_callback_1.TraciaCallbackHandler();
+    }
+    return globalTraciaHandler;
+}
+/**
+ * Wrap any LangChain model/chain/agent with automatic tracing.
+ *
+ * @example
+ * const model = new ChatOpenAI({ modelName: 'gpt-4' });
+ * const tracedModel = withTracing(model);
+ *
+ * const response = await tracedModel.invoke({ input: 'Hello' });
+ * // Automatically traced!
+ */
+function withTracing(component) {
+    const handler = getTraciaHandler();
+    // For models and chains, add the handler to callbacks
+    if (component && typeof component === 'object') {
+        if ('callbacks' in component) {
+            // If callbacks exist, add our handler
+            const existing = component.callbacks || [];
+            component.callbacks = Array.isArray(existing)
+                ? [...existing, handler]
+                : [existing, handler];
+        }
+        else {
+            // Otherwise create callbacks array
+            component.callbacks = [handler];
+        }
+    }
+    return component;
+}
+/**
+ * Create a traced ChatOpenAI model with one line.
+ *
+ * @example
+ * const model = createTracedOpenAI({ modelName: 'gpt-4' });
+ * const response = await model.invoke({ input: 'Hello' });
+ */
+async function createTracedOpenAI(config) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const langchainOpenai = require('@langchain/openai');
+        const model = new langchainOpenai.ChatOpenAI(config);
+        return withTracing(model);
+    }
+    catch (error) {
+        throw new Error('Failed to create traced ChatOpenAI. Make sure @langchain/openai is installed.');
+    }
+}
+/**
+ * Create a traced agent executor with one line.
+ *
+ * @example
+ * const executor = createTracedAgentExecutor({
+ *   agent,
+ *   tools,
+ *   agentExecutorOptions: { maxIterations: 10 }
+ * });
+ *
+ * const result = await executor.invoke({ input: 'What time is it?' });
+ */
+async function createTracedAgentExecutor(options) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const langchainAgents = require('langchain/agents');
+        const { agent, tools, agentExecutorOptions = {} } = options;
+        const executor = langchainAgents.AgentExecutor.fromAgentAndTools({
+            agent,
+            tools,
+            ...agentExecutorOptions,
+            callbacks: [getTraciaHandler(), ...(agentExecutorOptions.callbacks || [])],
+        });
+        return executor;
+    }
+    catch (error) {
+        throw new Error('Failed to create traced AgentExecutor. Make sure langchain/agents is installed.');
+    }
+}
+/**
+ * Create a traced LLMChain with one line.
+ *
+ * @example
+ * const chain = createTracedLLMChain({
+ *   llm: new ChatOpenAI(),
+ *   prompt: chatPrompt
+ * });
+ *
+ * const result = await chain.invoke({ question: 'Hello?' });
+ */
+async function createTracedLLMChain(options) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const langchainChains = require('langchain/chains');
+        const { llm, prompt } = options;
+        const chain = new langchainChains.LLMChain({
+            llm: withTracing(llm),
+            prompt,
+            callbacks: [getTraciaHandler()],
+        });
+        return chain;
+    }
+    catch (error) {
+        throw new Error('Failed to create traced LLMChain. Make sure langchain/chains is installed.');
+    }
+}
+/**
+ * Decorator for methods that should be traced.
+ *
+ * @example
+ * class MyAgent {
+ *   @traced('agent-process')
+ *   async process(input: string) {
+ *     return await this.llm.invoke({ input });
+ *   }
+ * }
+ *
+ * const agent = new MyAgent();
+ * const result = await agent.process('Hello'); // Automatically traced!
+ */
+function traced(spanName) {
+    return function (_target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            const { getTracer } = await Promise.resolve().then(() => __importStar(require('../auto')));
+            const tracer = getTracer('decorated-method');
+            return tracer.startActiveSpan(spanName, async (span) => {
+                try {
+                    span.setAttribute('method', propertyKey);
+                    span.setAttribute('args_count', args.length);
+                    const result = await originalMethod.apply(this, args);
+                    span.setAttribute('success', true);
+                    return result;
+                }
+                catch (error) {
+                    if (error instanceof Error) {
+                        span.recordException(error);
+                    }
+                    throw error;
+                }
+            });
+        };
+        return descriptor;
+    };
+}
+/**
+ * Simple configuration helper for common LangChain setup patterns.
+ *
+ * @example
+ * const { model, executor } = await setupLangChainWithTracing({
+ *   modelName: 'gpt-4',
+ *   tools: [weatherTool, calculatorTool],
+ *   systemPrompt: 'You are a helpful assistant.'
+ * });
+ *
+ * const result = await executor.invoke({ input: 'What is the weather?' });
+ */
+async function setupLangChainWithTracing(options) {
+    try {
+        const { modelName = 'gpt-4', modelConfig = {}, tools = [], systemPrompt, } = options;
+        // Create traced model
+        const model = await createTracedOpenAI({
+            modelName,
+            ...modelConfig,
+        });
+        // Create agent if tools provided
+        let executor = null;
+        if (tools.length > 0) {
+            try {
+                // Try to create agent with tools
+                const langchainAgents = require('langchain/agents');
+                const langchainCore = require('@langchain/core/prompts');
+                // Create prompt
+                const prompt = langchainCore.ChatPromptTemplate.fromMessages([
+                    ...(systemPrompt
+                        ? [['system', systemPrompt]]
+                        : [['system', 'You are a helpful assistant.']]),
+                    ['human', '{input}'],
+                    new langchainCore.MessagesPlaceholder('agent_scratchpad'),
+                ]);
+                // Create agent
+                const agent = await langchainAgents.createOpenAIToolsAgent({
+                    llmWithTools: model,
+                    tools,
+                    prompt,
+                    callbacks: [getTraciaHandler()],
+                });
+                // Create executor
+                executor = await createTracedAgentExecutor({
+                    agent,
+                    tools,
+                });
+            }
+            catch (error) {
+                // If agent creation fails, just return model without executor
+                console.warn('Could not create agent executor:', error.message);
+            }
+        }
+        return {
+            model,
+            executor,
+            handler: getTraciaHandler(),
+        };
+    }
+    catch (error) {
+        const err = error;
+        throw new Error(`Failed to setup LangChain with tracing: ${err.message}`);
+    }
+}
+//# sourceMappingURL=auto-langchain.js.map

package/dist/integrations/auto-langchain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-langchain.js","sourceRoot":"","sources":["../../src/integrations/auto-langchain.ts"],"names":[],"mappings":"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"}