feat!: Remove AIProvider deprecated methods and create*/init* aliases (AIC-2388) (#1363)

Author: jsonbailey

packages/ai-providers/server-ai-langchain/README.md

@@ -20,7 +20,7 @@
 
 ## Quick Setup
 
-This package provides LangChain integration for the LaunchDarkly AI SDK. The simplest way to use it is with the LaunchDarkly AI SDK's `initChat` method:
+This package provides LangChain integration for the LaunchDarkly AI SDK. The simplest way to use it is with the LaunchDarkly AI SDK's `createModel` method:
 
 1. Install the required packages:
 
@@ -30,7 +30,7 @@ npm install @launchdarkly/server-sdk-ai @launchdarkly/server-sdk-ai-langchain --
 yarn add @launchdarkly/server-sdk-ai @launchdarkly/server-sdk-ai-langchain
 ```
 
-2. Create a chat session and use it:
+2. Create a managed model and run it:
 
 ```typescript
 import { init } from '@launchdarkly/node-server-sdk';
@@ -40,17 +40,17 @@ import { initAi } from '@launchdarkly/server-sdk-ai';
 const ldClient = init(sdkKey);
 const aiClient = initAi(ldClient);
 
-// Create a chat session
-const defaultConfig = { 
-  enabled: true, 
+// Create a managed model
+const defaultConfig = {
+  enabled: true,
   model: { name: 'gpt-4' },
   provider: { name: 'openai' }
 };
-const chat = await aiClient.initChat('my-chat-config', context, defaultConfig);
+const model = await aiClient.createModel('my-chat-config', context, defaultConfig);
 
-if (chat) {
-  const response = await chat.invoke('What is the capital of France?');
-  console.log(response.message.content);
+if (model) {
+  const result = await model.run('What is the capital of France?');
+  console.log(result.content);
 }
 ```
 

packages/ai-providers/server-ai-langchain/src/LangChainRunnerFactory.ts

@@ -29,7 +29,7 @@ export class LangChainRunnerFactory extends AIProvider {
    */
   async createModel(config: LDAICompletionConfig): Promise<LangChainModelRunner> {
     const llm = await createLangChainModel(config);
-    return new LangChainModelRunner(llm, config, this.logger);
+    return new LangChainModelRunner(llm, config, this._logger);
   }
 
   /**
@@ -51,7 +51,7 @@ export class LangChainRunnerFactory extends AIProvider {
     };
     const llm = await createLangChainModel(configForModel);
 
-    const lcTools = buildStructuredTools(toolDefinitions, tools ?? {}, this.logger);
+    const lcTools = buildStructuredTools(toolDefinitions, tools ?? {}, this._logger);
     const instructions = config.instructions ?? '';
 
     const agent = createAgent({
@@ -60,7 +60,7 @@ export class LangChainRunnerFactory extends AIProvider {
       systemPrompt: instructions || undefined,
     });
 
-    return new LangChainAgentRunner(agent as any, this.logger);
+    return new LangChainAgentRunner(agent as any, this._logger);
   }
 
   /**

packages/ai-providers/server-ai-openai/README.md

@@ -23,15 +23,15 @@
 
 ## Quick Setup
 
-This package provides OpenAI integration for the LaunchDarkly AI SDK. The simplest way to use it is with the LaunchDarkly AI SDK's `initChat` method:
+This package provides OpenAI integration for the LaunchDarkly AI SDK. The simplest way to use it is with the LaunchDarkly AI SDK's `createModel` method:
 
 1. Install the required packages:
 
 ```shell
 npm install @launchdarkly/server-sdk-ai @launchdarkly/server-sdk-ai-openai --save
 ```
 
-2. Create a chat session and use it:
+2. Create a managed model and run it:
 
 ```typescript
 import { init } from '@launchdarkly/node-server-sdk';
@@ -41,17 +41,17 @@ import { initAi } from '@launchdarkly/server-sdk-ai';
 const ldClient = init(sdkKey);
 const aiClient = initAi(ldClient);
 
-// Create a chat session
-const defaultConfig = { 
-  enabled: true, 
+// Create a managed model
+const defaultConfig = {
+  enabled: true,
   model: { name: 'gpt-4' },
   provider: { name: 'openai' }
 };
-const chat = await aiClient.initChat('my-chat-config', context, defaultConfig);
+const model = await aiClient.createModel('my-chat-config', context, defaultConfig);
 
-if (chat) {
-  const response = await chat.invoke("What is the capital of France?");
-  console.log(response.message.content);
+if (model) {
+  const result = await model.run('What is the capital of France?');
+  console.log(result.content);
 }
 ```
 

packages/ai-providers/server-ai-openai/src/OpenAIRunnerFactory.ts

@@ -30,7 +30,7 @@ export class OpenAIRunnerFactory extends AIProvider {
    * Create a model runner from a completion AI configuration.
    */
   async createModel(config: LDAICompletionConfig): Promise<OpenAIModelRunner> {
-    return new OpenAIModelRunner(this._client, config, this.logger);
+    return new OpenAIModelRunner(this._client, config, this._logger);
   }
 
   /**
@@ -67,7 +67,12 @@ export class OpenAIRunnerFactory extends AIProvider {
     const parameters = mapParameterKeys({ ...(config.model?.parameters ?? {}) });
     delete parameters.tools;
 
-    const { agentTools, toolNameMap } = buildAgentTools(toolHelper, configTools, registry, this.logger);
+    const { agentTools, toolNameMap } = buildAgentTools(
+      toolHelper,
+      configTools,
+      registry,
+      this._logger,
+    );
     const agent = new Agent({
       name: 'ldai-agent',
       instructions: config.instructions || undefined,
@@ -76,7 +81,7 @@ export class OpenAIRunnerFactory extends AIProvider {
       modelSettings: parameters,
     });
 
-    return new OpenAIAgentRunner(agent, agentRun, toolNameMap, this.logger);
+    return new OpenAIAgentRunner(agent, agentRun, toolNameMap, this._logger);
   }
 
   /**

packages/ai-providers/server-ai-vercel/README.md

@@ -20,7 +20,7 @@
 
 ## Quick Setup
 
-This package provides Vercel AI SDK integration for the LaunchDarkly AI SDK. The simplest way to use it is with the LaunchDarkly AI SDK's `initChat` method:
+This package provides Vercel AI SDK integration for the LaunchDarkly AI SDK. The simplest way to use it is with the LaunchDarkly AI SDK's `createModel` method:
 
 1. Install the required packages:
 
@@ -30,7 +30,7 @@ npm install @launchdarkly/server-sdk-ai @launchdarkly/server-sdk-ai-vercel --sav
 yarn add @launchdarkly/server-sdk-ai @launchdarkly/server-sdk-ai-vercel
 ```
 
-2. Create a chat session and use it:
+2. Create a managed model and run it:
 
 ```typescript
 import { init } from '@launchdarkly/node-server-sdk';
@@ -40,17 +40,17 @@ import { initAi } from '@launchdarkly/server-sdk-ai';
 const ldClient = init(sdkKey);
 const aiClient = initAi(ldClient);
 
-// Create a chat session
-const defaultConfig = { 
-  enabled: true, 
+// Create a managed model
+const defaultConfig = {
+  enabled: true,
   model: { name: 'gpt-4' },
   provider: { name: 'openai' }
 };
-const chat = await aiClient.initChat('my-chat-config', context, defaultConfig);
+const model = await aiClient.createModel('my-chat-config', context, defaultConfig);
 
-if (chat) {
-  const response = await chat.invoke('What is the capital of France?');
-  console.log(response.message.content);
+if (model) {
+  const result = await model.run('What is the capital of France?');
+  console.log(result.content);
 }
 ```
 

packages/ai-providers/server-ai-vercel/src/VercelRunnerFactory.ts

@@ -25,7 +25,7 @@ export class VercelRunnerFactory extends AIProvider {
   async createModel(config: LDAICompletionConfig): Promise<VercelModelRunner> {
     const model = await VercelRunnerFactory.createVercelModel(config);
     const parameters = VercelRunnerFactory.mapParameters(config.model?.parameters);
-    return new VercelModelRunner(model, config, parameters, this.logger);
+    return new VercelModelRunner(model, config, parameters, this._logger);
   }
 
   /**

packages/sdk/server-ai/README.md

@@ -79,37 +79,34 @@ if (aiConfig.enabled) {
 }
 ```
 
-## TrackedChat for Conversational AI
+## ManagedModel for Tracked Model Invocations
 
-`TrackedChat` provides a high-level interface for conversational AI with automatic conversation management and metrics tracking:
+`ManagedModel` provides a high-level interface for invoking AI models with automatic metrics tracking and judge evaluation:
 
 - Automatically configures models based on AI configuration
-- Maintains conversation history across multiple interactions
 - Automatically tracks token usage, latency, and success rates
+- Runs configured judges asynchronously and reports their results
 - Works with any supported AI provider (see [AI Providers](https://github.com/launchdarkly/js-core#ai-providers) for available packages)
 
-### Using TrackedChat
+### Using ManagedModel
 
 ```typescript
 // Use the same defaultConfig from the retrieval section above
-const chat = await aiClient.createChat(
+const model = await aiClient.createModel(
   'customer-support-chat',
   context,
   defaultConfig,
   { customerName: 'John' }
 );
 
-if (chat) {
-  // Simple conversation flow - metrics are automatically tracked by invoke()
-  const response1 = await chat.invoke('I need help with my order');
-  console.log(response1.message.content);
-  
-  const response2 = await chat.invoke("What's the status?");
-  console.log(response2.message.content);
-  
-  // Access conversation history
-  const messages = chat.getMessages();
-  console.log(`Conversation has ${messages.length} messages`);
+if (model) {
+  // Metrics are automatically tracked by run()
+  const result = await model.run('I need help with my order');
+  console.log(result.content);
+
+  // Judge evaluations run asynchronously; await if you need their results
+  const evals = await result.evaluations;
+  console.log('Judge results:', evals);
 }
 ```
 

packages/sdk/server-ai/__tests__/LDAIClientImpl.test.ts

@@ -692,7 +692,7 @@ describe('createJudge method', () => {
 
   beforeEach(() => {
     mockProvider = {
-      invokeStructuredModel: jest.fn(),
+      run: jest.fn(),
     };
 
     mockJudge = {

packages/sdk/server-ai/__tests__/RunnerFactory.test.ts

@@ -1,4 +1,7 @@
-import { LDAIConfigKind } from '../src/api/config/types';
+import {
+  LDAIAgentConfig,
+  LDAICompletionConfig,
+} from '../src/api/config/types';
 import { AIProvider, ToolRegistry } from '../src/api/providers/AIProvider';
 import { AgentGraphRunner, Runner } from '../src/api/providers/Runner';
 import { RunnerFactory, SupportedAIProvider } from '../src/api/providers/RunnerFactory';
@@ -7,14 +10,23 @@ import { RunnerFactory, SupportedAIProvider } from '../src/api/providers/RunnerF
 // Helpers
 // ---------------------------------------------------------------------------
 
-const makeConfig = (providerName: string): LDAIConfigKind =>
+const makeConfig = (providerName: string): LDAICompletionConfig =>
   ({
     key: 'test-config',
     enabled: true,
     provider: { name: providerName },
     createTracker: () => ({}) as any,
     evaluator: {} as any,
-  }) as unknown as LDAIConfigKind;
+  }) as unknown as LDAICompletionConfig;
+
+const makeAgentConfig = (providerName: string): LDAIAgentConfig =>
+  ({
+    key: 'test-agent-config',
+    enabled: true,
+    provider: { name: providerName },
+    createTracker: () => ({}) as any,
+    evaluator: {} as any,
+  }) as unknown as LDAIAgentConfig;
 
 const makeRunner = (): Runner => ({ run: jest.fn() });
 const makeGraphRunner = (): AgentGraphRunner => ({ run: jest.fn() });
@@ -162,7 +174,7 @@ describe('RunnerFactory.createAgent', () => {
 
     jest.spyOn(RunnerFactory as any, '_getProviderFactory').mockResolvedValue(mockFactory);
 
-    const result = await RunnerFactory.createAgent(makeConfig('openai'), tools);
+    const result = await RunnerFactory.createAgent(makeAgentConfig('openai'), tools);
 
     expect(result).toBe(runner);
     expect(mockFactory.createAgent).toHaveBeenCalledWith(
@@ -177,7 +189,11 @@ describe('RunnerFactory.createAgent', () => {
 
     jest.spyOn(RunnerFactory as any, '_getProviderFactory').mockResolvedValue(undefined);
 
-    const result = await RunnerFactory.createAgent(makeConfig('openai'), undefined, logger as any);
+    const result = await RunnerFactory.createAgent(
+      makeAgentConfig('openai'),
+      undefined,
+      logger as any,
+    );
 
     expect(result).toBeUndefined();
     expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('not supported'));
@@ -243,7 +259,7 @@ describe('AIProvider default factory methods', () => {
 
   it('createAgent returns undefined by default', async () => {
     const provider = new ConcreteProvider();
-    const result = await provider.createAgent(makeConfig('openai'));
+    const result = await provider.createAgent(makeAgentConfig('openai'));
     expect(result).toBeUndefined();
   });
 
@@ -252,25 +268,4 @@ describe('AIProvider default factory methods', () => {
     const result = await provider.createAgentGraph({} as any);
     expect(result).toBeUndefined();
   });
-
-  it('createModel warns when not overridden', async () => {
-    const warnSpy = jest.fn();
-    const provider = new ConcreteProvider({ warn: warnSpy } as any);
-    await provider.createModel(makeConfig('openai'));
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('createModel not implemented'));
-  });
-
-  it('createAgent warns when not overridden', async () => {
-    const warnSpy = jest.fn();
-    const provider = new ConcreteProvider({ warn: warnSpy } as any);
-    await provider.createAgent(makeConfig('openai'));
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('createAgent not implemented'));
-  });
-
-  it('createAgentGraph warns when not overridden', async () => {
-    const warnSpy = jest.fn();
-    const provider = new ConcreteProvider({ warn: warnSpy } as any);
-    await provider.createAgentGraph({} as any);
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('createAgentGraph not implemented'));
-  });
 });

packages/sdk/server-ai/examples/openai-observability/README.md

@@ -1,6 +1,6 @@
 # Provider-Specific Observability Example (OpenAI)
 
-This example shows how to use the LaunchDarkly observability plugin when calling an AI provider directly — without the higher-level `createChat` abstraction. It uses OpenAI as the provider, but the same pattern applies to any provider (Bedrock, Anthropic, Vercel AI SDK, etc.).
+This example shows how to use the LaunchDarkly observability plugin when calling an AI provider directly — without the higher-level `createModel` abstraction. It uses OpenAI as the provider, but the same pattern applies to any provider (Bedrock, Anthropic, Vercel AI SDK, etc.).
 
 ## How it works