@launchdarkly/server-sdk-ai 0.14.0 → 0.15.0

package/dist/index.d.cts

@@ -0,0 +1,1022 @@
+import * as common from '@launchdarkly/js-server-sdk-common';
+import { LDLogger as LDLogger$1, LDContext, LDFlagValue } from '@launchdarkly/js-server-sdk-common';
+
+/**
+ * Information about token usage.
+ */
+interface LDTokenUsage {
+    /**
+     * Combined token usage.
+     */
+    total: number;
+    /**
+     * Number of tokens in the input.
+     */
+    input: number;
+    /**
+     * Number of tokens in the output.
+     */
+    output: number;
+}
+
+/**
+ * Metrics information for AI operations that includes success status and token usage.
+ * This class combines success/failure tracking with token usage metrics.
+ */
+interface LDAIMetrics {
+    /**
+     * Whether the AI operation was successful.
+     */
+    success: boolean;
+    /**
+     * Token usage information for the operation.
+     * This will be undefined if no token usage data is available.
+     */
+    usage?: LDTokenUsage;
+}
+
+/**
+ * Structured response from AI models.
+ */
+interface StructuredResponse {
+    /** The structured data returned by the model */
+    data: Record<string, unknown>;
+    /** The raw response from the model */
+    rawResponse: string;
+    /**
+     * Metrics information including success status and token usage.
+     */
+    metrics: LDAIMetrics;
+}
+/**
+ * Score and reasoning for a single evaluation metric.
+ */
+interface EvalScore {
+    /** Score between 0.0 and 1.0 indicating the evaluation result for this metric */
+    score: number;
+    /** Reasoning behind the provided score for this metric */
+    reasoning: string;
+}
+/**
+ * Response from a judge evaluation containing scores and reasoning for multiple metrics.
+ */
+interface JudgeResponse {
+    /** The key of the judge configuration that was used to generate this response */
+    judgeConfigKey?: string;
+    /** Dictionary where keys are metric names and values contain score and reasoning */
+    evals: Record<string, EvalScore>;
+    /** Whether the evaluation completed successfully */
+    success: boolean;
+    /** Error message if evaluation failed */
+    error?: string;
+}
+
+declare function createBedrockTokenUsage(data: {
+    totalTokens?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+}): LDTokenUsage;
+
+declare function createOpenAiUsage(data: {
+    total_tokens?: number;
+    prompt_tokens?: number;
+    completion_tokens?: number;
+}): LDTokenUsage;
+
+/**
+ * Feedback about the generated content.
+ */
+declare enum LDFeedbackKind {
+    /**
+     * The sentiment was positive.
+     */
+    Positive = "positive",
+    /**
+     * The sentiment is negative.
+     */
+    Negative = "negative"
+}
+
+declare function createVercelAISDKTokenUsage(data: {
+    totalTokens?: number;
+    inputTokens?: number;
+    promptTokens?: number;
+    outputTokens?: number;
+    completionTokens?: number;
+}): LDTokenUsage;
+
+/**
+ * Metrics which have been tracked.
+ */
+interface LDAIMetricSummary {
+    /**
+     * The duration of generation.
+     */
+    durationMs?: number;
+    /**
+     * Information about token usage.
+     */
+    tokens?: LDTokenUsage;
+    /**
+     * Was generation successful.
+     */
+    success?: boolean;
+    /**
+     * Any sentiment about the generation.
+     */
+    feedback?: {
+        kind: LDFeedbackKind;
+    };
+    /**
+     * Time to first token for this generation.
+     */
+    timeToFirstTokenMs?: number;
+}
+/**
+ * The LDAIConfigTracker is used to track various details about AI operations.
+ */
+interface LDAIConfigTracker {
+    /**
+     * Get the data for tracking.
+     */
+    getTrackData(): {
+        variationKey: string;
+        configKey: string;
+        version: number;
+        modelName: string;
+        providerName: string;
+        aiSdkName: string;
+        aiSdkVersion: string;
+    };
+    /**
+     * Track the duration of generation.
+     *
+     * Ideally this would not include overhead time such as network communication.
+     *
+     * @param durationMs The duration in milliseconds.
+     */
+    trackDuration(durationMs: number): void;
+    /**
+     * Track information about token usage.
+     *
+     * @param tokens Token usage information.
+     */
+    trackTokens(tokens: LDTokenUsage): void;
+    /**
+     * Generation was successful.
+     */
+    trackSuccess(): void;
+    /**
+     * An error was encountered during generation.
+     */
+    trackError(): void;
+    /**
+     * Track sentiment about the generation.
+     *
+     * @param feedback Feedback about the generation.
+     */
+    trackFeedback(feedback: {
+        kind: LDFeedbackKind;
+    }): void;
+    /**
+     * Track the time to first token for this generation.
+     *
+     * @param timeToFirstTokenMs The duration in milliseconds.
+     */
+    trackTimeToFirstToken(timeToFirstTokenMs: number): void;
+    /**
+     * Track evaluation scores for multiple metrics.
+     *
+     * @param scores Record mapping metric keys to their evaluation scores
+     */
+    trackEvalScores(scores: Record<string, EvalScore>): void;
+    /**
+     * Track a judge response containing evaluation scores and judge configuration key.
+     *
+     * @param response Judge response containing evaluation scores and judge configuration key
+     */
+    trackJudgeResponse(response: JudgeResponse): void;
+    /**
+     * Track the duration of execution of the provided function.
+     *
+     * If the provided function throws, then this method will also throw.
+     * In the case the provided function throws, this function will still record the duration.
+     *
+     * This function does not automatically record an error when the function throws.
+     *
+     * @param func The function to track the duration of.
+     * @returns The result of the function.
+     */
+    trackDurationOf(func: () => Promise<any>): Promise<any>;
+    /**
+     * Track metrics for a generic AI operation.
+     *
+     * This function will track the duration of the operation, extract metrics using the provided
+     * metrics extractor function, and track success or error status accordingly.
+     *
+     * If the provided function throws, then this method will also throw.
+     * In the case the provided function throws, this function will record the duration and an error.
+     * A failed operation will not have any token usage data.
+     *
+     * @param metricsExtractor Function that extracts LDAIMetrics from the operation result
+     * @param func Function which executes the operation
+     * @returns The result of the operation
+     */
+    trackMetricsOf<TRes>(metricsExtractor: (result: TRes) => LDAIMetrics, func: () => Promise<TRes>): Promise<TRes>;
+    /**
+     * Track metrics for a streaming AI operation.
+     *
+     * This function will track the duration of the operation, extract metrics using the provided
+     * metrics extractor function, and track success or error status accordingly.
+     *
+     * Unlike trackMetricsOf, this method is designed for streaming operations where:
+     * - The stream is created and returned immediately (synchronously)
+     * - Metrics are extracted asynchronously in the background once the stream completes
+     * - Duration is tracked from stream creation to metrics extraction completion
+     *
+     * The stream is returned immediately so the caller can begin consuming it without waiting.
+     * Metrics extraction happens in the background and does not block stream consumption.
+     *
+     * If the stream creator throws, then this method will also throw and record an error.
+     * If metrics extraction fails, the error is logged but does not affect stream consumption.
+     *
+     * @param streamCreator Function that creates and returns the stream (synchronous)
+     * @param metricsExtractor Function that asynchronously extracts metrics from the stream
+     * @returns The stream result (returned immediately, not a Promise)
+     */
+    trackStreamMetricsOf<TStream>(streamCreator: () => TStream, metricsExtractor: (stream: TStream) => Promise<LDAIMetrics>): TStream;
+    /**
+     * Track an OpenAI operation.
+     *
+     * This function will track the duration of the operation, the token usage, and the success or error status.
+     *
+     * If the provided function throws, then this method will also throw.
+     * In the case the provided function throws, this function will record the duration and an error.
+     * A failed operation will not have any token usage data.
+     *
+     * @param func Function which executes the operation.
+     * @returns The result of the operation.
+     */
+    trackOpenAIMetrics<TRes extends {
+        usage?: {
+            total_tokens?: number;
+            prompt_tokens?: number;
+            completion_tokens?: number;
+        };
+    }>(func: () => Promise<TRes>): Promise<TRes>;
+    /**
+     * Track an operation which uses Bedrock.
+     *
+     * This function will track the duration of the operation, the token usage, and the success or error status.
+     *
+     * @param res The result of the Bedrock operation.
+     * @returns The input operation.
+     */
+    trackBedrockConverseMetrics<TRes extends {
+        $metadata: {
+            httpStatusCode?: number;
+        };
+        metrics?: {
+            latencyMs?: number;
+        };
+        usage?: {
+            inputTokens?: number;
+            outputTokens?: number;
+            totalTokens?: number;
+        };
+    }>(res: TRes): TRes;
+    /**
+     * Track a Vercel AI SDK generateText operation.
+     *
+     * This function will track the duration of the operation, the token usage, and the success or error status.
+     *
+     * If the provided function throws, then this method will also throw.
+     * In the case the provided function throws, this function will record the duration and an error.
+     * A failed operation will not have any token usage data.
+     *
+     * @param func Function which executes the operation.
+     * @returns The result of the operation.
+     */
+    trackVercelAISDKGenerateTextMetrics<TRes extends {
+        usage?: {
+            totalTokens?: number;
+            inputTokens?: number;
+            promptTokens?: number;
+            outputTokens?: number;
+            completionTokens?: number;
+        };
+    }>(func: () => Promise<TRes>): Promise<TRes>;
+    /**
+     * Get a summary of the tracked metrics.
+     */
+    getSummary(): LDAIMetricSummary;
+}
+
+/**
+ * Information about prompts.
+ */
+interface LDMessage {
+    /**
+     * The role of the prompt.
+     */
+    role: 'user' | 'assistant' | 'system';
+    /**
+     * Content for the prompt.
+     */
+    content: string;
+}
+/**
+ * Configuration related to the model.
+ */
+interface LDModelConfig {
+    /**
+     * The ID of the model.
+     */
+    name: string;
+    /**
+     * Model specific parameters.
+     */
+    parameters?: {
+        [index: string]: unknown;
+    };
+    /**
+     * Additional user-specified parameters.
+     */
+    custom?: {
+        [index: string]: unknown;
+    };
+}
+interface LDProviderConfig {
+    /**
+     * The name of the provider.
+     */
+    name: string;
+}
+/**
+ * Configuration for a single judge attachment.
+ */
+interface LDJudge {
+    /** The key of the judge AI Config */
+    key: string;
+    /** Sampling rate for evaluation (0.0 to 1.0) */
+    samplingRate: number;
+}
+/**
+ * Configuration for judge attachment to AI Configs.
+ */
+interface LDJudgeConfiguration {
+    /** Array of judge configurations */
+    judges: LDJudge[];
+}
+/**
+ * Base AI Config interface for default implementations with optional enabled property.
+ */
+interface LDAIConfigDefault {
+    /**
+     * Optional model configuration.
+     */
+    model?: LDModelConfig;
+    /**
+     * Optional configuration for the provider.
+     */
+    provider?: LDProviderConfig;
+    /**
+     * Whether the configuration is enabled. Defaults to false when not provided.
+     */
+    enabled?: boolean;
+}
+/**
+ * Base AI Config interface without mode-specific fields.
+ */
+interface LDAIConfig extends Omit<LDAIConfigDefault, 'enabled'> {
+    /**
+     * The key of the AI Config.
+     */
+    key: string;
+    /**
+     * Whether the configuration is enabled.
+     */
+    enabled: boolean;
+    /**
+     * A tracker which can be used to generate analytics.
+     * Undefined for disabled configs.
+     */
+    tracker?: LDAIConfigTracker;
+}
+/**
+ * Default Agent-specific AI Config with instructions.
+ */
+interface LDAIAgentConfigDefault extends LDAIConfigDefault {
+    /**
+     * Instructions for the agent.
+     */
+    instructions?: string;
+    /**
+     * Judge configuration for AI Configs being evaluated.
+     * References judge AI Configs that should evaluate this AI Config.
+     */
+    judgeConfiguration?: LDJudgeConfiguration;
+}
+/**
+ * Default Completion AI Config (default mode).
+ */
+interface LDAICompletionConfigDefault extends LDAIConfigDefault {
+    /**
+     * Optional prompt data for completion configurations.
+     */
+    messages?: LDMessage[];
+    /**
+     * Judge configuration for AI Configs being evaluated.
+     * References judge AI Configs that should evaluate this AI Config.
+     */
+    judgeConfiguration?: LDJudgeConfiguration;
+}
+/**
+ * Default Judge-specific AI Config with required evaluation metric key.
+ */
+interface LDAIJudgeConfigDefault extends LDAIConfigDefault {
+    /**
+     * Optional prompt data for judge configurations.
+     */
+    messages?: LDMessage[];
+    /**
+     * Evaluation metric keys for judge configurations.
+     * The keys of the metrics that this judge can evaluate.
+     */
+    evaluationMetricKeys?: string[];
+}
+/**
+ * Union type for all default AI Config variants.
+ */
+type LDAIConfigDefaultKind = LDAIAgentConfigDefault | LDAICompletionConfigDefault | LDAIJudgeConfigDefault;
+/**
+ * Agent-specific AI Config with instructions.
+ */
+interface LDAIAgentConfig extends LDAIConfig {
+    /**
+     * Instructions for the agent.
+     */
+    instructions?: string;
+    /**
+     * Judge configuration for AI Configs being evaluated.
+     * References judge AI Configs that should evaluate this AI Config.
+     */
+    judgeConfiguration?: LDJudgeConfiguration;
+}
+/**
+ * Completion AI Config (default mode).
+ */
+interface LDAICompletionConfig extends LDAIConfig {
+    /**
+     * Optional prompt data for completion configurations.
+     */
+    messages?: LDMessage[];
+    /**
+     * Judge configuration for AI Configs being evaluated.
+     * References judge AI Configs that should evaluate this AI Config.
+     */
+    judgeConfiguration?: LDJudgeConfiguration;
+}
+/**
+ * Judge-specific AI Config with required evaluation metric key.
+ */
+interface LDAIJudgeConfig extends LDAIConfig {
+    /**
+     * Optional prompt data for judge configurations.
+     */
+    messages?: LDMessage[];
+    /**
+     * Evaluation metric keys for judge configurations.
+     * The keys of the metrics that this judge can evaluate.
+     */
+    evaluationMetricKeys: string[];
+}
+/**
+ * Union type for all AI Config variants.
+ */
+type LDAIConfigKind = LDAIAgentConfig | LDAICompletionConfig | LDAIJudgeConfig;
+/**
+ * Configuration for a single agent request.
+ */
+interface LDAIAgentRequestConfig {
+    /**
+     * The agent key to retrieve.
+     */
+    key: string;
+    /**
+     * Default configuration for the agent.
+     */
+    defaultValue: LDAIAgentConfigDefault;
+    /**
+     * Variables for instructions interpolation.
+     */
+    variables?: Record<string, unknown>;
+}
+/**
+ * Mode type for AI configurations.
+ */
+type LDAIConfigMode = 'completion' | 'agent' | 'judge';
+
+/**
+ * Chat response structure.
+ */
+interface ChatResponse {
+    /**
+     * The response message from the AI.
+     */
+    message: LDMessage;
+    /**
+     * Metrics information including success status and token usage.
+     */
+    metrics: LDAIMetrics;
+    /**
+     * Promise that resolves to judge evaluation results.
+     * Only present when judges are configured for evaluation.
+     */
+    evaluations?: Promise<Array<JudgeResponse | undefined>>;
+}
+
+/**
+ * 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.
+ */
+declare abstract class AIProvider {
+    protected readonly logger?: LDLogger$1;
+    constructor(logger?: LDLogger$1);
+    /**
+     * 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
+     */
+    invokeModel(_messages: LDMessage[]): Promise<ChatResponse>;
+    /**
+     * 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
+     */
+    invokeStructuredModel(_messages: LDMessage[], _responseStructure: Record<string, unknown>): Promise<StructuredResponse>;
+    /**
+     * 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
+     */
+    static create(aiConfig: LDAIConfigKind, logger?: LDLogger$1): Promise<AIProvider>;
+}
+
+/**
+ * Judge implementation that handles evaluation functionality and conversation management.
+ *
+ * According to the AIEval spec, judges are AI Configs with mode: "judge" that evaluate
+ * other AI Configs using structured output.
+ */
+declare class Judge {
+    private readonly _aiConfig;
+    private readonly _aiConfigTracker;
+    private readonly _aiProvider;
+    private readonly _logger?;
+    private readonly _evaluationResponseStructure;
+    constructor(_aiConfig: LDAIJudgeConfig, _aiConfigTracker: LDAIConfigTracker, _aiProvider: AIProvider, logger?: LDLogger$1);
+    /**
+     * Evaluates an AI response using the judge's configuration.
+     *
+     * @param input The input prompt or question that was provided to the AI
+     * @param output The AI-generated response to be evaluated
+     * @param samplingRate Sampling rate (0-1) to determine if evaluation should be processed (defaults to 1)
+     * @returns Promise that resolves to evaluation results or undefined if not sampled
+     */
+    evaluate(input: string, output: string, samplingRate?: number): Promise<JudgeResponse | undefined>;
+    /**
+     * Evaluates an AI response from chat messages and response.
+     *
+     * @param messages Array of messages representing the conversation history
+     * @param response The AI response to be evaluated
+     * @param samplingRatio Sampling ratio (0-1) to determine if evaluation should be processed (defaults to 1)
+     * @returns Promise that resolves to evaluation results or undefined if not sampled
+     */
+    evaluateMessages(messages: LDMessage[], response: ChatResponse, samplingRatio?: number): Promise<JudgeResponse | undefined>;
+    /**
+     * Returns the AI Config used by this judge.
+     */
+    getAIConfig(): LDAIJudgeConfig;
+    /**
+     * Returns the tracker associated with this judge.
+     */
+    getTracker(): LDAIConfigTracker;
+    /**
+     * Returns the AI provider used by this judge.
+     */
+    getProvider(): AIProvider;
+    /**
+     * Constructs evaluation messages by combining judge's config messages with input/output.
+     */
+    private _constructEvaluationMessages;
+    /**
+     * Interpolates message content with variables using Mustache templating.
+     */
+    private _interpolateMessage;
+    /**
+     * Parses the structured evaluation response from the AI provider.
+     */
+    private _parseEvaluationResponse;
+}
+
+/**
+ * Concrete implementation of TrackedChat that provides chat functionality
+ * by delegating to an AIProvider implementation.
+ * This class handles conversation management and tracking, while delegating
+ * the actual model invocation to the provider.
+ */
+declare class TrackedChat {
+    protected readonly aiConfig: LDAICompletionConfig;
+    protected readonly tracker: LDAIConfigTracker;
+    protected readonly provider: AIProvider;
+    protected readonly judges: Record<string, Judge>;
+    private readonly _logger?;
+    protected messages: LDMessage[];
+    constructor(aiConfig: LDAICompletionConfig, tracker: LDAIConfigTracker, provider: AIProvider, judges?: Record<string, Judge>, _logger?: LDLogger$1 | undefined);
+    /**
+     * Invoke the chat model with a prompt string.
+     * This method handles conversation management and tracking, delegating to the provider's invokeModel method.
+     */
+    invoke(prompt: string): Promise<ChatResponse>;
+    /**
+     * Evaluates the response with all configured judges.
+     * Returns a promise that resolves to an array of evaluation results.
+     *
+     * @param messages Array of messages representing the conversation history
+     * @param response The AI response to be evaluated
+     * @returns Promise resolving to array of judge evaluation results
+     */
+    private _evaluateWithJudges;
+    /**
+     * Get the underlying AI configuration used to initialize this TrackedChat.
+     */
+    getConfig(): LDAICompletionConfig;
+    /**
+     * Get the underlying AI configuration tracker used to initialize this TrackedChat.
+     */
+    getTracker(): LDAIConfigTracker;
+    /**
+     * Get the underlying AI provider instance.
+     * This provides direct access to the provider for advanced use cases.
+     */
+    getProvider(): AIProvider;
+    /**
+     * Get the judges associated with this TrackedChat.
+     * Returns a record of judge instances keyed by their configuration keys.
+     */
+    getJudges(): Record<string, Judge>;
+    /**
+     * Append messages to the conversation history.
+     * Adds messages to the conversation history without invoking the model,
+     * which is useful for managing multi-turn conversations or injecting context.
+     *
+     * @param messages Array of messages to append to the conversation history
+     */
+    appendMessages(messages: LDMessage[]): void;
+    /**
+     * Get all messages in the conversation history.
+     *
+     * @param includeConfigMessages Whether to include the config messages from the AIConfig.
+     *                              Defaults to false.
+     * @returns Array of messages. When includeConfigMessages is true, returns both config
+     *          messages and conversation history with config messages prepended. When false,
+     *          returns only the conversation history messages.
+     */
+    getMessages(includeConfigMessages?: boolean): LDMessage[];
+}
+
+/**
+ * List of supported AI providers.
+ */
+declare const SUPPORTED_AI_PROVIDERS: readonly ["openai", "langchain", "vercel"];
+/**
+ * Type representing the supported AI providers.
+ */
+type SupportedAIProvider = (typeof SUPPORTED_AI_PROVIDERS)[number];
+/**
+ * Factory for creating AIProvider instances based on the provider configuration.
+ */
+declare 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 create(aiConfig: LDAIConfigKind, logger?: LDLogger$1, defaultAiProvider?: SupportedAIProvider): Promise<AIProvider | undefined>;
+    /**
+     * Determine which providers to try based on defaultAiProvider and providerName.
+     */
+    private static _getProvidersToTry;
+    /**
+     * Try to create a provider of the specified type.
+     */
+    private static _tryCreateProvider;
+}
+
+/**
+ * Interface for performing AI operations using LaunchDarkly.
+ */
+interface LDAIClient {
+    /**
+     * Retrieves and processes a completion AI Config based on the provided key, LaunchDarkly context,
+     * and variables. This includes the model configuration and the customized messages.
+     *
+     * @param key The key of the AI Config.
+     * @param context The LaunchDarkly context object that contains relevant information about the
+     * current environment, user, or session. This context may influence how the configuration is
+     * processed or personalized.
+     * @param defaultValue A fallback value containing model configuration and messages. This will
+     * be used if the configuration is not available from LaunchDarkly.
+     * @param variables A map of key-value pairs representing dynamic variables to be injected into
+     * the message content. The keys correspond to placeholders within the template, and the values
+     * are the corresponding replacements.
+     *
+     * @returns The AI `config`, customized `messages`, and a `tracker`. If the configuration cannot be accessed from
+     * LaunchDarkly, then the return value will include information from the `defaultValue`. The returned `tracker` can
+     * be used to track AI operation metrics (latency, token usage, etc.).
+     *
+     * @example
+     * ```
+     * const key = "welcome_prompt";
+     * const context = {...};
+     * const variables = {username: 'john'};
+     * const defaultValue = {
+     *  enabled: false,
+     *  model: { name: 'gpt-4' },
+     *  provider: { name: 'openai' },
+     * };
+     *
+     * const result = completionConfig(key, context, defaultValue, variables);
+     * // Output:
+     * {
+     *   enabled: true,
+     *   config: {
+     *     modelId: "gpt-4o",
+     *     temperature: 0.2,
+     *     maxTokens: 4096,
+     *     userDefinedKey: "myValue",
+     *   },
+     *   messages: [
+     *     {
+     *       role: "system",
+     *       content: "You are an amazing GPT."
+     *     },
+     *     {
+     *       role: "user",
+     *       content: "Explain how you're an amazing GPT."
+     *     }
+     *   ],
+     *   tracker: ...
+     * }
+     * ```
+     */
+    completionConfig(key: string, context: LDContext, defaultValue: LDAICompletionConfigDefault, variables?: Record<string, unknown>): Promise<LDAICompletionConfig>;
+    /**
+     * @deprecated Use `completionConfig` instead. This method will be removed in a future version.
+     */
+    config(key: string, context: LDContext, defaultValue: LDAICompletionConfigDefault, variables?: Record<string, unknown>): Promise<LDAICompletionConfig>;
+    /**
+     * Retrieves and processes a single AI Config agent based on the provided key, LaunchDarkly context,
+     * and variables. This includes the model configuration and the customized instructions.
+     *
+     * @param key The key of the AI Config agent.
+     * @param context The LaunchDarkly context object that contains relevant information about the
+     * current environment, user, or session. This context may influence how the configuration is
+     * processed or personalized.
+     * @param defaultValue A fallback value containing model configuration and instructions.
+     * @param variables A map of key-value pairs representing dynamic variables to be injected into
+     * the instructions. The keys correspond to placeholders within the template, and the values
+     * are the corresponding replacements.
+     *
+     * @returns An AI agent with customized `instructions` and a `tracker`. If the configuration
+     * cannot be accessed from LaunchDarkly, then the return value will include information from the
+     * `defaultValue`. The returned `tracker` can be used to track AI operation metrics (latency, token usage, etc.).
+     *
+     * @example
+     * ```
+     * const key = "research_agent";
+     * const context = {...};
+     * const variables = { topic: 'climate change' };
+     * const agentConfig = await client.agentConfig(key, context, {
+     *   enabled: true,
+     *   model: { name: 'gpt-4' },
+     *   provider: { name: 'openai' },
+     *   instructions: 'You are a research assistant.',
+     * }, variables);
+     *
+     * const researchResult = agentConfig.instructions; // Interpolated instructions
+     * agentConfig.tracker.trackSuccess();
+     * ```
+     */
+    agentConfig(key: string, context: LDContext, defaultValue: LDAIAgentConfigDefault, variables?: Record<string, unknown>): Promise<LDAIAgentConfig>;
+    /**
+     * @deprecated Use `agentConfig` instead. This method will be removed in a future version.
+     */
+    agent(key: string, context: LDContext, defaultValue: LDAIAgentConfigDefault, variables?: Record<string, unknown>): Promise<LDAIAgentConfig>;
+    /**
+     * Retrieves and processes a Judge AI Config based on the provided key, LaunchDarkly context,
+     * and variables. This includes the model configuration and the customized messages for evaluation.
+     *
+     * @param key The key of the Judge AI Config.
+     * @param context The LaunchDarkly context object that contains relevant information about the
+     * current environment, user, or session. This context may influence how the configuration is
+     * processed or personalized.
+     * @param defaultValue A fallback value containing model configuration and messages. This will
+     * be used if the configuration is not available from LaunchDarkly.
+     * @param variables Optional variables for template interpolation in messages and instructions.
+     * @returns A promise that resolves to a tracked judge configuration.
+     *
+     * @example
+     * ```typescript
+     * const judgeConf = await client.judgeConfig(key, context, {
+     *   enabled: true,
+     *   model: { name: 'gpt-4' },
+     *   provider: { name: 'openai' },
+     *   evaluationMetricKeys: ['$ld:ai:judge:relevance'],
+     *   messages: [{ role: 'system', content: 'You are a relevance judge.' }]
+     * }, variables);
+     *
+     * const config = judgeConf.config; // Interpolated configuration
+     * judgeConf.tracker.trackSuccess();
+     * ```
+     */
+    judgeConfig(key: string, context: LDContext, defaultValue: LDAIJudgeConfigDefault, variables?: Record<string, unknown>): Promise<LDAIJudgeConfig>;
+    /**
+     * Retrieves and processes multiple AI Config agents based on the provided agent configurations
+     * and LaunchDarkly context. This includes the model configuration and the customized instructions.
+     *
+     * @param agentConfigs An array of agent configurations, each containing the agent key, default configuration,
+     * and variables for instructions interpolation.
+     * @param context The LaunchDarkly context object that contains relevant information about the
+     * current environment, user, or session. This context may influence how the configuration is
+     * processed or personalized.
+     *
+     * @returns A map of agent keys to their respective AI agents with customized `instructions` and `tracker`.
+     * If a configuration cannot be accessed from LaunchDarkly, then the return value will include information
+     * from the respective `defaultValue`. The returned `tracker` can be used to track AI operation metrics
+     * (latency, token usage, etc.).
+     *
+     * @example
+     * ```
+     * const agentConfigsList = [
+     *   {
+     *     key: 'research_agent',
+     *     defaultValue: {
+     *       enabled: true,
+     *       model: { name: 'gpt-4' },
+     *       provider: { name: 'openai' },
+     *       instructions: 'You are a research assistant.'
+     *     },
+     *     variables: { topic: 'climate change' }
+     *   },
+     *   {
+     *     key: 'writing_agent',
+     *     defaultValue: {
+     *       enabled: true,
+     *       model: { name: 'gpt-4' },
+     *       provider: { name: 'openai' },
+     *       instructions: 'You are a writing assistant.'
+     *     },
+     *     variables: { style: 'academic' }
+     *   }
+     * ] as const;
+     * const context = {...};
+     *
+     * const configs = await client.agentConfigs(agentConfigsList, context);
+     * const researchResult = configs["research_agent"].instructions; // Interpolated instructions
+     * configs["research_agent"].tracker.trackSuccess();
+     * ```
+     */
+    agentConfigs<const T extends readonly LDAIAgentRequestConfig[]>(agentConfigs: T, context: LDContext): Promise<Record<T[number]['key'], LDAIAgentConfig>>;
+    /**
+     * @deprecated Use `agentConfigs` instead. This method will be removed in a future version.
+     */
+    agents<const T extends readonly LDAIAgentRequestConfig[]>(agentConfigs: T, context: LDContext): Promise<Record<T[number]['key'], LDAIAgentConfig>>;
+    /**
+     * Returns a TrackedChat instance for chat interactions.
+     * This method serves as the primary entry point for creating TrackedChat instances from configuration.
+     *
+     * @param key The key identifying the AI chat configuration to use.
+     * @param context The standard LDContext used when evaluating flags.
+     * @param defaultValue A default value representing a standard AI chat config result.
+     * @param variables Dictionary of values for instruction interpolation.
+     * The variables will also be used for judge evaluation. For the judge only, the variables
+     * `message_history` and `response_to_evaluate` are reserved and will be ignored.
+     * @param defaultAiProvider Optional default AI provider to use.
+     * @returns A promise that resolves to the TrackedChat instance, or null if the configuration is disabled.
+     *
+     * @example
+     * ```
+     * const key = "customer_support_chat";
+     * const context = {...};
+     * const defaultValue = {
+     *   enabled: false,
+     *   model: { name: "gpt-4" },
+     *   provider: { name: "openai" },
+     *   messages: [
+     *     { role: "system", content: "You are a helpful customer support agent." }
+     *   ]
+     * };
+     * const variables = { customerName: 'John' };
+     *
+     * const chat = await client.createChat(key, context, defaultValue, variables);
+     * if (chat) {
+     *   const response = await chat.invoke("I need help with my order");
+     *   console.log(response.message.content);
+     * }
+     * ```
+     */
+    createChat(key: string, context: LDContext, defaultValue: LDAICompletionConfigDefault, variables?: Record<string, unknown>, defaultAiProvider?: SupportedAIProvider): Promise<TrackedChat | undefined>;
+    /**
+     * @deprecated Use `createChat` instead. This method will be removed in a future version.
+     */
+    initChat(key: string, context: LDContext, defaultValue: LDAICompletionConfigDefault, variables?: Record<string, unknown>, defaultAiProvider?: SupportedAIProvider): Promise<TrackedChat | undefined>;
+    /**
+     * Creates and returns a new Judge instance for AI evaluation.
+     *
+     * @param key The key identifying the AI judge configuration to use
+     * @param context Standard LDContext used when evaluating flags
+     * @param defaultValue A default value representing a standard AI config result
+     * @param variables Dictionary of values for instruction interpolation.
+     * The variables `message_history` and `response_to_evaluate` are reserved for the judge and will be ignored.
+     * @param defaultAiProvider Optional default AI provider to use.
+     * @returns Promise that resolves to a Judge instance or undefined if disabled/unsupported
+     *
+     * @example
+     * ```
+     * const judge = await client.createJudge(
+     *   "relevance-judge",
+     *   context,
+     *   {
+     *     enabled: true,
+     *     model: { name: "gpt-4" },
+     *     provider: { name: "openai" },
+     *     evaluationMetricKeys: ['$ld:ai:judge:relevance'],
+     *     messages: [{ role: 'system', content: 'You are a relevance judge.' }]
+     *   },
+     *   { metric: "relevance" }
+     * );
+     *
+     * if (judge) {
+     *   const result = await judge.evaluate("User question", "AI response");
+     *   console.log('Relevance score:', result.evals.relevance?.score);
+     * }
+     * ```
+     */
+    createJudge(key: string, context: LDContext, defaultValue: LDAIJudgeConfigDefault, variables?: Record<string, unknown>, defaultAiProvider?: SupportedAIProvider): Promise<Judge | undefined>;
+}
+
+/**
+ * Interface which represents the required interface components for a sever SDK
+ * to work with the AI SDK.
+ */
+interface LDClientMin {
+    variation(key: string, context: LDContext, defaultValue: LDFlagValue, callback?: (err: any, res: LDFlagValue) => void): Promise<LDFlagValue>;
+    track(key: string, context: LDContext, data?: any, metricValue?: number): void;
+    readonly logger?: LDLogger$1;
+}
+
+/**
+ * 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
+ */
+
+/**
+ * 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.
+ */
+declare function initAi(ldClient: LDClientMin): LDAIClient;
+type LDLogger = common.LDLogger;
+
+export { AIProvider, AIProviderFactory, type ChatResponse, type EvalScore, Judge, type JudgeResponse, type LDAIAgentConfig, type LDAIAgentConfigDefault, type LDAIAgentRequestConfig, type LDAIClient, type LDAICompletionConfig, type LDAICompletionConfigDefault, type LDAIConfig, type LDAIConfigDefault, type LDAIConfigDefaultKind, type LDAIConfigKind, type LDAIConfigMode, type LDAIConfigTracker, type LDAIJudgeConfig, type LDAIJudgeConfigDefault, type LDAIMetrics, LDFeedbackKind, type LDJudge, type LDJudgeConfiguration, type LDLogger, type LDMessage, type LDModelConfig, type LDProviderConfig, type LDTokenUsage, SUPPORTED_AI_PROVIDERS, type StructuredResponse, type SupportedAIProvider, TrackedChat, createBedrockTokenUsage, createOpenAiUsage, createVercelAISDKTokenUsage, initAi };