@launchdarkly/server-sdk-ai 0.14.1 → 0.15.0

package/src/api/providers/AIProvider.ts

@@ -1,94 +0,0 @@
-import { LDLogger } from '@launchdarkly/js-server-sdk-common';
-
-import { ChatResponse } from '../chat/types';
-import { LDAIConfigKind, LDMessage } from '../config/types';
-import { StructuredResponse } from '../judge/types';
-
-/**
- * Abstract base class for AI providers that implement chat model functionality.
- * This class provides the contract that all provider implementations must follow
- * to integrate with LaunchDarkly's tracking and configuration capabilities.
- *
- * Following the AICHAT spec recommendation to use base classes with non-abstract methods
- * for better extensibility and backwards compatibility.
- */
-export abstract class AIProvider {
-  protected readonly logger?: LDLogger;
-
-  constructor(logger?: LDLogger) {
-    this.logger = logger;
-  }
-  /**
-   * Invoke the chat model with an array of messages.
-   * This method should convert messages to provider format, invoke the model,
-   * and return a ChatResponse with the result and metrics.
-   *
-   * Default implementation takes no action and returns a placeholder response.
-   * Provider implementations should override this method.
-   *
-   * @param messages Array of LDMessage objects representing the conversation
-   * @returns Promise that resolves to a ChatResponse containing the model's response
-   */
-  async invokeModel(_messages: LDMessage[]): Promise<ChatResponse> {
-    this.logger?.warn('invokeModel not implemented by this provider');
-    return {
-      message: {
-        role: 'assistant',
-        content: '',
-      },
-      metrics: {
-        success: false,
-        usage: {
-          total: 0,
-          input: 0,
-          output: 0,
-        },
-      },
-    };
-  }
-
-  /**
-   * Invoke the chat model with structured output support.
-   * This method should convert messages to provider format, invoke the model with
-   * structured output configuration, and return a structured response.
-   *
-   * Default implementation takes no action and returns a placeholder response.
-   * Provider implementations should override this method.
-   *
-   * @param messages Array of LDMessage objects representing the conversation
-   * @param responseStructure Dictionary of output configurations keyed by output name
-   * @returns Promise that resolves to a structured response
-   */
-  async invokeStructuredModel(
-    _messages: LDMessage[],
-    _responseStructure: Record<string, unknown>,
-  ): Promise<StructuredResponse> {
-    this.logger?.warn('invokeStructuredModel not implemented by this provider');
-    return {
-      data: {},
-      rawResponse: '',
-      metrics: {
-        success: false,
-        usage: {
-          total: 0,
-          input: 0,
-          output: 0,
-        },
-      },
-    };
-  }
-
-  /**
-   * Static method that constructs an instance of the provider.
-   * Each provider implementation must provide their own static create method
-   * that accepts an AIConfig and returns a configured instance.
-   *
-   * @param aiConfig The LaunchDarkly AI configuration
-   * @param logger Optional logger for the provider
-   * @returns Promise that resolves to a configured provider instance
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  static async create(aiConfig: LDAIConfigKind, logger?: LDLogger): Promise<AIProvider> {
-    throw new Error('Provider implementations must override the static create method');
-  }
-}

package/src/api/providers/AIProviderFactory.ts

@@ -1,152 +0,0 @@
-import { LDLogger } from '@launchdarkly/js-server-sdk-common';
-
-import { LDAIConfigKind } from '../config/types';
-import { AIProvider } from './AIProvider';
-
-/**
- * List of supported AI providers.
- */
-export const SUPPORTED_AI_PROVIDERS = [
-  'openai',
-  // Multi-provider packages should be last in the list
-  'langchain',
-  'vercel',
-] as const;
-
-/**
- * Type representing the supported AI providers.
- */
-export type SupportedAIProvider = (typeof SUPPORTED_AI_PROVIDERS)[number];
-
-/**
- * Factory for creating AIProvider instances based on the provider configuration.
- */
-export class AIProviderFactory {
-  /**
-   * Create an AIProvider instance based on the AI configuration.
-   * This method attempts to load provider-specific implementations dynamically.
-   * Returns undefined if the provider is not supported.
-   *
-   * @param aiConfig The AI configuration
-   * @param logger Optional logger for logging provider initialization
-   * @param defaultAiProvider Optional default AI provider to use
-   */
-  static async create(
-    aiConfig: LDAIConfigKind,
-    logger?: LDLogger,
-    defaultAiProvider?: SupportedAIProvider,
-  ): Promise<AIProvider | undefined> {
-    const providerName = aiConfig.provider?.name?.toLowerCase();
-    // Determine which providers to try based on defaultAiProvider
-    const providersToTry = this._getProvidersToTry(defaultAiProvider, providerName);
-
-    // Try each provider in order
-    // eslint-disable-next-line no-restricted-syntax
-    for (const providerType of providersToTry) {
-      // eslint-disable-next-line no-await-in-loop
-      const provider = await this._tryCreateProvider(providerType, aiConfig, logger);
-      if (provider) {
-        return provider;
-      }
-    }
-
-    // If no provider was successfully created, log a warning
-    logger?.warn(
-      `Provider is not supported or failed to initialize: ${aiConfig.provider?.name ?? 'unknown'}`,
-    );
-    return undefined;
-  }
-
-  /**
-   * Determine which providers to try based on defaultAiProvider and providerName.
-   */
-  private static _getProvidersToTry(
-    defaultAiProvider?: SupportedAIProvider,
-    providerName?: string,
-  ): SupportedAIProvider[] {
-    // If defaultAiProvider is set, only try that specific provider
-    if (defaultAiProvider) {
-      return [defaultAiProvider];
-    }
-
-    // If no defaultAiProvider is set, try all providers in order
-    const providerSet = new Set<SupportedAIProvider>();
-
-    // First try the specific provider if it's supported
-    if (providerName && SUPPORTED_AI_PROVIDERS.includes(providerName as SupportedAIProvider)) {
-      providerSet.add(providerName as SupportedAIProvider);
-    }
-
-    // Then try multi-provider packages, but avoid duplicates
-    const multiProviderPackages: SupportedAIProvider[] = ['langchain', 'vercel'];
-    multiProviderPackages.forEach((provider) => {
-      providerSet.add(provider);
-    });
-
-    return Array.from(providerSet);
-  }
-
-  /**
-   * Try to create a provider of the specified type.
-   */
-  private static async _tryCreateProvider(
-    providerType: SupportedAIProvider,
-    aiConfig: LDAIConfigKind,
-    logger?: LDLogger,
-  ): Promise<AIProvider | undefined> {
-    switch (providerType) {
-      case 'openai':
-        return this._createProvider(
-          '@launchdarkly/server-sdk-ai-openai',
-          'OpenAIProvider',
-          aiConfig,
-          logger,
-        );
-      case 'langchain':
-        return this._createProvider(
-          '@launchdarkly/server-sdk-ai-langchain',
-          'LangChainProvider',
-          aiConfig,
-          logger,
-        );
-      case 'vercel':
-        return this._createProvider(
-          '@launchdarkly/server-sdk-ai-vercel',
-          'VercelProvider',
-          aiConfig,
-          logger,
-        );
-      default:
-        return undefined;
-    }
-  }
-
-  /**
-   * Create a provider instance dynamically.
-   */
-  private static async _createProvider(
-    packageName: string,
-    providerClassName: string,
-    aiConfig: LDAIConfigKind,
-    logger?: LDLogger,
-  ): Promise<AIProvider | undefined> {
-    try {
-      // Try to dynamically import the provider
-      // This will work if the package is installed
-      // eslint-disable-next-line import/no-extraneous-dependencies, global-require, import/no-dynamic-require
-      const { [providerClassName]: ProviderClass } = require(packageName);
-
-      const provider = await ProviderClass.create(aiConfig, logger);
-      logger?.debug(
-        `Successfully created AIProvider for: ${aiConfig.provider?.name} with package ${packageName}`,
-      );
-      return provider;
-    } catch (error) {
-      // If the provider is not available or creation fails, return undefined
-      logger?.warn(
-        `Error creating AIProvider for: ${aiConfig.provider?.name} with package ${packageName}: ${error}`,
-      );
-      return undefined;
-    }
-  }
-}

package/src/api/providers/index.ts

@@ -1,2 +0,0 @@
-export * from './AIProvider';
-export * from './AIProviderFactory';

package/src/index.ts

@@ -1,24 +0,0 @@
-/**
- * This is the API reference for the LaunchDarkly AI SDK for Server-Side JavaScript.
- *
- * In typical usage, you will call {@link initAi} once at startup time to obtain an instance of
- * {@link LDAIClient}, which provides access to all of the SDK's functionality.
- *
- * @packageDocumentation
- */
-import { LDAIClient } from './api/LDAIClient';
-import { LDAIClientImpl } from './LDAIClientImpl';
-import { LDClientMin } from './LDClientMin';
-
-/**
- * Initialize a new AI client. This client will be used to perform any AI operations.
- * @param ldClient The base LaunchDarkly client.
- * @returns A new AI client.
- */
-export function initAi(ldClient: LDClientMin): LDAIClient {
-  return new LDAIClientImpl(ldClient);
-}
-
-export { LDLogger } from '@launchdarkly/js-server-sdk-common';
-
-export * from './api';

package/tsconfig.eslint.json

@@ -1,5 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "include": ["**/*.ts"],
-  "exclude": ["node_modules", "dist"]
-}

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    // Uses "." so it can load package.json.
-    "rootDir": ".",
-    "outDir": "dist",
-    "target": "es2017",
-    "lib": ["es6"],
-    "module": "commonjs",
-    "strict": true,
-    "noImplicitOverride": true,
-    // Needed for CommonJS modules.
-    "allowSyntheticDefaultImports": true,
-    "sourceMap": true,
-    "declaration": true,
-    "declarationMap": true, // enables importers to jump to source
-    "resolveJsonModule": true,
-    "stripInternal": true,
-    "moduleResolution": "node"
-  },
-  "exclude": ["**/*.test.ts", "dist", "node_modules", "__tests__", "examples"]
-}

package/tsconfig.ref.json

@@ -1,7 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "include": ["src/**/*", "package.json"],
-  "compilerOptions": {
-    "composite": true
-  }
-}

package/typedoc.json

@@ -1,5 +0,0 @@
-{
-  "extends": ["../../../typedoc.base.json"],
-  "entryPoints": ["src/index.ts"],
-  "out": "docs"
-}