📦 NEW: add tracing support

Author: saqibameen

examples/nodejs/workflows/workflows.ts

@@ -1,40 +1,85 @@
-// Experimental upcoming beta AI primitve.
-// Please refer to the documentation for more information: https://langbase.com/docs for more information.
-
+// Test script for the simplified proxy approach
 import 'dotenv/config';
-import {Langbase, Workflow} from 'langbase';
+import {Langbase} from 'langbase';
 
+// Create Langbase instance
 const langbase = new Langbase({
 	apiKey: process.env.LANGBASE_API_KEY!,
 });
 
 async function main() {
-	const {step} = new Workflow({debug: true});
-
-	const result = await step({
-		id: 'sumamrize',
-		run: async () => {
-			return langbase.llm.run({
-				model: 'openai:gpt-4o-mini',
-				apiKey: process.env.OPENAI_API_KEY!,
-				messages: [
-					{
-						role: 'system',
-						content:
-							'You are an expert summarizer. Summarize the user input.',
-					},
-					{
-						role: 'user',
-						content:
-							'I am testing workflows. I just created an example of summarize workflow. Can you summarize this?',
-					},
-				],
-				stream: false,
-			});
-		},
+	// Create a workflow with debug mode enabled
+	const workflow = langbase.workflow({
+		name: 'simplified-proxy-test',
+		debug: true, // Enable debug logging
 	});
 
-	console.log(result['completion']);
+	try {
+		// STEP 1: Call langbase.agent.run but don't return its result directly
+		const step1Result = await workflow.step({
+			id: 'call-but-return-custom',
+			run: async () => {
+				// Return custom result instead
+				return {
+					customField: 'Custom result from simplified proxy',
+					timestamp: new Date().toISOString(),
+				};
+			},
+		});
+
+		// STEP 2: Return agent.run result directly
+		const step2Result = await workflow.step({
+			id: 'return-agent-run-directly',
+			run: async () => {
+				// Call Langbase API and return the result directly
+				return langbase.agent.run({
+					model: 'openai:gpt-4o-mini',
+					apiKey: process.env.OPENAI_API_KEY!,
+					instructions: 'Be brief and concise.',
+					input: 'What is 2+2?',
+					stream: false,
+				});
+			},
+		});
+
+		// STEP 3: Make multiple Langbase calls in one step
+		const step3Result = await workflow.step({
+			id: 'multiple-calls',
+			run: async () => {
+				// First call
+				const call1 = await langbase.agent.run({
+					model: 'openai:gpt-4o-mini',
+					apiKey: process.env.OPENAI_API_KEY!,
+					instructions: 'Be brief.',
+					input: 'First proxy test',
+					stream: false,
+				});
+
+				// Second call with different method
+				const call2 = await langbase.agent.run({
+					model: 'openai:gpt-4o-mini',
+					apiKey: process.env.OPENAI_API_KEY!,
+					instructions: 'Be brief.',
+					input: 'Second proxy test',
+					stream: false,
+				});
+
+				// Return combined result
+				return {
+					summary: 'Multiple calls completed with simplified proxy',
+					calls: 2,
+					firstOutput: call1.output,
+					secondOutput: call2.output,
+				};
+			},
+		});
+	} catch (error) {
+		console.error('❌ Workflow error:', error);
+	} finally {
+		// End the workflow to show trace report
+		workflow.end();
+	}
 }
 
-main();
+// Run the test
+main().catch(console.error);

packages/langbase/src/langbase/langbase.ts

@@ -1,5 +1,6 @@
 import {convertDocToFormData} from '@/lib/utils/doc-to-formdata';
 import {Request} from '../common/request';
+import {Workflow} from './workflows';
 
 export type Role = 'user' | 'assistant' | 'system' | 'tool';
 
@@ -602,6 +603,8 @@ export class Langbase {
 		};
 	};
 
+	public workflow: (config: {debug?: boolean; name: string}) => Workflow;
+
 	constructor(options?: LangbaseOptions) {
 		this.baseUrl = options?.baseUrl ?? 'https://api.langbase.com';
 		this.apiKey = options?.apiKey ?? '';
@@ -684,6 +687,8 @@ export class Langbase {
 		this.agent = {
 			run: this.runAgent.bind(this),
 		};
+
+		this.workflow = (config) => new Workflow({...config, langbase: this});
 	}
 
 	private async runPipe(

packages/langbase/src/langbase/trace.ts

@@ -0,0 +1,79 @@
+export interface Trace {
+	name: string;
+	startTime: number;
+	endTime?: number;
+	steps: StepTrace[];
+}
+
+export interface StepTrace {
+	name: string;
+	output: any;
+	traces: string[] | null;
+	duration: number;
+	startTime: number;
+	endTime: number;
+}
+
+export class TraceManager {
+	private traces: Map<string, Trace> = new Map();
+
+	createTrace(name: string): string {
+		const traceId = `trace_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+		this.traces.set(traceId, {
+			name,
+			startTime: Date.now(),
+			steps: [],
+		});
+		return traceId;
+	}
+
+	addStep(traceId: string, step: StepTrace) {
+		const trace = this.traces.get(traceId);
+		if (trace) {
+			trace.steps.push(step);
+		}
+	}
+
+	endTrace(traceId: string) {
+		const trace = this.traces.get(traceId);
+		if (trace) {
+			trace.endTime = Date.now();
+		}
+	}
+
+	getTrace(traceId: string): Trace | undefined {
+		return this.traces.get(traceId);
+	}
+
+	printTrace(traceId: string) {
+		const trace = this.traces.get(traceId);
+		if (trace) {
+			const duration = trace.endTime
+				? trace.endTime - trace.startTime
+				: Date.now() - trace.startTime;
+			console.log('\n📊 Workflow Trace:');
+			console.log(`Name: ${trace.name}`);
+			console.log(`Duration: ${duration}ms`);
+			console.log(
+				`Start Time: ${new Date(trace.startTime).toISOString()}`,
+			);
+			if (trace.endTime) {
+				console.log(
+					`End Time: ${new Date(trace.endTime).toISOString()}`,
+				);
+			}
+			console.log('\nSteps:');
+			trace.steps.forEach(step => {
+				console.log(`\n  Step: ${step.name}`);
+				console.log(`  Duration: ${step.duration}ms`);
+
+				// Make sure to check for both existence and non-empty array
+				if (step.traces && step.traces.length > 0) {
+					console.log(`  Traces:`, step.traces);
+				}
+
+				console.log(`  Output:`, step.output);
+			});
+		}
+	}
+}