@launchdarkly/server-sdk-ai 0.14.0 → 0.15.0

package/dist/index.cjs

@@ -0,0 +1,1117 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AIProvider: () => AIProvider,
+  AIProviderFactory: () => AIProviderFactory,
+  Judge: () => Judge,
+  LDFeedbackKind: () => LDFeedbackKind,
+  SUPPORTED_AI_PROVIDERS: () => SUPPORTED_AI_PROVIDERS,
+  TrackedChat: () => TrackedChat,
+  createBedrockTokenUsage: () => createBedrockTokenUsage,
+  createOpenAiUsage: () => createOpenAiUsage,
+  createVercelAISDKTokenUsage: () => createVercelAISDKTokenUsage,
+  initAi: () => initAi
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/LDAIClientImpl.ts
+var import_mustache2 = __toESM(require("mustache"), 1);
+
+// src/api/chat/TrackedChat.ts
+var TrackedChat = class {
+  constructor(aiConfig, tracker, provider, judges = {}, _logger) {
+    this.aiConfig = aiConfig;
+    this.tracker = tracker;
+    this.provider = provider;
+    this.judges = judges;
+    this._logger = _logger;
+    this.messages = [];
+  }
+  /**
+   * Invoke the chat model with a prompt string.
+   * This method handles conversation management and tracking, delegating to the provider's invokeModel method.
+   */
+  async invoke(prompt) {
+    const userMessage = {
+      role: "user",
+      content: prompt
+    };
+    this.messages.push(userMessage);
+    const configMessages = this.aiConfig.messages || [];
+    const allMessages = [...configMessages, ...this.messages];
+    const response = await this.tracker.trackMetricsOf(
+      (result) => result.metrics,
+      () => this.provider.invokeModel(allMessages)
+    );
+    if (this.aiConfig.judgeConfiguration?.judges && this.aiConfig.judgeConfiguration.judges.length > 0) {
+      response.evaluations = this._evaluateWithJudges(this.messages, response);
+    }
+    this.messages.push(response.message);
+    return response;
+  }
+  /**
+   * 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
+   */
+  async _evaluateWithJudges(messages, response) {
+    const judgeConfigs = this.aiConfig.judgeConfiguration.judges;
+    const evaluationPromises = judgeConfigs.map(async (judgeConfig) => {
+      const judge = this.judges[judgeConfig.key];
+      if (!judge) {
+        this._logger?.warn(
+          `Judge configuration is not enabled: ${judgeConfig.key}`,
+          this.tracker.getTrackData()
+        );
+        return void 0;
+      }
+      const judgeResponse = await judge.evaluateMessages(
+        messages,
+        response,
+        judgeConfig.samplingRate
+      );
+      if (judgeResponse && judgeResponse.success) {
+        this.tracker.trackJudgeResponse(judgeResponse);
+      }
+      return judgeResponse;
+    });
+    const results = await Promise.allSettled(evaluationPromises);
+    return results.map((result) => result.status === "fulfilled" ? result.value : void 0);
+  }
+  /**
+   * Get the underlying AI configuration used to initialize this TrackedChat.
+   */
+  getConfig() {
+    return this.aiConfig;
+  }
+  /**
+   * Get the underlying AI configuration tracker used to initialize this TrackedChat.
+   */
+  getTracker() {
+    return this.tracker;
+  }
+  /**
+   * Get the underlying AI provider instance.
+   * This provides direct access to the provider for advanced use cases.
+   */
+  getProvider() {
+    return this.provider;
+  }
+  /**
+   * Get the judges associated with this TrackedChat.
+   * Returns a record of judge instances keyed by their configuration keys.
+   */
+  getJudges() {
+    return this.judges;
+  }
+  /**
+   * 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) {
+    this.messages.push(...messages);
+  }
+  /**
+   * 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 = false) {
+    if (includeConfigMessages) {
+      const configMessages = this.aiConfig.messages || [];
+      return [...configMessages, ...this.messages];
+    }
+    return [...this.messages];
+  }
+};
+
+// src/api/config/LDAIConfigUtils.ts
+var LDAIConfigUtils = class {
+  /**
+   * Converts a default AI configuration to a LaunchDarkly flag value format.
+   *
+   * @param config The default AI configuration to convert
+   * @param mode The mode for the configuration
+   * @returns The flag value structure for LaunchDarkly
+   */
+  static toFlagValue(config, mode) {
+    const flagValue = {
+      _ldMeta: {
+        variationKey: "",
+        // Not available when converting from config
+        enabled: config.enabled ?? false,
+        mode
+      },
+      model: config.model
+    };
+    if ("messages" in config && config.messages !== void 0) {
+      flagValue.messages = config.messages;
+    }
+    if (config.provider !== void 0) {
+      flagValue.provider = config.provider;
+    }
+    if ("instructions" in config && config.instructions !== void 0) {
+      flagValue.instructions = config.instructions;
+    }
+    if ("evaluationMetricKeys" in config && config.evaluationMetricKeys !== void 0) {
+      flagValue.evaluationMetricKeys = config.evaluationMetricKeys;
+    }
+    if ("judgeConfiguration" in config && config.judgeConfiguration !== void 0) {
+      flagValue.judgeConfiguration = config.judgeConfiguration;
+    }
+    return flagValue;
+  }
+  /**
+   * Converts a LaunchDarkly flag value to the appropriate AI configuration type.
+   *
+   * @param flagValue The flag value from LaunchDarkly
+   * @param tracker The tracker to add to the config
+   * @returns The appropriate AI configuration type
+   */
+  static fromFlagValue(key, flagValue, tracker) {
+    const flagValueMode = flagValue._ldMeta?.mode;
+    switch (flagValueMode) {
+      case "agent":
+        return this.toAgentConfig(key, flagValue, tracker);
+      case "judge":
+        return this.toJudgeConfig(key, flagValue, tracker);
+      case "completion":
+      default:
+        return this.toCompletionConfig(key, flagValue, tracker);
+    }
+  }
+  /**
+   * Creates a disabled configuration of the specified mode.
+   *
+   * @param mode The mode for the disabled config
+   * @returns A disabled config of the appropriate type
+   */
+  static createDisabledConfig(key, mode) {
+    switch (mode) {
+      case "agent":
+        return {
+          key,
+          enabled: false,
+          tracker: void 0
+        };
+      case "judge":
+        return {
+          key,
+          enabled: false,
+          tracker: void 0,
+          evaluationMetricKeys: []
+        };
+      case "completion":
+      default:
+        return {
+          key,
+          enabled: false,
+          tracker: void 0
+        };
+    }
+  }
+  /**
+   * Creates the base configuration that all config types share.
+   *
+   * @param flagValue The flag value from LaunchDarkly
+   * @returns Base configuration object
+   */
+  static _toBaseConfig(key, flagValue) {
+    return {
+      key,
+      // eslint-disable-next-line no-underscore-dangle
+      enabled: flagValue._ldMeta?.enabled ?? false,
+      model: flagValue.model,
+      provider: flagValue.provider
+    };
+  }
+  /**
+   * Creates a completion config from flag value data.
+   *
+   * @param flagValue The flag value from LaunchDarkly
+   * @param tracker The tracker to add to the config
+   * @returns A completion configuration
+   */
+  static toCompletionConfig(key, flagValue, tracker) {
+    return {
+      ...this._toBaseConfig(key, flagValue),
+      tracker,
+      messages: flagValue.messages,
+      judgeConfiguration: flagValue.judgeConfiguration
+    };
+  }
+  /**
+   * Creates an agent config from flag value data.
+   *
+   * @param flagValue The flag value from LaunchDarkly
+   * @param tracker The tracker to add to the config
+   * @returns An agent configuration
+   */
+  static toAgentConfig(key, flagValue, tracker) {
+    return {
+      ...this._toBaseConfig(key, flagValue),
+      tracker,
+      instructions: flagValue.instructions,
+      judgeConfiguration: flagValue.judgeConfiguration
+    };
+  }
+  /**
+   * Creates a judge config from flag value data.
+   *
+   * @param flagValue The flag value from LaunchDarkly
+   * @param tracker The tracker to add to the config
+   * @returns A judge configuration
+   */
+  static toJudgeConfig(key, flagValue, tracker) {
+    return {
+      ...this._toBaseConfig(key, flagValue),
+      tracker,
+      messages: flagValue.messages,
+      evaluationMetricKeys: flagValue.evaluationMetricKeys || []
+    };
+  }
+};
+
+// src/api/judge/Judge.ts
+var import_mustache = __toESM(require("mustache"), 1);
+
+// src/api/judge/EvaluationSchemaBuilder.ts
+var EvaluationSchemaBuilder = class {
+  static build(evaluationMetricKeys) {
+    return {
+      type: "object",
+      properties: {
+        evaluations: {
+          type: "object",
+          description: `Object containing evaluation results for ${evaluationMetricKeys.join(", ")} metrics`,
+          properties: this._buildKeyProperties(evaluationMetricKeys),
+          required: evaluationMetricKeys,
+          additionalProperties: false
+        }
+      },
+      required: ["evaluations"],
+      additionalProperties: false
+    };
+  }
+  static _buildKeyProperties(evaluationMetricKeys) {
+    return evaluationMetricKeys.reduce(
+      (acc, key) => {
+        acc[key] = this._buildKeySchema(key);
+        return acc;
+      },
+      {}
+    );
+  }
+  static _buildKeySchema(key) {
+    return {
+      type: "object",
+      properties: {
+        score: {
+          type: "number",
+          minimum: 0,
+          maximum: 1,
+          description: `Score between 0.0 and 1.0 for ${key}`
+        },
+        reasoning: {
+          type: "string",
+          description: `Reasoning behind the score for ${key}`
+        }
+      },
+      required: ["score", "reasoning"],
+      additionalProperties: false
+    };
+  }
+};
+
+// src/api/judge/Judge.ts
+var Judge = class {
+  constructor(_aiConfig, _aiConfigTracker, _aiProvider, logger) {
+    this._aiConfig = _aiConfig;
+    this._aiConfigTracker = _aiConfigTracker;
+    this._aiProvider = _aiProvider;
+    this._logger = logger;
+    this._evaluationResponseStructure = EvaluationSchemaBuilder.build(
+      this._aiConfig.evaluationMetricKeys
+    );
+  }
+  /**
+   * 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
+   */
+  async evaluate(input, output, samplingRate = 1) {
+    try {
+      if (!this._aiConfig.evaluationMetricKeys || this._aiConfig.evaluationMetricKeys.length === 0) {
+        this._logger?.warn(
+          "Judge configuration is missing required evaluationMetricKeys",
+          this._aiConfigTracker.getTrackData()
+        );
+        return void 0;
+      }
+      if (!this._aiConfig.messages) {
+        this._logger?.warn(
+          "Judge configuration must include messages",
+          this._aiConfigTracker.getTrackData()
+        );
+        return void 0;
+      }
+      if (Math.random() > samplingRate) {
+        this._logger?.debug(`Judge evaluation skipped due to sampling rate: ${samplingRate}`);
+        return void 0;
+      }
+      const messages = this._constructEvaluationMessages(input, output);
+      const response = await this._aiConfigTracker.trackMetricsOf(
+        (result) => result.metrics,
+        () => this._aiProvider.invokeStructuredModel(messages, this._evaluationResponseStructure)
+      );
+      let { success } = response.metrics;
+      const evals = this._parseEvaluationResponse(response.data);
+      if (Object.keys(evals).length !== this._aiConfig.evaluationMetricKeys.length) {
+        this._logger?.warn(
+          "Judge evaluation did not return all evaluations",
+          this._aiConfigTracker.getTrackData()
+        );
+        success = false;
+      }
+      return {
+        evals,
+        success,
+        judgeConfigKey: this._aiConfig.key
+      };
+    } catch (error) {
+      this._logger?.error("Judge evaluation failed:", error);
+      return {
+        evals: {},
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+        judgeConfigKey: this._aiConfig.key
+      };
+    }
+  }
+  /**
+   * 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
+   */
+  async evaluateMessages(messages, response, samplingRatio = 1) {
+    const input = messages.length === 0 ? "" : messages.map((msg) => msg.content).join("\r\n");
+    const output = response.message.content;
+    return this.evaluate(input, output, samplingRatio);
+  }
+  /**
+   * Returns the AI Config used by this judge.
+   */
+  getAIConfig() {
+    return this._aiConfig;
+  }
+  /**
+   * Returns the tracker associated with this judge.
+   */
+  getTracker() {
+    return this._aiConfigTracker;
+  }
+  /**
+   * Returns the AI provider used by this judge.
+   */
+  getProvider() {
+    return this._aiProvider;
+  }
+  /**
+   * Constructs evaluation messages by combining judge's config messages with input/output.
+   */
+  _constructEvaluationMessages(input, output) {
+    const messages = this._aiConfig.messages.map((msg) => ({
+      ...msg,
+      content: this._interpolateMessage(msg.content, {
+        message_history: input,
+        response_to_evaluate: output
+      })
+    }));
+    return messages;
+  }
+  /**
+   * Interpolates message content with variables using Mustache templating.
+   */
+  _interpolateMessage(content, variables) {
+    return import_mustache.default.render(content, variables, void 0, { escape: (item) => item });
+  }
+  /**
+   * Parses the structured evaluation response from the AI provider.
+   */
+  _parseEvaluationResponse(data) {
+    const evaluations = data.evaluations;
+    const results = {};
+    if (!data.evaluations || typeof data.evaluations !== "object") {
+      this._logger?.warn("Invalid response: missing or invalid evaluations object");
+      return results;
+    }
+    this._aiConfig.evaluationMetricKeys.forEach((metricKey) => {
+      const evaluation = evaluations[metricKey];
+      if (!evaluation || typeof evaluation !== "object") {
+        this._logger?.warn(
+          `Missing evaluation for metric key: ${metricKey}`,
+          this._aiConfigTracker.getTrackData()
+        );
+        return;
+      }
+      const evalData = evaluation;
+      if (typeof evalData.score !== "number" || evalData.score < 0 || evalData.score > 1) {
+        this._logger?.warn(
+          `Invalid score evaluated for ${metricKey}: ${evalData.score}. Score must be a number between 0 and 1 inclusive`,
+          this._aiConfigTracker.getTrackData()
+        );
+        return;
+      }
+      if (typeof evalData.reasoning !== "string") {
+        this._logger?.warn(
+          `Invalid reasoning evaluated for ${metricKey}: ${evalData.reasoning}. Reasoning must be a string`,
+          this._aiConfigTracker.getTrackData()
+        );
+        return;
+      }
+      results[metricKey] = {
+        score: evalData.score,
+        reasoning: evalData.reasoning
+      };
+    });
+    return results;
+  }
+};
+
+// src/api/providers/AIProvider.ts
+var AIProvider = class {
+  constructor(logger) {
+    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) {
+    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, _responseStructure) {
+    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, logger) {
+    throw new Error("Provider implementations must override the static create method");
+  }
+};
+
+// src/api/providers/AIProviderFactory.ts
+var SUPPORTED_AI_PROVIDERS = [
+  "openai",
+  // Multi-provider packages should be last in the list
+  "langchain",
+  "vercel"
+];
+var AIProviderFactory = class {
+  /**
+   * 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, logger, defaultAiProvider) {
+    const providerName = aiConfig.provider?.name?.toLowerCase();
+    const providersToTry = this._getProvidersToTry(defaultAiProvider, providerName);
+    for (const providerType of providersToTry) {
+      logger?.debug(
+        `Attempting to create AIProvider for: ${aiConfig.provider?.name} with provider type: ${providerType}`
+      );
+      const provider = await this._tryCreateProvider(providerType, aiConfig, logger);
+      if (provider) {
+        logger?.debug(`Successfully created AIProvider for: ${aiConfig.provider?.name}`);
+        return provider;
+      }
+    }
+    logger?.warn(
+      `Provider is not supported or failed to initialize: ${aiConfig.provider?.name ?? "unknown"}`
+    );
+    return void 0;
+  }
+  /**
+   * Determine which providers to try based on defaultAiProvider and providerName.
+   */
+  static _getProvidersToTry(defaultAiProvider, providerName) {
+    if (defaultAiProvider) {
+      return [defaultAiProvider];
+    }
+    const providerSet = /* @__PURE__ */ new Set();
+    if (providerName && SUPPORTED_AI_PROVIDERS.includes(providerName)) {
+      providerSet.add(providerName);
+    }
+    const multiProviderPackages = ["langchain", "vercel"];
+    multiProviderPackages.forEach((provider) => {
+      providerSet.add(provider);
+    });
+    return Array.from(providerSet);
+  }
+  /**
+   * Try to create a provider of the specified type.
+   */
+  static async _tryCreateProvider(providerType, aiConfig, logger) {
+    try {
+      let module2;
+      switch (providerType) {
+        case "openai": {
+          module2 = await import("@launchdarkly/server-sdk-ai-openai");
+          const provider = await module2.OpenAIProvider.create(aiConfig, logger);
+          return provider;
+        }
+        case "langchain": {
+          module2 = await import("@launchdarkly/server-sdk-ai-langchain");
+          const provider = await module2.LangChainProvider.create(aiConfig, logger);
+          return provider;
+        }
+        case "vercel": {
+          module2 = await import("@launchdarkly/server-sdk-ai-vercel");
+          const provider = await module2.VercelProvider.create(aiConfig, logger);
+          return provider;
+        }
+        default:
+          return void 0;
+      }
+    } catch (error) {
+      logger?.warn(
+        `Unable to create AIProvider. Check that you have installed the correct package. ${error.message}`
+      );
+      return void 0;
+    }
+  }
+};
+
+// src/api/metrics/BedrockTokenUsage.ts
+function createBedrockTokenUsage(data) {
+  return {
+    total: data.totalTokens || 0,
+    input: data.inputTokens || 0,
+    output: data.outputTokens || 0
+  };
+}
+
+// src/api/metrics/OpenAiUsage.ts
+function createOpenAiUsage(data) {
+  return {
+    total: data.total_tokens ?? 0,
+    input: data.prompt_tokens ?? 0,
+    output: data.completion_tokens ?? 0
+  };
+}
+
+// src/api/metrics/LDFeedbackKind.ts
+var LDFeedbackKind = /* @__PURE__ */ ((LDFeedbackKind2) => {
+  LDFeedbackKind2["Positive"] = "positive";
+  LDFeedbackKind2["Negative"] = "negative";
+  return LDFeedbackKind2;
+})(LDFeedbackKind || {});
+
+// src/api/metrics/VercelAISDKTokenUsage.ts
+function createVercelAISDKTokenUsage(data) {
+  return {
+    total: data.totalTokens ?? 0,
+    input: data.inputTokens ?? data.promptTokens ?? 0,
+    output: data.outputTokens ?? data.completionTokens ?? 0
+  };
+}
+
+// src/sdkInfo.ts
+var aiSdkName = "@launchdarkly/server-sdk-ai";
+var aiSdkVersion = "0.15.0";
+
+// src/LDAIConfigTrackerImpl.ts
+var LDAIConfigTrackerImpl = class {
+  constructor(_ldClient, _configKey, _variationKey, _version, _modelName, _providerName, _context) {
+    this._ldClient = _ldClient;
+    this._configKey = _configKey;
+    this._variationKey = _variationKey;
+    this._version = _version;
+    this._modelName = _modelName;
+    this._providerName = _providerName;
+    this._context = _context;
+    this._trackedMetrics = {};
+  }
+  getTrackData() {
+    return {
+      variationKey: this._variationKey,
+      configKey: this._configKey,
+      version: this._version,
+      modelName: this._modelName,
+      providerName: this._providerName,
+      aiSdkName,
+      aiSdkVersion
+    };
+  }
+  trackDuration(duration) {
+    this._trackedMetrics.durationMs = duration;
+    this._ldClient.track("$ld:ai:duration:total", this._context, this.getTrackData(), duration);
+  }
+  async trackDurationOf(func) {
+    const startTime = Date.now();
+    try {
+      const result = await func();
+      return result;
+    } finally {
+      const endTime = Date.now();
+      const duration = endTime - startTime;
+      this.trackDuration(duration);
+    }
+  }
+  trackTimeToFirstToken(timeToFirstTokenMs) {
+    this._trackedMetrics.timeToFirstTokenMs = timeToFirstTokenMs;
+    this._ldClient.track(
+      "$ld:ai:tokens:ttf",
+      this._context,
+      this.getTrackData(),
+      timeToFirstTokenMs
+    );
+  }
+  trackEvalScores(scores) {
+    Object.entries(scores).forEach(([metricKey, evalScore]) => {
+      this._ldClient.track(metricKey, this._context, this.getTrackData(), evalScore.score);
+    });
+  }
+  trackJudgeResponse(response) {
+    Object.entries(response.evals).forEach(([metricKey, evalScore]) => {
+      this._ldClient.track(
+        metricKey,
+        this._context,
+        { ...this.getTrackData(), judgeConfigKey: response.judgeConfigKey },
+        evalScore.score
+      );
+    });
+  }
+  trackFeedback(feedback) {
+    this._trackedMetrics.feedback = feedback;
+    if (feedback.kind === "positive" /* Positive */) {
+      this._ldClient.track("$ld:ai:feedback:user:positive", this._context, this.getTrackData(), 1);
+    } else if (feedback.kind === "negative" /* Negative */) {
+      this._ldClient.track("$ld:ai:feedback:user:negative", this._context, this.getTrackData(), 1);
+    }
+  }
+  trackSuccess() {
+    this._trackedMetrics.success = true;
+    this._ldClient.track("$ld:ai:generation:success", this._context, this.getTrackData(), 1);
+  }
+  trackError() {
+    this._trackedMetrics.success = false;
+    this._ldClient.track("$ld:ai:generation:error", this._context, this.getTrackData(), 1);
+  }
+  async trackMetricsOf(metricsExtractor, func) {
+    let result;
+    try {
+      result = await this.trackDurationOf(func);
+    } catch (err) {
+      this.trackError();
+      throw err;
+    }
+    const metrics = metricsExtractor(result);
+    if (metrics.success) {
+      this.trackSuccess();
+    } else {
+      this.trackError();
+    }
+    if (metrics.usage) {
+      this.trackTokens(metrics.usage);
+    }
+    return result;
+  }
+  trackStreamMetricsOf(streamCreator, metricsExtractor) {
+    const startTime = Date.now();
+    try {
+      const stream = streamCreator();
+      this._trackStreamMetricsInBackground(stream, metricsExtractor, startTime);
+      return stream;
+    } catch (error) {
+      this.trackDuration(Date.now() - startTime);
+      this.trackError();
+      throw error;
+    }
+  }
+  async _trackStreamMetricsInBackground(stream, metricsExtractor, startTime) {
+    try {
+      const metrics = await metricsExtractor(stream);
+      if (metrics.success) {
+        this.trackSuccess();
+      } else {
+        this.trackError();
+      }
+      if (metrics.usage) {
+        this.trackTokens(metrics.usage);
+      }
+    } catch (error) {
+      this.trackError();
+    } finally {
+      this.trackDuration(Date.now() - startTime);
+    }
+  }
+  async trackOpenAIMetrics(func) {
+    try {
+      const result = await this.trackDurationOf(func);
+      this.trackSuccess();
+      if (result.usage) {
+        this.trackTokens(createOpenAiUsage(result.usage));
+      }
+      return result;
+    } catch (err) {
+      this.trackError();
+      throw err;
+    }
+  }
+  trackBedrockConverseMetrics(res) {
+    if (res.$metadata?.httpStatusCode === 200) {
+      this.trackSuccess();
+    } else if (res.$metadata?.httpStatusCode && res.$metadata.httpStatusCode >= 400) {
+      this.trackError();
+    }
+    if (res.metrics && res.metrics.latencyMs) {
+      this.trackDuration(res.metrics.latencyMs);
+    }
+    if (res.usage) {
+      this.trackTokens(createBedrockTokenUsage(res.usage));
+    }
+    return res;
+  }
+  async trackVercelAISDKGenerateTextMetrics(func) {
+    try {
+      const result = await this.trackDurationOf(func);
+      this.trackSuccess();
+      if (result.usage) {
+        this.trackTokens(createVercelAISDKTokenUsage(result.usage));
+      }
+      return result;
+    } catch (err) {
+      this.trackError();
+      throw err;
+    }
+  }
+  trackTokens(tokens) {
+    this._trackedMetrics.tokens = tokens;
+    const trackData = this.getTrackData();
+    if (tokens.total > 0) {
+      this._ldClient.track("$ld:ai:tokens:total", this._context, trackData, tokens.total);
+    }
+    if (tokens.input > 0) {
+      this._ldClient.track("$ld:ai:tokens:input", this._context, trackData, tokens.input);
+    }
+    if (tokens.output > 0) {
+      this._ldClient.track("$ld:ai:tokens:output", this._context, trackData, tokens.output);
+    }
+  }
+  /**
+   * Get a summary of the tracked metrics.
+   */
+  getSummary() {
+    return { ...this._trackedMetrics };
+  }
+};
+
+// src/LDAIClientImpl.ts
+var TRACK_CONFIG_SINGLE = "$ld:ai:config:function:single";
+var TRACK_CONFIG_CREATE_CHAT = "$ld:ai:config:function:createChat";
+var TRACK_JUDGE_SINGLE = "$ld:ai:judge:function:single";
+var TRACK_JUDGE_CREATE = "$ld:ai:judge:function:createJudge";
+var TRACK_AGENT_SINGLE = "$ld:ai:agent:function:single";
+var TRACK_AGENT_MULTIPLE = "$ld:ai:agent:function:multiple";
+var LDAIClientImpl = class {
+  constructor(_ldClient) {
+    this._ldClient = _ldClient;
+    this._logger = _ldClient.logger;
+  }
+  _interpolateTemplate(template, variables) {
+    return import_mustache2.default.render(template, variables, void 0, { escape: (item) => item });
+  }
+  async _evaluate(key, context, defaultValue, mode, variables) {
+    const ldFlagValue = LDAIConfigUtils.toFlagValue(defaultValue, mode);
+    const value = await this._ldClient.variation(key, context, ldFlagValue);
+    const flagMode = value._ldMeta?.mode ?? "completion";
+    if (flagMode !== mode) {
+      this._logger?.warn(
+        `AI Config mode mismatch for ${key}: expected ${mode}, got ${flagMode}. Returning disabled config.`
+      );
+      return LDAIConfigUtils.createDisabledConfig(key, mode);
+    }
+    const tracker = new LDAIConfigTrackerImpl(
+      this._ldClient,
+      key,
+      // eslint-disable-next-line no-underscore-dangle
+      value._ldMeta?.variationKey ?? "",
+      // eslint-disable-next-line no-underscore-dangle
+      value._ldMeta?.version ?? 1,
+      value.model?.name ?? "",
+      value.provider?.name ?? "",
+      context
+    );
+    const config = LDAIConfigUtils.fromFlagValue(key, value, tracker);
+    return this._applyInterpolation(config, context, variables);
+  }
+  _applyInterpolation(config, context, variables) {
+    const allVariables = { ...variables, ldctx: context };
+    if ("messages" in config && config.messages) {
+      return {
+        ...config,
+        messages: config.messages.map((entry) => ({
+          ...entry,
+          content: this._interpolateTemplate(entry.content, allVariables)
+        }))
+      };
+    }
+    if ("instructions" in config && config.instructions) {
+      return {
+        ...config,
+        instructions: this._interpolateTemplate(config.instructions, allVariables)
+      };
+    }
+    return config;
+  }
+  async _initializeJudges(judgeConfigs, context, variables, defaultAiProvider) {
+    const judges = {};
+    const judgePromises = judgeConfigs.map(async (judgeConfig) => {
+      const judge = await this.createJudge(
+        judgeConfig.key,
+        context,
+        { enabled: false },
+        variables,
+        defaultAiProvider
+      );
+      return judge ? { key: judgeConfig.key, judge } : null;
+    });
+    const results = await Promise.all(judgePromises);
+    results.forEach((result) => {
+      if (result) {
+        judges[result.key] = result.judge;
+      }
+    });
+    return judges;
+  }
+  async completionConfig(key, context, defaultValue, variables) {
+    this._ldClient.track(TRACK_CONFIG_SINGLE, context, key, 1);
+    const config = await this._evaluate(key, context, defaultValue, "completion", variables);
+    return config;
+  }
+  /**
+   * @deprecated Use `completionConfig` instead. This method will be removed in a future version.
+   */
+  async config(key, context, defaultValue, variables) {
+    return this.completionConfig(key, context, defaultValue, variables);
+  }
+  async judgeConfig(key, context, defaultValue, variables) {
+    this._ldClient.track(TRACK_JUDGE_SINGLE, context, key, 1);
+    const config = await this._evaluate(key, context, defaultValue, "judge", variables);
+    return config;
+  }
+  async agentConfig(key, context, defaultValue, variables) {
+    this._ldClient.track(TRACK_AGENT_SINGLE, context, key, 1);
+    const config = await this._evaluate(key, context, defaultValue, "agent", variables);
+    return config;
+  }
+  /**
+   * @deprecated Use `agentConfig` instead. This method will be removed in a future version.
+   */
+  async agent(key, context, defaultValue, variables) {
+    return this.agentConfig(key, context, defaultValue, variables);
+  }
+  async agentConfigs(agentConfigs, context) {
+    this._ldClient.track(TRACK_AGENT_MULTIPLE, context, agentConfigs.length, agentConfigs.length);
+    const agents = {};
+    await Promise.all(
+      agentConfigs.map(async (config) => {
+        const agent = await this._evaluate(
+          config.key,
+          context,
+          config.defaultValue,
+          "agent",
+          config.variables
+        );
+        agents[config.key] = agent;
+      })
+    );
+    return agents;
+  }
+  /**
+   * @deprecated Use `agentConfigs` instead. This method will be removed in a future version.
+   */
+  async agents(agentConfigs, context) {
+    return this.agentConfigs(agentConfigs, context);
+  }
+  async createChat(key, context, defaultValue, variables, defaultAiProvider) {
+    this._ldClient.track(TRACK_CONFIG_CREATE_CHAT, context, key, 1);
+    const config = await this.completionConfig(key, context, defaultValue, variables);
+    if (!config.enabled || !config.tracker) {
+      this._logger?.info(`Chat configuration is disabled: ${key}`);
+      return void 0;
+    }
+    const provider = await AIProviderFactory.create(config, this._logger, defaultAiProvider);
+    if (!provider) {
+      return void 0;
+    }
+    const judges = await this._initializeJudges(
+      config.judgeConfiguration?.judges ?? [],
+      context,
+      variables,
+      defaultAiProvider
+    );
+    return new TrackedChat(config, config.tracker, provider, judges, this._logger);
+  }
+  async createJudge(key, context, defaultValue, variables, defaultAiProvider) {
+    this._ldClient.track(TRACK_JUDGE_CREATE, context, key, 1);
+    try {
+      if (variables?.message_history !== void 0) {
+        this._logger?.warn(
+          "The variable 'message_history' is reserved by the judge and will be ignored."
+        );
+      }
+      if (variables?.response_to_evaluate !== void 0) {
+        this._logger?.warn(
+          "The variable 'response_to_evaluate' is reserved by the judge and will be ignored."
+        );
+      }
+      const extendedVariables = {
+        ...variables,
+        message_history: "{{message_history}}",
+        response_to_evaluate: "{{response_to_evaluate}}"
+      };
+      const judgeConfig = await this.judgeConfig(key, context, defaultValue, extendedVariables);
+      if (!judgeConfig.enabled || !judgeConfig.tracker) {
+        this._logger?.info(`Judge configuration is disabled: ${key}`);
+        return void 0;
+      }
+      const provider = await AIProviderFactory.create(judgeConfig, this._logger, defaultAiProvider);
+      if (!provider) {
+        return void 0;
+      }
+      return new Judge(judgeConfig, judgeConfig.tracker, provider, this._logger);
+    } catch (error) {
+      this._logger?.error(`Failed to initialize judge ${key}:`, error);
+      return void 0;
+    }
+  }
+  /**
+   * @deprecated Use `createChat` instead. This method will be removed in a future version.
+   */
+  async initChat(key, context, defaultValue, variables, defaultAiProvider) {
+    return this.createChat(key, context, defaultValue, variables, defaultAiProvider);
+  }
+};
+
+// src/index.ts
+function initAi(ldClient) {
+  return new LDAIClientImpl(ldClient);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AIProvider,
+  AIProviderFactory,
+  Judge,
+  LDFeedbackKind,
+  SUPPORTED_AI_PROVIDERS,
+  TrackedChat,
+  createBedrockTokenUsage,
+  createOpenAiUsage,
+  createVercelAISDKTokenUsage,
+  initAi
+});
+//# sourceMappingURL=index.cjs.map