@revenium/litellm 0.0.1

package/examples/litellm-streaming.ts

@@ -0,0 +1,309 @@
+/**
+ * LiteLLM Streaming Example
+ *
+ * This example demonstrates streaming responses and advanced features with metadata tracking.
+ * Shows streaming chat completions, multi-provider support, and advanced metadata usage.
+ */
+
+// Load environment variables from .env file
+import "dotenv/config";
+
+// Step 1: Import the middleware (this enables automatic tracking)
+import "@revenium/litellm";
+
+async function streamingExample() {
+  console.log("Starting streaming Revenium LiteLLM middleware example...\n");
+
+  // Check environment variables
+  const requiredVars = ["REVENIUM_METERING_API_KEY", "LITELLM_PROXY_URL"];
+  const missing = requiredVars.filter((key) => !process.env[key]);
+
+  if (missing.length > 0) {
+    console.error("❌ Missing required environment variables:");
+    missing.forEach((key) => console.error(`   ${key}`));
+    console.error("\nPlease set them in a .env file in the project root.");
+    process.exit(1);
+  }
+
+  const proxyUrl = process.env.LITELLM_PROXY_URL!;
+  const apiKey = process.env.LITELLM_API_KEY || "sk-1234";
+
+  // Handle proxy URL - remove endpoint if already included
+  const baseProxyUrl = proxyUrl.replace(
+    /\/(chat\/completions|embeddings)$/,
+    ""
+  );
+
+  // Debug: Show loaded configuration (partially obfuscated)
+  console.log("Configuration loaded:");
+  console.log(
+    `   Revenium API Key: ${process.env.REVENIUM_METERING_API_KEY?.substring(
+      0,
+      8
+    )}...${process.env.REVENIUM_METERING_API_KEY?.slice(-4)}`
+  );
+  console.log(
+    `   Revenium Base URL: ${process.env.REVENIUM_METERING_BASE_URL}`
+  );
+  console.log(`   LiteLLM Proxy URL: ${proxyUrl}`);
+  console.log(`   Base Proxy URL: ${baseProxyUrl}`);
+  console.log(
+    `   LiteLLM API Key: ${apiKey.substring(0, 8)}...${apiKey.slice(-4)}\n`
+  );
+
+  let successCount = 0;
+  let totalRequests = 3;
+
+  try {
+    // Example 1: Basic streaming with metadata
+    console.log("Example 1: Basic streaming response with metadata...");
+
+    const streamResponse = await fetch(`${baseProxyUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+        // Custom metadata for this streaming request
+        "x-revenium-subscriber-id": "artist-456",
+        "x-revenium-subscriber-email": "artist@creative-ai-inc.com",
+        "x-revenium-subscriber-credential-name": "creative-api-key",
+        "x-revenium-subscriber-credential": "creative-credential-value",
+        "x-revenium-organization-id": "creative-ai-inc",
+        "x-revenium-product-id": "story-generator",
+        "x-revenium-task-type": "creative-writing",
+        "x-revenium-agent": "litellm-node-streaming",
+      },
+      body: JSON.stringify({
+        model: "openai/gpt-4o-mini",
+        max_tokens: 150,
+        messages: [
+          {
+            role: "user",
+            content: "Tell me a short story about a robot learning to paint.",
+          },
+        ],
+        stream: true,
+      }),
+    });
+
+    if (streamResponse.ok && streamResponse.body) {
+      console.log("Streaming response:");
+
+      const reader = streamResponse.body.getReader();
+      const decoder = new TextDecoder();
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        const chunk = decoder.decode(value);
+        const lines = chunk.split("\n").filter((line) => line.trim());
+
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6);
+            if (data === "[DONE]") continue;
+
+            try {
+              const parsed = JSON.parse(data);
+              const content = parsed.choices?.[0]?.delta?.content;
+              if (content) {
+                process.stdout.write(content);
+              }
+            } catch (e) {
+              // Ignore parsing errors for malformed chunks
+            }
+          }
+        }
+      }
+
+      console.log("\n   ✅ Stream completed and automatically tracked!\n");
+      successCount++;
+    } else {
+      console.log(
+        "❌ Streaming request failed:",
+        streamResponse.status,
+        streamResponse.statusText
+      );
+    }
+
+    // Example 2: Multi-provider streaming
+    console.log(
+      "Example 2: Multi-provider streaming with different metadata..."
+    );
+
+    const anthropicStreamResponse = await fetch(
+      `${baseProxyUrl}/chat/completions`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+          // Metadata for research provider
+          "x-revenium-subscriber-id": "researcher-789",
+          "x-revenium-subscriber-email": "researcher@research-users.com",
+          "x-revenium-subscriber-credential-name": "research-api-key",
+          "x-revenium-subscriber-credential": "research-credential-value",
+          "x-revenium-organization-id": "research-users",
+          "x-revenium-product-id": "research-assistant",
+          "x-revenium-task-type": "research-query",
+          "x-revenium-agent": "litellm-node-streaming-multi",
+        },
+        body: JSON.stringify({
+          model: "openai/gpt-4o-mini",
+          max_tokens: 100,
+          messages: [
+            {
+              role: "user",
+              content: "What are three benefits of renewable energy?",
+            },
+          ],
+          stream: true,
+        }),
+      }
+    );
+
+    if (anthropicStreamResponse.ok && anthropicStreamResponse.body) {
+      console.log("Research streaming response:");
+
+      const reader = anthropicStreamResponse.body.getReader();
+      const decoder = new TextDecoder();
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        const chunk = decoder.decode(value);
+        const lines = chunk.split("\n").filter((line) => line.trim());
+
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6);
+            if (data === "[DONE]") continue;
+
+            try {
+              const parsed = JSON.parse(data);
+              const content = parsed.choices?.[0]?.delta?.content;
+              if (content) {
+                process.stdout.write(content);
+              }
+            } catch (e) {
+              // Ignore parsing errors
+            }
+          }
+        }
+      }
+
+      console.log(
+        "\n   ✅ Research stream completed and automatically tracked!\n"
+      );
+      successCount++;
+    } else {
+      console.log(
+        "❌ Research streaming request failed:",
+        anthropicStreamResponse.status,
+        anthropicStreamResponse.statusText
+      );
+    }
+
+    // Example 3: Advanced metadata with embeddings
+    console.log(
+      "Example 3: Advanced embeddings with comprehensive metadata..."
+    );
+
+    const advancedEmbeddingResponse = await fetch(
+      `${baseProxyUrl}/embeddings`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+          // Comprehensive metadata for embeddings
+          "x-revenium-subscriber-id": "search-user-101",
+          "x-revenium-subscriber-email": "user@search-company.com",
+          "x-revenium-subscriber-credential-name": "search-api-key",
+          "x-revenium-subscriber-credential": "search-credential-value",
+          "x-revenium-organization-id": "search-company",
+          "x-revenium-product-id": "semantic-search-engine",
+          "x-revenium-task-type": "document-indexing",
+          "x-revenium-agent": "litellm-node-streaming-embeddings",
+          "x-revenium-trace-id": "batch-embedding-session-456",
+        },
+        body: JSON.stringify({
+          model: "text-embedding-ada-002",
+          input: [
+            "Advanced machine learning techniques for natural language processing",
+            "Deep learning architectures for computer vision applications",
+            "Reinforcement learning algorithms for autonomous systems",
+          ],
+        }),
+      }
+    );
+
+    if (advancedEmbeddingResponse.ok) {
+      const embeddingData = await advancedEmbeddingResponse.json();
+      console.log(
+        "Advanced embedding response: Multiple vectors generated successfully"
+      );
+      console.log(`   Vectors: ${embeddingData.data?.length || 0}`);
+      console.log(
+        `   Dimensions: ${
+          embeddingData.data?.[0]?.embedding?.length || "Unknown"
+        }`
+      );
+      console.log(`   Tokens: ${embeddingData.usage?.prompt_tokens} input\n`);
+      successCount++;
+    } else {
+      console.log(
+        "❌ Advanced embedding request failed:",
+        advancedEmbeddingResponse.status,
+        advancedEmbeddingResponse.statusText
+      );
+    }
+
+    // Report results
+    console.log(
+      `\nResults: ${successCount}/${totalRequests} requests successful`
+    );
+
+    if (successCount === totalRequests) {
+      console.log(
+        "✅ All streaming requests successful and automatically tracked to Revenium!"
+      );
+      console.log(
+        "Check your Revenium dashboard to see the detailed analytics"
+      );
+    } else if (successCount > 0) {
+      console.log(
+        "⚠️  Some streaming requests successful and tracked to Revenium."
+      );
+      console.log("Check your Revenium dashboard to see the tracked usage.");
+    } else {
+      console.log(
+        "❌ No requests were successful. Check your LiteLLM Proxy configuration."
+      );
+      console.log(
+        "Ensure your LiteLLM Proxy is running and accessible at:",
+        proxyUrl
+      );
+    }
+  } catch (error) {
+    console.error("❌ Error in streaming example:", error);
+    throw error;
+  }
+}
+
+// Run the example
+if (require.main === module) {
+  streamingExample()
+    .then(() => {
+      console.log("\nStreaming example completed successfully!");
+      console.log(
+        "Enable REVENIUM_DEBUG=true to see detailed request tracking logs"
+      );
+    })
+    .catch((error) => {
+      console.error("\nStreaming example failed:", error);
+      process.exit(1);
+    });
+}

package/examples/prompt-capture.ts

@@ -0,0 +1,128 @@
+import { configure, UsageMetadata } from "../src/index.js";
+
+async function main() {
+  console.log("=== LiteLLM Prompt Capture Example ===\n");
+
+  // Configure the middleware with prompt capture enabled
+  configure({
+    reveniumMeteringApiKey: process.env.REVENIUM_METERING_API_KEY || "test-key",
+    reveniumMeteringBaseUrl:
+      process.env.REVENIUM_METERING_BASE_URL || "https://api.revenium.ai",
+    litellmProxyUrl: process.env.LITELLM_PROXY_URL || "http://localhost:4000",
+    litellmApiKey: process.env.LITELLM_API_KEY,
+    capturePrompts: true,
+  });
+
+  console.log("Example 1: Prompt capture enabled via config");
+  console.log("Making request with prompt capture enabled...\n");
+
+  try {
+    const metadata: UsageMetadata = {
+      organizationId: "org-prompt-capture-demo",
+      productId: "prod-litellm-prompt-capture",
+    };
+
+    const response = await fetch(
+      `${
+        process.env.LITELLM_PROXY_URL || "http://localhost:4000"
+      }/chat/completions`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${process.env.LITELLM_API_KEY || ""}`,
+          "X-Revenium-Organization-Id": metadata.organizationId || "",
+          "X-Revenium-Product-Id": metadata.productId || "",
+        },
+        body: JSON.stringify({
+          model: "gpt-4o-mini",
+          messages: [
+            {
+              role: "system",
+              content:
+                "You are a helpful assistant that provides concise answers.",
+            },
+            {
+              role: "user",
+              content: "What is the capital of France?",
+            },
+          ],
+          max_tokens: 100,
+        }),
+      }
+    );
+
+    const data = await response.json();
+    console.log("Response:", data.choices?.[0]?.message?.content);
+    console.log("\nPrompts captured and sent to Revenium API!");
+  } catch (error) {
+    console.error(
+      "Error:",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+
+  console.log("\n" + "=".repeat(50) + "\n");
+  console.log("Example 2: Prompt capture disabled via metadata override");
+  console.log("Making request with prompt capture disabled...\n");
+
+  try {
+    const metadata2: UsageMetadata = {
+      organizationId: "org-prompt-capture-demo",
+      productId: "prod-litellm-prompt-capture",
+      capturePrompts: false,
+    };
+
+    const response2 = await fetch(
+      `${
+        process.env.LITELLM_PROXY_URL || "http://localhost:4000"
+      }/chat/completions`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${process.env.LITELLM_API_KEY || ""}`,
+          "X-Revenium-Organization-Id": metadata2.organizationId || "",
+          "X-Revenium-Product-Id": metadata2.productId || "",
+          "X-Revenium-Capture-Prompts": "false",
+        },
+        body: JSON.stringify({
+          model: "gpt-4o-mini",
+          messages: [
+            {
+              role: "system",
+              content: "You are a helpful assistant.",
+            },
+            {
+              role: "user",
+              content: "What is 2+2?",
+            },
+          ],
+          max_tokens: 100,
+        }),
+      }
+    );
+
+    const data2 = await response2.json();
+    console.log("Response:", data2.choices?.[0]?.message?.content);
+    console.log("\nPrompts NOT captured (overridden via metadata)!");
+  } catch (error) {
+    console.error(
+      "Error:",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+
+  console.log("\n" + "=".repeat(50) + "\n");
+  console.log("Example 3: Prompt capture with environment variable");
+  console.log("Set REVENIUM_CAPTURE_PROMPTS=true in your .env file\n");
+
+  console.log("✅ Prompt capture examples completed!");
+  console.log("\nConfiguration hierarchy:");
+  console.log("1. Per-call metadata (highest priority)");
+  console.log("2. Global config");
+  console.log("3. Environment variable REVENIUM_CAPTURE_PROMPTS");
+  console.log("4. Default: false (lowest priority)");
+}
+
+main().catch(console.error);

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@revenium/litellm",
+  "version": "0.0.1",
+  "description": "Comprehensive middleware for Node.js applications using LiteLLM Proxy to automatically track LLM usage, costs, and performance metrics with Revenium",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run build",
+    "test": "jest",
+    "test:unit": "jest --testPathPatterns=tests/unit",
+    "test:integration": "jest --testPathPatterns=tests/integration --passWithNoTests",
+    "test:performance": "jest --testPathPatterns=tests/performance --passWithNoTests",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:e2e": "npm run build && tsx tests/integration/09-trace-fields-integration.ts",
+    "test:basic": "REVENIUM_DEBUG=true npx tsx tests/integration/01-basic-connectivity.ts",
+    "test:proxy": "REVENIUM_DEBUG=true npx tsx tests/integration/02-proxy-requests.ts",
+    "test:metadata": "REVENIUM_DEBUG=true npx tsx tests/integration/03-metadata-tracking.ts",
+    "test:providers": "REVENIUM_DEBUG=true npx tsx tests/integration/04-multi-provider.ts",
+    "test:streaming": "REVENIUM_DEBUG=true npx tsx tests/integration/05-streaming.ts",
+    "test:embeddings": "REVENIUM_DEBUG=true npx tsx tests/integration/06-embeddings.ts",
+    "test:model-source": "REVENIUM_DEBUG=true npx tsx tests/integration/07-model-source-test.ts",
+    "test:all-integration": "npm run test:basic && npm run test:proxy && npm run test:metadata && npm run test:providers && npm run test:streaming && npm run test:embeddings && npm run test:model-source"
+  },
+  "keywords": [
+    "revenium",
+    "litellm",
+    "llm",
+    "ai",
+    "middleware",
+    "tracking",
+    "analytics",
+    "openai",
+    "anthropic",
+    "streaming",
+    "usage",
+    "metrics",
+    "monitoring"
+  ],
+  "author": "Revenium Inc.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/revenium/revenium-middleware-litellm-node.git"
+  },
+  "bugs": {
+    "url": "https://github.com/revenium/revenium-middleware-litellm-node/issues"
+  },
+  "homepage": "https://github.com/revenium/revenium-middleware-litellm-node#readme",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.map",
+    "examples/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^20.0.0",
+    "@types/node-fetch": "^2.6.4",
+    "dotenv": "^16.0.0",
+    "jest": "^30.2.0",
+    "node-fetch": "^2.6.7",
+    "ts-jest": "^29.4.6",
+    "ts-node": "^10.9.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "node-fetch": "^2.6.0 || ^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "node-fetch": {
+      "optional": true
+    }
+  }
+}