langwatch 0.1.7 → 0.3.0-prerelease.1

package/examples/mastra/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "mastra-sdk-example",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "tsc && dotenv -- node dist/index.js",
+    "cli": "tsc && dotenv -- node dist/index.js",
+    "build": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "LangWatch",
+  "type": "module",
+  "license": "MIT",
+  "dependencies": {
+    "@ai-sdk/openai": "^1.3.23",
+    "@mastra/core": "^0.12.1",
+    "@mastra/libsql": "^0.12.0",
+    "@mastra/loggers": "^0.10.5",
+    "@mastra/memory": "^0.12.0",
+    "@opentelemetry/context-async-hooks": "^2.0.1",
+    "@opentelemetry/sdk-node": "^0.203.0",
+    "ai": "^5.0.0",
+    "cli-markdown": "^3.5.1",
+    "dotenv-cli": "^10.0.0",
+    "langwatch": "file:../../"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.2"
+  }
+}

package/examples/mastra/src/cli-markdown.d.ts

@@ -0,0 +1,137 @@
+declare module 'cli-markdown' {
+  export interface CliMarkdownOptions {
+    /**
+     * Custom styles for different markdown elements
+     */
+    styles?: {
+      /**
+       * Style for headings (h1, h2, h3, etc.)
+       */
+      heading?: string;
+      /**
+       * Style for bold text
+       */
+      bold?: string;
+      /**
+       * Style for italic text
+       */
+      italic?: string;
+      /**
+       * Style for code blocks
+       */
+      code?: string;
+      /**
+       * Style for inline code
+       */
+      inlineCode?: string;
+      /**
+       * Style for links
+       */
+      link?: string;
+      /**
+       * Style for lists
+       */
+      list?: string;
+      /**
+       * Style for blockquotes
+       */
+      blockquote?: string;
+      /**
+       * Style for horizontal rules
+       */
+      hr?: string;
+    };
+    /**
+     * Whether to preserve line breaks
+     */
+    preserveLineBreaks?: boolean;
+    /**
+     * Custom renderer functions for different markdown elements
+     */
+    renderers?: {
+      /**
+       * Custom renderer for headings
+       */
+      heading?: (text: string, level: number) => string;
+      /**
+       * Custom renderer for paragraphs
+       */
+      paragraph?: (text: string) => string;
+      /**
+       * Custom renderer for lists
+       */
+      list?: (items: string[], ordered: boolean) => string;
+      /**
+       * Custom renderer for list items
+       */
+      listItem?: (text: string, index: number) => string;
+      /**
+       * Custom renderer for code blocks
+       */
+      code?: (code: string, language?: string) => string;
+      /**
+       * Custom renderer for inline code
+       */
+      inlineCode?: (code: string) => string;
+      /**
+       * Custom renderer for links
+       */
+      link?: (text: string, url: string) => string;
+      /**
+       * Custom renderer for images
+       */
+      image?: (alt: string, url: string) => string;
+      /**
+       * Custom renderer for blockquotes
+       */
+      blockquote?: (text: string) => string;
+      /**
+       * Custom renderer for horizontal rules
+       */
+      hr?: () => string;
+      /**
+       * Custom renderer for emphasis (bold/italic)
+       */
+      emphasis?: (text: string, type: 'bold' | 'italic') => string;
+    };
+    /**
+     * Maximum width for text wrapping
+     */
+    maxWidth?: number;
+    /**
+     * Whether to enable ANSI color codes
+     */
+    colors?: boolean;
+    /**
+     * Custom color theme
+     */
+    theme?: {
+      /**
+       * Color for headings
+       */
+      heading?: string;
+      /**
+       * Color for links
+       */
+      link?: string;
+      /**
+       * Color for code
+       */
+      code?: string;
+      /**
+       * Color for blockquotes
+       */
+      blockquote?: string;
+    };
+  }
+
+  /**
+   * Converts markdown text to formatted CLI output
+   * @param markdown - The markdown text to convert
+   * @param options - Configuration options for the conversion
+   * @returns Formatted CLI text
+   */
+  function cliMarkdown(markdown: string, options?: CliMarkdownOptions): string;
+
+  export = cliMarkdown;
+}

package/examples/mastra/src/index.ts

@@ -0,0 +1,120 @@
+import { setupLangWatch } from "langwatch/node";
+import { getLangWatchTracer } from "langwatch";
+import { semconv } from "langwatch/observability";
+import * as readline from "readline";
+import cliMarkdown from "cli-markdown";
+import { mastra } from "./mastra/index.js";
+
+await setupLangWatch();
+
+const tracer = getLangWatchTracer("mastra-weather-agent-example");
+
+async function main() {
+  const threadId = crypto.randomUUID();
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log('🌤️  Weather Agent Chatbot started! Type "quit" to exit.');
+  console.log("Ask me about weather for any location and I'll help you plan activities!");
+  console.log("---");
+
+  const conversationHistory: Array<{
+    role: "user" | "assistant" | "system";
+    content: string;
+  }> = [
+    {
+      role: "system",
+      content:
+        "You are a helpful weather assistant that provides accurate weather information and can help planning activities based on the weather. You may use markdown to format your responses.",
+    },
+  ];
+
+  while (true) {
+    let finish = false;
+
+    await tracer.withActiveSpan("iteration", {
+      attributes: {
+        [semconv.ATTR_LANGWATCH_THREAD_ID]: threadId,
+      },
+    }, async (span) => {
+      try {
+        // Get user input
+        const userInput = await new Promise<string>((resolve) => {
+          rl.question("You: ", resolve);
+        });
+
+        // Check for exit command
+        if (
+          userInput.toLowerCase() === "quit" ||
+          userInput.toLowerCase() === "exit"
+        ) {
+          console.log("👋 Goodbye!");
+          finish = true;
+          return;
+        }
+
+        // Skip empty input
+        if (!userInput.trim()) {
+          return;
+        }
+
+        // Add user message to conversation history
+        conversationHistory.push({ role: "user", content: userInput });
+
+        // Set input string for tracing
+        span.setInputString(userInput);
+
+        // Generate AI response using Mastra agent
+        console.log("🌤️  Checking weather and planning activities...");
+
+        const agent = mastra.getAgent("weatherAgent");
+        if (!agent) {
+          throw new Error("Weather agent not found");
+        }
+
+        const response = await agent.generate([
+          {
+            role: "user",
+            content: userInput,
+          },
+        ]);
+
+        // Add AI response to conversation history
+        conversationHistory.push({ role: "assistant", content: response.text });
+
+        // Set output string for tracing
+        span.setOutputString(response.text);
+
+        // Display AI response with markdown formatting
+        console.log("\nAI:");
+        console.log(
+          `${cliMarkdown(response.text, {
+            colors: true,
+            maxWidth: 80,
+            theme: {
+              heading: "cyan",
+              link: "blue",
+              code: "green",
+              blockquote: "yellow",
+            },
+          })}---`,
+        );
+      } catch (error) {
+        console.error("❌ Error:", error);
+        console.log("Please try again.");
+      }
+    });
+
+    if (finish) {
+      break;
+    }
+  }
+
+  rl.close();
+}
+
+// Run the chatbot
+main().catch(console.error);

package/examples/mastra/src/mastra/agents/weather-agent.ts

@@ -0,0 +1,30 @@
+import { openai } from '@ai-sdk/openai';
+import { Agent } from '@mastra/core/agent';
+import { Memory } from '@mastra/memory';
+import { LibSQLStore } from '@mastra/libsql';
+import { weatherTool } from '../tools/weather-tool.js';
+
+export const weatherAgent = new Agent({
+  name: 'Weather Agent',
+  instructions: `
+      You are a helpful weather assistant that provides accurate weather information and can help planning activities based on the weather.
+
+      Your primary function is to help users get weather details for specific locations. When responding:
+      - Always ask for a location if none is provided
+      - If the location name isn't in English, please translate it
+      - If giving a location with multiple parts (e.g. "New York, NY"), use the most relevant part (e.g. "New York")
+      - Include relevant details like humidity, wind conditions, and precipitation
+      - Keep responses concise but informative
+      - If the user asks for activities and provides the weather forecast, suggest activities based on the weather forecast.
+      - If the user asks for activities, respond in the format they request.
+
+      Use the weatherTool to fetch current weather data.
+`,
+  model: openai('gpt-4o-mini'),
+  tools: { weatherTool },
+  memory: new Memory({
+    storage: new LibSQLStore({
+      url: 'file:../mastra.db', // path is relative to the .mastra/output directory
+    }),
+  }),
+});

package/examples/mastra/src/mastra/index.ts

@@ -0,0 +1,21 @@
+
+import { Mastra } from '@mastra/core/mastra';
+import { PinoLogger } from '@mastra/loggers';
+import { LibSQLStore } from '@mastra/libsql';
+import { weatherAgent } from './agents/weather-agent.js';
+
+export const mastra = new Mastra({
+  agents: { weatherAgent },
+  storage: new LibSQLStore({
+    // stores telemetry, evals, ... into memory storage, if it needs to persist, change to file:../mastra.db
+    url: ":memory:",
+  }),
+  logger: new PinoLogger({
+    name: 'Mastra',
+    level: 'info',
+  }),
+  telemetry: {
+    enabled: true,
+    serviceName: "mastra-and-vercel-ai-sdk-example",
+  },
+});

package/examples/mastra/src/mastra/tools/weather-tool.ts

@@ -0,0 +1,102 @@
+import { createTool } from '@mastra/core/tools';
+import { z } from 'zod';
+
+interface GeocodingResponse {
+  results: {
+    latitude: number;
+    longitude: number;
+    name: string;
+  }[];
+}
+interface WeatherResponse {
+  current: {
+    time: string;
+    temperature_2m: number;
+    apparent_temperature: number;
+    relative_humidity_2m: number;
+    wind_speed_10m: number;
+    wind_gusts_10m: number;
+    weather_code: number;
+  };
+}
+
+export const weatherTool = createTool({
+  id: 'get-weather',
+  description: 'Get current weather for a location',
+  inputSchema: z.object({
+    location: z.string().describe('City name'),
+  }),
+  outputSchema: z.object({
+    temperature: z.number(),
+    feelsLike: z.number(),
+    humidity: z.number(),
+    windSpeed: z.number(),
+    windGust: z.number(),
+    conditions: z.string(),
+    location: z.string(),
+  }),
+  execute: async ({ context }: { context: { location: string } }) => {
+    return await getWeather(context.location);
+  },
+});
+
+const getWeather = async (location: string) => {
+  const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(location)}&count=1`;
+  const geocodingResponse = await fetch(geocodingUrl);
+  const geocodingData = (await geocodingResponse.json()) as GeocodingResponse;
+
+  if (!geocodingData.results?.[0]) {
+    throw new Error(`Location '${location}' not found`);
+  }
+
+  const { latitude, longitude, name } = geocodingData.results[0];
+
+  const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=temperature_2m,apparent_temperature,relative_humidity_2m,wind_speed_10m,wind_gusts_10m,weather_code`;
+
+  const response = await fetch(weatherUrl);
+  const data = (await response.json()) as WeatherResponse;
+
+  return {
+    temperature: data.current.temperature_2m,
+    feelsLike: data.current.apparent_temperature,
+    humidity: data.current.relative_humidity_2m,
+    windSpeed: data.current.wind_speed_10m,
+    windGust: data.current.wind_gusts_10m,
+    conditions: getWeatherCondition(data.current.weather_code),
+    location: name,
+  };
+};
+
+function getWeatherCondition(code: number): string {
+  const conditions: Record<number, string> = {
+    0: 'Clear sky',
+    1: 'Mainly clear',
+    2: 'Partly cloudy',
+    3: 'Overcast',
+    45: 'Foggy',
+    48: 'Depositing rime fog',
+    51: 'Light drizzle',
+    53: 'Moderate drizzle',
+    55: 'Dense drizzle',
+    56: 'Light freezing drizzle',
+    57: 'Dense freezing drizzle',
+    61: 'Slight rain',
+    63: 'Moderate rain',
+    65: 'Heavy rain',
+    66: 'Light freezing rain',
+    67: 'Heavy freezing rain',
+    71: 'Slight snow fall',
+    73: 'Moderate snow fall',
+    75: 'Heavy snow fall',
+    77: 'Snow grains',
+    80: 'Slight rain showers',
+    81: 'Moderate rain showers',
+    82: 'Violent rain showers',
+    85: 'Slight snow showers',
+    86: 'Heavy snow showers',
+    95: 'Thunderstorm',
+    96: 'Thunderstorm with slight hail',
+    99: 'Thunderstorm with heavy hail',
+  };
+  return conditions[code] || 'Unknown';
+}

package/examples/mastra/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "Bundler",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/examples/vercel-ai/.env.example

@@ -0,0 +1,2 @@
+LANGWATCH_API_KEY=""
+OPENAI_API_KEY=""

package/examples/vercel-ai/README.md

@@ -0,0 +1,38 @@
+# Vercel AI Examples
+
+This directory contains examples of AI apps built with the LangWatch SDK and Vercel AI.
+
+## Example
+
+### Basic Chatbot (`src/index.ts`)
+
+A simple chatbot that handles basic conversation flow:
+
+- **Features:**
+  - Basic conversation loop
+  - User input handling
+  - AI response generation
+  - Conversation history management
+  - Error handling
+  - Exit commands (`quit`, `exit`)
+
+- **Usage:**
+  ```bash
+  npm run start
+  ```
+
+## Troubleshooting
+
+### Common Issues:
+
+1. **"Cannot find module 'langwatch/node'"**
+   - Make sure you've built the LangWatch SDK
+   - Check that the package is properly built
+
+2. **OpenAI API errors**
+   - Verify your API key is set correctly
+   - Check your OpenAI account has sufficient credits
+
+3. **TypeScript compilation errors**
+   - Run `npm run start` to check for type errors
+   - Ensure all dependencies are installed