feat: Add AI SDK for Server-Side JavaScript.

package.json

@@ -23,7 +23,8 @@
     "packages/store/node-server-sdk-dynamodb",
     "packages/telemetry/node-server-sdk-otel",
     "packages/tooling/jest",
-    "packages/sdk/browser"
+    "packages/sdk/browser",
+    "packages/sdk/ai"
   ],
   "private": true,
   "scripts": {

packages/sdk/ai/README.md

@@ -0,0 +1,5 @@
+# LaunchDarkly AI SDK for Node.js
+
+This package provides the LaunchDarkly AI SDK for Node.js.
+
+## Installation

packages/sdk/ai/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@launchdarkly/ai",
+  "version": "0.1.0",
+  "description": "LaunchDarkly AI SDK for Node.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint . --ext .ts"
+  },
+  "keywords": [
+    "launchdarkly",
+    "ai",
+    "llm"
+  ],
+  "author": "LaunchDarkly",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@launchdarkly/node-server-sdk": "^9.5.2",
+    "mustache": "^4.2.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.3",
+    "@types/mustache": "^4.2.5",
+    "@typescript-eslint/eslint-plugin": "^6.20.0",
+    "@typescript-eslint/parser": "^6.20.0",
+    "eslint": "^8.45.0",
+    "jest": "^29.6.1",
+    "ts-jest": "^29.1.1",
+    "typescript": "5.1.6"
+  },
+  "peerDependencies": {
+    "@launchdarkly/node-server-sdk": ">=9.4.3"
+  }
+}

packages/sdk/ai/src/LDAIConfigTracker.ts

@@ -0,0 +1,77 @@
+import { LDClient, LDContext } from '@launchdarkly/node-server-sdk';
+
+import { BedrockTokenUsage, FeedbackKind, TokenUsage, UnderscoreTokenUsage } from './api/metrics';
+import { usageToTokenMetrics } from './trackUtils';
+
+export class LDAIConfigTracker {
+  private ldClient: LDClient;
+  private configKey: string;
+  private variationId: string;
+  private context: LDContext;
+
+  constructor(ldClient: LDClient, configKey: string, variationId: string, context: LDContext) {
+    this.ldClient = ldClient;
+    this.configKey = configKey;
+    this.variationId = variationId;
+    this.context = context;
+  }
+
+  getTrackData() {
+    return {
+      configKey: this.configKey,
+      variationId: this.variationId,
+    };
+  }
+
+  trackDuration(duration: number): void {
+    this.ldClient.track('$ld:ai:duration:total', this.context, this.variationId, duration);
+  }
+
+  trackTokens(tokens: TokenUsage | UnderscoreTokenUsage | BedrockTokenUsage) {
+    console.log('tracking LLM tokens', tokens);
+    const tokenMetrics = usageToTokenMetrics(tokens);
+    console.log('token metrics', tokenMetrics);
+    if (tokenMetrics.total > 0) {
+      this.ldClient.track(
+        '$ld:ai:tokens:total',
+        this.context,
+        this.getTrackData(),
+        tokenMetrics.total,
+      );
+    }
+    if (tokenMetrics.input > 0) {
+      console.log('tracking input tokens', tokenMetrics.input);
+      this.ldClient.track(
+        '$ld:ai:tokens:input',
+        this.context,
+        this.getTrackData(),
+        tokenMetrics.input,
+      );
+    }
+    if (tokenMetrics.output > 0) {
+      console.log('tracking output tokens', tokenMetrics.output);
+      this.ldClient.track(
+        '$ld:ai:tokens:output',
+        this.context,
+        this.getTrackData(),
+        tokenMetrics.output,
+      );
+    }
+  }
+
+  trackError(error: number) {
+    this.ldClient.track('$ld:ai:error', this.context, this.getTrackData(), error);
+  }
+
+  trackGeneration(generation: number) {
+    this.ldClient.track('$ld:ai:generation', this.context, this.getTrackData(), generation);
+  }
+
+  trackFeedback(feedback: { kind: FeedbackKind }) {
+    if (feedback.kind === FeedbackKind.Positive) {
+      this.ldClient.track('$ld:ai:feedback:user:positive', this.context, this.getTrackData(), 1);
+    } else if (feedback.kind === FeedbackKind.Negative) {
+      this.ldClient.track('$ld:ai:feedback:user:negative', this.context, this.getTrackData(), 1);
+    }
+  }
+}

packages/sdk/ai/src/api/config/LDAIConfig.ts

@@ -0,0 +1,16 @@
+import { LDAIConfigTracker } from './LDAIConfigTracker';
+
+/**
+ * AI Config value and tracker.
+ */
+export interface LDAIConfig {
+  /**
+   * The result of the AI Config evaluation.
+   */
+  config: unknown;
+
+  /**
+   * A tracker which can be used to generate analytics for the migration.
+   */
+  tracker: LDAIConfigTracker;
+}

packages/sdk/ai/src/api/config/LDAIConfigTracker.ts

@@ -0,0 +1,9 @@
+import { BedrockTokenUsage, FeedbackKind, TokenUsage, UnderscoreTokenUsage } from '../metrics';
+
+export interface LDAIConfigTracker {
+  trackDuration: (duration: number) => void;
+  trackTokens: (tokens: TokenUsage | UnderscoreTokenUsage | BedrockTokenUsage) => void;
+  trackError: (error: number) => void;
+  trackGeneration: (generation: number) => void;
+  trackFeedback: (feedback: { kind: FeedbackKind }) => void;
+}

packages/sdk/ai/src/api/config/index.ts

@@ -0,0 +1,2 @@
+export * from './LDAIConfig';
+export * from './LDAIConfigTracker';

packages/sdk/ai/src/api/metrics/BedrockTokenUsage.ts

@@ -0,0 +1,5 @@
+export interface BedrockTokenUsage {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+}

packages/sdk/ai/src/api/metrics/FeedbackKind.ts

@@ -0,0 +1,4 @@
+export enum FeedbackKind {
+  Positive = 'positive',
+  Negative = 'negative',
+}

packages/sdk/ai/src/api/metrics/TokenMetrics.ts

@@ -0,0 +1,5 @@
+export interface TokenMetrics {
+  total: number;
+  input: number;
+  output: number;
+}

packages/sdk/ai/src/api/metrics/TokenUsage.ts

@@ -0,0 +1,5 @@
+export interface TokenUsage {
+  completionTokens?: number;
+  promptTokens?: number;
+  totalTokens?: number;
+}

packages/sdk/ai/src/api/metrics/UnderscoreTokenUsage.ts

@@ -0,0 +1,5 @@
+export interface UnderscoreTokenUsage {
+  completion_tokens?: number;
+  prompt_tokens?: number;
+  total_tokens?: number;
+}

packages/sdk/ai/src/api/metrics/index.ts

@@ -0,0 +1,5 @@
+export * from './BedrockTokenUsage';
+export * from './FeedbackKind';
+export * from './TokenMetrics';
+export * from './TokenUsage';
+export * from './UnderScoreTokenUsage';

packages/sdk/ai/src/index.ts

@@ -0,0 +1,95 @@
+import Mustache from 'mustache';
+
+import { LDClient, LDContext } from '@launchdarkly/node-server-sdk';
+
+import { LDAIConfigTracker } from './LDAIConfigTracker';
+import { LDAIConfig } from './api/config';
+
+export class AIClient {
+  private ldClient: LDClient;
+
+  constructor(ldClient: LDClient) {
+    this.ldClient = ldClient;
+  }
+
+  /**
+   * Parses and interpolates a template string with the provided variables.
+   *
+   * @param template - The template string to be parsed and interpolated.
+   * @param variables - An object containing the variables to be used for interpolation.
+   * @returns The interpolated string.
+   */
+  interpolateTemplate(template: string, variables: Record<string, unknown>): string {
+    return Mustache.render(template, variables, undefined, { escape: (item: any) => item });
+  }
+
+  /**
+   * Retrieves and processes a prompt template based on the provided key, LaunchDarkly context, and variables.
+   *
+   * @param key - A unique identifier for the prompt template. This key is used to fetch the correct prompt from storage or configuration.
+   * @param context - The LaunchDarkly context object that contains relevant information about the current environment, user, or session. This context may influence how the prompt is processed or personalized.
+   * @param variables - A map of key-value pairs representing dynamic variables to be injected into the prompt template. The keys correspond to placeholders within the template, and the values are the corresponding replacements.
+   * @param defaultValue - A fallback value to be used if the prompt template associated with the key is not found or if any errors occur during processing.
+   *
+   * @returns The processed prompt after all variables have been substituted in the stored prompt template. If the prompt cannot be retrieved or processed, the `defaultValue` is returned.
+   *
+   * @example
+   * ```
+   * const key = "welcome_prompt";
+   * const context = new LDContext(...);
+   * const variables = new Record<string, string>([["username", "John"]]);
+   * const defaultValue = {}};
+   *
+   * const result = modelConfig(key, context, defaultValue, variables);
+   * console.log(result);
+   * // Output:
+   * {
+   * modelId: "gpt-4o",
+   * temperature: 0.2,
+   * maxTokens: 4096,
+   * userDefinedKey: "myValue",
+   * prompt: [
+   * {
+   * role: "system",
+   * content: "You are an amazing GPT."
+   * },
+   * {
+   * role: "user",
+   * content: "Explain how you're an amazing GPT."
+   * }
+   * ]
+   * }
+   * ```
+   */
+  async modelConfig(
+    key: string,
+    context: LDContext,
+    defaultValue: string,
+    variables?: Record<string, unknown>,
+  ): Promise<LDAIConfig> {
+    const detail = await this.ldClient.variationDetail(key, context, defaultValue);
+
+    const allVariables = { ldctx: context, ...variables };
+
+    detail.value.prompt = detail.value.prompt.map((entry: any) => ({
+      ...entry,
+      content: this.interpolateTemplate(entry.content, allVariables),
+    }));
+
+    return {
+      config: detail.value,
+      tracker: new LDAIConfigTracker(
+        this.ldClient,
+        key,
+        detail.value["_ldMeta"]["variationId"],
+        context,
+      ),
+    };
+  }
+}
+
+export function init(ldClient: LDClient): AIClient {
+  return new AIClient(ldClient);
+}
+
+export { LDAIConfigTracker } from './LDAIConfigTracker';

packages/sdk/ai/src/trackUtils.ts

@@ -0,0 +1,25 @@
+import { BedrockTokenUsage, TokenMetrics, TokenUsage, UnderscoreTokenUsage } from './types';
+
+export function usageToTokenMetrics(
+  usage: TokenUsage | UnderscoreTokenUsage | BedrockTokenUsage,
+): TokenMetrics {
+  if ('inputTokens' in usage && 'outputTokens' in usage) {
+    // Bedrock usage
+    return {
+      total: usage.totalTokens,
+      input: usage.inputTokens,
+      output: usage.outputTokens,
+    };
+  }
+
+  // OpenAI usage (both camelCase and snake_case)
+  return {
+    total: 'total_tokens' in usage ? usage.total_tokens! : (usage as TokenUsage).totalTokens ?? 0,
+    input:
+      'prompt_tokens' in usage ? usage.prompt_tokens! : (usage as TokenUsage).promptTokens ?? 0,
+    output:
+      'completion_tokens' in usage
+        ? usage.completion_tokens!
+        : (usage as TokenUsage).completionTokens ?? 0,
+  };
+}

packages/sdk/ai/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "**/*.test.ts"]
+}