@usetransactional/llm-node 0.1.0

package/dist/integrations/vercel-ai.js

@@ -0,0 +1,419 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/integrations/vercel-ai.ts
+var vercel_ai_exports = {};
+__export(vercel_ai_exports, {
+  getLlmOps: () => getLlmOps,
+  initLlmOps: () => initLlmOps,
+  wrapAiSdk: () => wrapAiSdk,
+  wrapStreamText: () => wrapStreamText
+});
+module.exports = __toCommonJS(vercel_ai_exports);
+
+// src/client.ts
+var import_nanoid = require("nanoid");
+var currentTraceId;
+var currentObservationId;
+function setTraceContext(traceId, observationId) {
+  currentTraceId = traceId;
+  currentObservationId = observationId;
+}
+function getTraceContext() {
+  return { traceId: currentTraceId, observationId: currentObservationId };
+}
+function clearTraceContext() {
+  currentTraceId = void 0;
+  currentObservationId = void 0;
+}
+var LlmOpsClient = class {
+  constructor(config) {
+    this.queue = [];
+    this.config = this.parseConfig(config);
+    if (this.config.enabled) {
+      this.startFlushTimer();
+    }
+  }
+  parseConfig(config) {
+    let publicKey = config.publicKey;
+    let projectId = config.projectId;
+    let baseUrl = config.baseUrl || "https://api.transactional.dev";
+    if (config.dsn) {
+      try {
+        const url = new URL(config.dsn);
+        publicKey = url.username;
+        const pathParts = url.pathname.split("/").filter(Boolean);
+        projectId = parseInt(pathParts[pathParts.length - 1] || "0");
+        baseUrl = `${url.protocol}//${url.host}`;
+      } catch {
+        throw new Error(`Invalid DSN format: ${config.dsn}`);
+      }
+    }
+    if (!publicKey || !projectId) {
+      throw new Error("LlmOps requires either a DSN or publicKey + projectId");
+    }
+    return {
+      publicKey,
+      projectId,
+      baseUrl,
+      enabled: config.enabled ?? true,
+      batchSize: config.batchSize ?? 100,
+      flushInterval: config.flushInterval ?? 5e3,
+      debug: config.debug ?? false
+    };
+  }
+  startFlushTimer() {
+    this.flushTimer = setInterval(() => {
+      this.flush().catch((err) => {
+        if (this.config.debug) {
+          console.error("[LlmOps] Flush error:", err);
+        }
+      });
+    }, this.config.flushInterval);
+  }
+  log(message, ...args) {
+    if (this.config.debug) {
+      console.log(`[LlmOps] ${message}`, ...args);
+    }
+  }
+  enqueue(item) {
+    if (!this.config.enabled) return;
+    this.queue.push(item);
+    this.log("Enqueued:", item.type, item.id);
+    if (this.queue.length >= this.config.batchSize) {
+      this.flush().catch((err) => {
+        if (this.config.debug) {
+          console.error("[LlmOps] Flush error:", err);
+        }
+      });
+    }
+  }
+  /**
+   * Create a new trace
+   */
+  trace(params) {
+    const traceId = (0, import_nanoid.nanoid)();
+    const startTime = (/* @__PURE__ */ new Date()).toISOString();
+    this.enqueue({
+      type: "trace",
+      id: traceId,
+      projectId: this.config.projectId,
+      ...params,
+      status: "RUNNING",
+      startTime
+    });
+    setTraceContext(traceId);
+    return {
+      id: traceId,
+      end: async (endParams) => {
+        await this.updateTrace(traceId, {
+          status: "COMPLETED",
+          output: endParams?.output,
+          endTime: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        clearTraceContext();
+      },
+      error: async (error) => {
+        await this.updateTrace(traceId, {
+          status: "ERROR",
+          metadata: { error: error.message, stack: error.stack },
+          endTime: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        clearTraceContext();
+      }
+    };
+  }
+  /**
+   * Update an existing trace
+   */
+  async updateTrace(traceId, params) {
+    this.enqueue({
+      type: "trace",
+      id: traceId,
+      ...params
+    });
+  }
+  /**
+   * Create a new observation (span, generation, or event)
+   */
+  observation(params) {
+    const observationId = (0, import_nanoid.nanoid)();
+    const startTime = (/* @__PURE__ */ new Date()).toISOString();
+    const context = getTraceContext();
+    const traceId = params.traceId || context.traceId;
+    if (!traceId) {
+      throw new Error("No trace context found. Create a trace first.");
+    }
+    const { type: observationType, ...restParams } = params;
+    this.enqueue({
+      type: "observation",
+      id: observationId,
+      traceId,
+      parentObservationId: restParams.parentObservationId || context.observationId,
+      ...restParams,
+      observationType,
+      status: "RUNNING",
+      startTime
+    });
+    setTraceContext(traceId, observationId);
+    return {
+      id: observationId,
+      end: async (endParams) => {
+        await this.updateObservation(observationId, {
+          status: "COMPLETED",
+          output: endParams?.output,
+          promptTokens: endParams?.promptTokens,
+          completionTokens: endParams?.completionTokens,
+          endTime: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        setTraceContext(traceId, params.parentObservationId || context.observationId);
+      },
+      error: async (error) => {
+        await this.updateObservation(observationId, {
+          status: "ERROR",
+          metadata: { error: error.message, stack: error.stack },
+          endTime: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        setTraceContext(traceId, params.parentObservationId || context.observationId);
+      }
+    };
+  }
+  /**
+   * Create a generation observation (LLM call)
+   */
+  generation(params) {
+    return this.observation({
+      ...params,
+      type: "GENERATION"
+    });
+  }
+  /**
+   * Create a span observation
+   */
+  span(params) {
+    return this.observation({
+      ...params,
+      type: "SPAN"
+    });
+  }
+  /**
+   * Create an event observation
+   */
+  event(params) {
+    return this.observation({
+      ...params,
+      type: "EVENT"
+    });
+  }
+  /**
+   * Update an existing observation
+   */
+  async updateObservation(observationId, params) {
+    this.enqueue({
+      type: "observation",
+      id: observationId,
+      ...params
+    });
+  }
+  /**
+   * Flush queued events to the API
+   */
+  async flush() {
+    if (this.queue.length === 0) return;
+    if (this.pendingFlush) {
+      await this.pendingFlush;
+    }
+    const batch = this.queue.splice(0, this.config.batchSize);
+    this.log("Flushing", batch.length, "items");
+    this.pendingFlush = this.sendBatch(batch);
+    await this.pendingFlush;
+    this.pendingFlush = void 0;
+  }
+  async sendBatch(batch) {
+    try {
+      const response = await fetch(
+        `${this.config.baseUrl}/observability/ingest/batch`,
+        {
+          method: "POST",
+          headers: {
+            "Authorization": `Bearer ${this.config.publicKey}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            projectId: this.config.projectId,
+            batch
+          })
+        }
+      );
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Failed to send batch: ${response.status} ${text}`);
+      }
+      this.log("Batch sent successfully");
+    } catch (error) {
+      this.queue.unshift(...batch);
+      throw error;
+    }
+  }
+  /**
+   * Shutdown the client and flush remaining events
+   */
+  async shutdown() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+    }
+    await this.flush();
+    this.log("Shutdown complete");
+  }
+};
+
+// src/index.ts
+var defaultClient = null;
+function initLlmOps(config) {
+  if (defaultClient) {
+    console.warn("[LlmOps] SDK already initialized. Ignoring duplicate initialization.");
+    return defaultClient;
+  }
+  defaultClient = new LlmOpsClient(config);
+  return defaultClient;
+}
+function getLlmOps() {
+  if (!defaultClient) {
+    throw new Error(
+      "LLM Ops SDK not initialized. Call initLlmOps() first."
+    );
+  }
+  return defaultClient;
+}
+function isInitialized() {
+  return defaultClient !== null;
+}
+
+// src/integrations/vercel-ai.ts
+function wrapAiSdk(fn) {
+  return async (options) => {
+    if (!isInitialized()) {
+      console.warn(
+        "[LlmOps] SDK not initialized. Call initLlmOps() before using the Vercel AI wrapper."
+      );
+      return fn(options);
+    }
+    const client = getLlmOps();
+    const metadata = options.experimental_telemetry?.metadata || {};
+    const modelId = options.model?.modelId || "unknown";
+    const provider = options.model?.provider || "unknown";
+    const trace = client.trace({
+      name: `${fn.name || "ai-call"}`,
+      sessionId: metadata.sessionId,
+      userId: metadata.userId,
+      input: {
+        prompt: options.prompt,
+        messages: options.messages
+      },
+      metadata: {
+        provider,
+        modelId,
+        ...metadata
+      }
+    });
+    const generation = client.generation({
+      name: `${provider}/${modelId}`,
+      modelName: modelId,
+      input: {
+        prompt: options.prompt,
+        messages: options.messages
+      }
+    });
+    try {
+      const result = await fn(options);
+      await generation.end({
+        output: { text: result.text },
+        promptTokens: result.usage?.promptTokens,
+        completionTokens: result.usage?.completionTokens
+      });
+      await trace.end({
+        output: { text: result.text }
+      });
+      return result;
+    } catch (error) {
+      await generation.error(error);
+      await trace.error(error);
+      throw error;
+    }
+  };
+}
+function wrapStreamText(fn) {
+  return async (options) => {
+    if (!isInitialized()) {
+      console.warn(
+        "[LlmOps] SDK not initialized. Call initLlmOps() before using the Vercel AI wrapper."
+      );
+      return fn(options);
+    }
+    const client = getLlmOps();
+    const metadata = options.experimental_telemetry?.metadata || {};
+    const modelId = options.model?.modelId || "unknown";
+    const provider = options.model?.provider || "unknown";
+    const trace = client.trace({
+      name: "streamText",
+      sessionId: metadata.sessionId,
+      userId: metadata.userId,
+      input: {
+        prompt: options.prompt,
+        messages: options.messages
+      },
+      metadata: {
+        provider,
+        modelId,
+        streaming: true,
+        ...metadata
+      }
+    });
+    const generation = client.generation({
+      name: `${provider}/${modelId}`,
+      modelName: modelId,
+      input: {
+        prompt: options.prompt,
+        messages: options.messages
+      },
+      metadata: { streaming: true }
+    });
+    try {
+      const result = await fn(options);
+      await generation.end({
+        output: { streaming: true }
+      });
+      await trace.end({
+        output: { streaming: true }
+      });
+      return result;
+    } catch (error) {
+      await generation.error(error);
+      await trace.error(error);
+      throw error;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLlmOps,
+  initLlmOps,
+  wrapAiSdk,
+  wrapStreamText
+});

package/dist/integrations/vercel-ai.mjs

@@ -0,0 +1,117 @@
+import {
+  getLlmOps,
+  initLlmOps,
+  isInitialized
+} from "../chunk-IR6P3PV4.mjs";
+
+// src/integrations/vercel-ai.ts
+function wrapAiSdk(fn) {
+  return async (options) => {
+    if (!isInitialized()) {
+      console.warn(
+        "[LlmOps] SDK not initialized. Call initLlmOps() before using the Vercel AI wrapper."
+      );
+      return fn(options);
+    }
+    const client = getLlmOps();
+    const metadata = options.experimental_telemetry?.metadata || {};
+    const modelId = options.model?.modelId || "unknown";
+    const provider = options.model?.provider || "unknown";
+    const trace = client.trace({
+      name: `${fn.name || "ai-call"}`,
+      sessionId: metadata.sessionId,
+      userId: metadata.userId,
+      input: {
+        prompt: options.prompt,
+        messages: options.messages
+      },
+      metadata: {
+        provider,
+        modelId,
+        ...metadata
+      }
+    });
+    const generation = client.generation({
+      name: `${provider}/${modelId}`,
+      modelName: modelId,
+      input: {
+        prompt: options.prompt,
+        messages: options.messages
+      }
+    });
+    try {
+      const result = await fn(options);
+      await generation.end({
+        output: { text: result.text },
+        promptTokens: result.usage?.promptTokens,
+        completionTokens: result.usage?.completionTokens
+      });
+      await trace.end({
+        output: { text: result.text }
+      });
+      return result;
+    } catch (error) {
+      await generation.error(error);
+      await trace.error(error);
+      throw error;
+    }
+  };
+}
+function wrapStreamText(fn) {
+  return async (options) => {
+    if (!isInitialized()) {
+      console.warn(
+        "[LlmOps] SDK not initialized. Call initLlmOps() before using the Vercel AI wrapper."
+      );
+      return fn(options);
+    }
+    const client = getLlmOps();
+    const metadata = options.experimental_telemetry?.metadata || {};
+    const modelId = options.model?.modelId || "unknown";
+    const provider = options.model?.provider || "unknown";
+    const trace = client.trace({
+      name: "streamText",
+      sessionId: metadata.sessionId,
+      userId: metadata.userId,
+      input: {
+        prompt: options.prompt,
+        messages: options.messages
+      },
+      metadata: {
+        provider,
+        modelId,
+        streaming: true,
+        ...metadata
+      }
+    });
+    const generation = client.generation({
+      name: `${provider}/${modelId}`,
+      modelName: modelId,
+      input: {
+        prompt: options.prompt,
+        messages: options.messages
+      },
+      metadata: { streaming: true }
+    });
+    try {
+      const result = await fn(options);
+      await generation.end({
+        output: { streaming: true }
+      });
+      await trace.end({
+        output: { streaming: true }
+      });
+      return result;
+    } catch (error) {
+      await generation.error(error);
+      await trace.error(error);
+      throw error;
+    }
+  };
+}
+export {
+  getLlmOps,
+  initLlmOps,
+  wrapAiSdk,
+  wrapStreamText
+};

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@usetransactional/llm-node",
+  "version": "0.1.0",
+  "description": "LLM Ops SDK for Transactional - AI observability with cost tracking and trace analysis",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./langchain": {
+      "types": "./dist/integrations/langchain.d.ts",
+      "import": "./dist/integrations/langchain.mjs",
+      "require": "./dist/integrations/langchain.js"
+    },
+    "./vercel-ai": {
+      "types": "./dist/integrations/vercel-ai.d.ts",
+      "import": "./dist/integrations/vercel-ai.mjs",
+      "require": "./dist/integrations/vercel-ai.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/integrations/langchain.ts src/integrations/vercel-ai.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts src/integrations/langchain.ts src/integrations/vercel-ai.ts --format esm,cjs --dts --watch",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "llm",
+    "observability",
+    "langchain",
+    "openai",
+    "anthropic",
+    "tracing",
+    "monitoring",
+    "cost-tracking"
+  ],
+  "author": "Transactional",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TransactionalHQ/llm-node.git"
+  },
+  "homepage": "https://usetransactional.com/docs/llm-ops",
+  "dependencies": {
+    "nanoid": "^5.0.4"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "@langchain/core": "^0.3.0",
+    "@types/node": "^20.10.0",
+    "eslint": "^9.0.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "typescript-eslint": "^8.0.0"
+  },
+  "peerDependencies": {
+    "@langchain/core": ">=0.2.0",
+    "ai": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@langchain/core": {
+      "optional": true
+    },
+    "ai": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}