feat(ai-proxy): use LangChain for unified provider interface

- Replace native Mistral SDK with @langchain/mistralai
- Add @langchain/openai for OpenAI provider
- Both providers return AIMessage, converted to OpenAI format
- Simplifies adding new providers in the future

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: alban bertolini

packages/_example/package.json

@@ -5,7 +5,7 @@
   "private": true,
   "dependencies": {
     "@faker-js/faker": "^7.6.0",
-    "@forestadmin/agent": "file:../agent",
+    "@forestadmin/agent": "1.66.2",
     "@forestadmin/datasource-dummy": "1.1.59",
     "@forestadmin/datasource-mongo": "1.5.4",
     "@forestadmin/datasource-mongoose": "1.12.4",

packages/_example/src/forest/agent.ts

@@ -81,7 +81,7 @@ export default function makeAgent() {
     })
     .addAI({
       model: 'ministral-8b-2512',
-      provider: 'mistral',
+      provider: 'openai',
       apiKey: process.env.MISTRAL_API_KEY,
     })
 

packages/ai-proxy/package.json

@@ -18,7 +18,8 @@
     "@langchain/core": "1.1.4",
     "@langchain/langgraph": "1.0.4",
     "@langchain/mcp-adapters": "1.0.3",
-    "@mistralai/mistralai": "^1.3.0"
+    "@langchain/openai": "^1.2.0",
+    "@langchain/mistralai": "^1.0.2"
   },
   "devDependencies": {
     "@modelcontextprotocol/sdk": "1.20.0",

packages/ai-proxy/src/provider-dispatcher.ts

@@ -2,8 +2,9 @@ import type { RemoteTools } from './remote-tools';
 import type { ClientOptions } from 'openai';
 import type { ChatCompletionCreateParamsNonStreaming } from 'openai/resources/chat/completions';
 
-import { Mistral } from '@mistralai/mistralai';
-import OpenAI from 'openai';
+import { AIMessage } from '@langchain/core/messages';
+import { ChatMistralAI } from '@langchain/mistralai';
+import { ChatOpenAI } from '@langchain/openai';
 
 import {
   AINotConfiguredError,
@@ -13,7 +14,8 @@ import {
 
 export type OpenAiConfiguration = ClientOptions & {
   provider: 'openai';
-  model: ChatCompletionCreateParamsNonStreaming['model'] | string;
+  // (string & NonNullable<unknown>) allows custom models while preserving autocomplete for known models
+  model: ChatCompletionCreateParamsNonStreaming['model'] | (string & NonNullable<unknown>);
 };
 
 export type MistralConfiguration = {
@@ -33,10 +35,15 @@ export type OpenAIBody = Pick<
 
 export type DispatchBody = OpenAIBody;
 
+type LangChainClient = {
+  invoke: (messages: unknown) => Promise<AIMessage>;
+  bindTools: (tools: unknown, options?: unknown) => LangChainClient;
+};
+
 export class ProviderDispatcher {
-  private readonly openAiClient: OpenAI | null = null;
+  private readonly client: LangChainClient | null = null;
 
-  private readonly mistralClient: Mistral | null = null;
+  private readonly provider: AiProvider | null = null;
 
   private readonly model: string;
 
@@ -45,129 +52,97 @@ export class ProviderDispatcher {
   constructor(configuration: AiConfiguration | null, remoteTools: RemoteTools) {
     this.remoteTools = remoteTools;
     this.model = configuration?.model ?? '';
+    this.provider = configuration?.provider ?? null;
 
     if (configuration?.provider === 'openai' && configuration.apiKey) {
-      const { provider, model, ...clientOptions } = configuration;
-      this.openAiClient = new OpenAI(clientOptions);
+      const { provider, model, apiKey, ...clientOptions } = configuration;
+      this.client = new ChatOpenAI({
+        apiKey,
+        model,
+        configuration: clientOptions,
+      }) as unknown as LangChainClient;
     }
 
     if (configuration?.provider === 'mistral' && configuration.apiKey) {
-      this.mistralClient = new Mistral({ apiKey: configuration.apiKey });
+      this.client = new ChatMistralAI({
+        apiKey: configuration.apiKey,
+        model: configuration.model,
+      }) as unknown as LangChainClient;
     }
   }
 
   async dispatch(body: DispatchBody): Promise<unknown> {
-    if (this.openAiClient) {
-      return this.dispatchOpenAI(body);
-    }
-
-    if (this.mistralClient) {
-      return this.dispatchMistral(body);
+    if (!this.client) {
+      throw new AINotConfiguredError();
     }
 
-    throw new AINotConfiguredError();
-  }
-
-  private async dispatchOpenAI(body: DispatchBody): Promise<unknown> {
     const { tools, messages, tool_choice: toolChoice } = body;
 
     try {
-      return await this.openAiClient!.chat.completions.create({
-        model: this.model,
-        tools: this.enhanceRemoteTools(tools),
-        messages,
-        tool_choice: toolChoice,
-      } as ChatCompletionCreateParamsNonStreaming);
+      const enhancedTools = this.enhanceRemoteTools(tools);
+
+      const clientWithTools =
+        enhancedTools && enhancedTools.length > 0
+          ? this.client.bindTools(enhancedTools, { tool_choice: toolChoice })
+          : this.client;
+
+      const response = await clientWithTools.invoke(messages);
+
+      return this.convertAIMessageToOpenAI(response);
     } catch (error) {
+      if (this.provider === 'mistral') {
+        throw new MistralUnprocessableError(
+          `Error while calling Mistral: ${(error as Error).message}`,
+        );
+      }
+
       throw new OpenAIUnprocessableError(`Error while calling OpenAI: ${(error as Error).message}`);
     }
   }
 
-  private async dispatchMistral(body: DispatchBody): Promise<unknown> {
-    const { tools, messages, tool_choice: toolChoice } = body;
+  private convertAIMessageToOpenAI(message: AIMessage): unknown {
+    const toolCalls = message.tool_calls?.map(tc => ({
+      id: tc.id ?? `call_${Date.now()}`,
+      type: 'function' as const,
+      function: {
+        name: tc.name,
+        arguments: typeof tc.args === 'string' ? tc.args : JSON.stringify(tc.args),
+      },
+    }));
 
-    try {
-      const response = await this.mistralClient!.chat.complete({
-        model: this.model,
-        tools: this.enhanceRemoteTools(tools) as Parameters<
-          typeof this.mistralClient.chat.complete
-        >[0]['tools'],
-        messages: messages as Parameters<typeof this.mistralClient.chat.complete>[0]['messages'],
-        toolChoice: toolChoice as 'auto' | 'none' | 'required',
-      });
-
-      return this.convertMistralToOpenAI(response);
-    } catch (error) {
-      throw new MistralUnprocessableError(
-        `Error while calling Mistral: ${(error as Error).message}`,
-      );
-    }
-  }
+    // Usage metadata types vary by provider, use type assertions
+    const usageMetadata = message.usage_metadata as
+      | { input_tokens?: number; output_tokens?: number; total_tokens?: number }
+      | undefined;
+    const tokenUsage = (message.response_metadata as { tokenUsage?: Record<string, number> })
+      ?.tokenUsage;
 
-  private convertMistralToOpenAI(response: unknown): unknown {
-    const mistralResponse = response as {
-      id?: string;
-      model?: string;
-      choices?: Array<{
-        index?: number;
-        message?: {
-          role?: string;
-          content?: string | null;
-          toolCalls?: Array<{
-            id?: string;
-            function?: { name?: string; arguments?: string };
-          }>;
-        };
-        finishReason?: string;
-      }>;
-      usage?: {
-        promptTokens?: number;
-        completionTokens?: number;
-        totalTokens?: number;
-      };
-    };
+    const content = typeof message.content === 'string' ? message.content : null;
 
     return {
-      id: mistralResponse.id ?? `chatcmpl-${Date.now()}`,
+      id: message.id ?? `chatcmpl-${Date.now()}`,
       object: 'chat.completion',
       created: Math.floor(Date.now() / 1000),
-      model: mistralResponse.model ?? this.model,
-      choices: (mistralResponse.choices ?? []).map(choice => ({
-        index: choice.index ?? 0,
-        message: {
-          role: choice.message?.role ?? 'assistant',
-          content: choice.message?.content ?? null,
-          ...(choice.message?.toolCalls && choice.message.toolCalls.length > 0
-            ? {
-                tool_calls: choice.message.toolCalls.map(tc => ({
-                  id: tc.id,
-                  type: 'function',
-                  function: {
-                    name: tc.function?.name,
-                    arguments: tc.function?.arguments,
-                  },
-                })),
-              }
-            : {}),
+      model: this.model,
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: 'assistant',
+            content,
+            ...(toolCalls && toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+          },
+          finish_reason: toolCalls && toolCalls.length > 0 ? 'tool_calls' : 'stop',
         },
-        finish_reason: this.convertFinishReason(choice.finishReason),
-      })),
+      ],
       usage: {
-        prompt_tokens: mistralResponse.usage?.promptTokens ?? 0,
-        completion_tokens: mistralResponse.usage?.completionTokens ?? 0,
-        total_tokens: mistralResponse.usage?.totalTokens ?? 0,
+        prompt_tokens: usageMetadata?.input_tokens ?? tokenUsage?.promptTokens ?? 0,
+        completion_tokens: usageMetadata?.output_tokens ?? tokenUsage?.completionTokens ?? 0,
+        total_tokens: usageMetadata?.total_tokens ?? tokenUsage?.totalTokens ?? 0,
       },
     };
   }
 
-  private convertFinishReason(reason?: string): string {
-    if (reason === 'tool_calls') return 'tool_calls';
-    if (reason === 'stop') return 'stop';
-    if (reason === 'length') return 'length';
-
-    return 'stop';
-  }
-
   private enhanceRemoteTools(tools?: ChatCompletionCreateParamsNonStreaming['tools']) {
     if (!tools || !Array.isArray(tools)) return tools;