Add Mistral, use "ai" lib

api/package.json

@@ -39,6 +39,9 @@
     "fpx": "bin/cli.js"
   },
   "dependencies": {
+    "@ai-sdk/anthropic": "^0.0.51",
+    "@ai-sdk/mistral": "^0.0.42",
+    "@ai-sdk/openai": "^0.0.66",
     "@anthropic-ai/sdk": "^0.24.3",
     "@fiberplane/fpx-types": "workspace:*",
     "@hono/node-server": "^1.11.1",
@@ -48,6 +51,7 @@
     "@libsql/client": "^0.6.2",
     "acorn": "^8.11.3",
     "acorn-walk": "^8.3.2",
+    "ai": "^3.4.10",
     "chalk": "^5.3.0",
     "dotenv": "^16.4.5",
     "drizzle-kit": "^0.24.2",

api/src/lib/ai/index.ts

@@ -1,6 +1,45 @@
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createMistral } from "@ai-sdk/mistral";
+import { createOpenAI } from "@ai-sdk/openai";
 import type { Settings } from "@fiberplane/fpx-types";
-import { generateRequestWithAnthropic } from "./anthropic.js";
-import { generateRequestWithOpenAI } from "./openai.js";
+import { generateObject } from "ai";
+import logger from "../../logger.js";
+import { invokeRequestGenerationPrompt } from "./prompts.js";
+import { requestSchema } from "./tools.js";
+
+function configureProvider(
+  aiProvider: string,
+  providerConfig: {
+    apiKey: string;
+    baseUrl?: string | undefined;
+    model: string;
+  },
+) {
+  if (aiProvider === "openai") {
+    const openai = createOpenAI({
+      apiKey: providerConfig.apiKey,
+      baseURL: providerConfig.baseUrl,
+    });
+    return openai(providerConfig.model, { structuredOutputs: true });
+  }
+  if (aiProvider === "anthropic") {
+    const anthropic = createAnthropic({
+      apiKey: providerConfig.apiKey,
+      baseURL: providerConfig.baseUrl,
+    });
+    return anthropic(providerConfig.model);
+  }
+
+  if (aiProvider === "mistral") {
+    const mistral = createMistral({
+      apiKey: providerConfig.apiKey,
+      baseURL: providerConfig.baseUrl,
+    });
+    return mistral(providerConfig.model);
+  }
+
+  throw new Error("Unknown AI provider");
+}
 
 export async function generateRequestWithAiProvider({
   inferenceConfig,
@@ -29,67 +68,56 @@ export async function generateRequestWithAiProvider({
   }[];
   middlewareContext?: string;
 }) {
+  const { aiEnabled, aiProviderConfigurations, aiProvider } = inferenceConfig;
+  if (!aiEnabled) {
+    return { data: null, error: { message: "AI is not enabled" } };
+  }
+
+  if (!aiProvider) {
+    return { data: null, error: { message: "AI provider is not set" } };
+  }
+
+  if (!aiProviderConfigurations || !aiProviderConfigurations[aiProvider]) {
+    return {
+      data: null,
+      error: { message: "AI provider is not configured properly" },
+    };
+  }
+
+  const providerConfig = aiProviderConfigurations[aiProvider];
+
+  const provider = configureProvider(aiProvider, providerConfig);
+
+  logger.debug("Generating request with AI provider", {
+    aiProvider,
+    providerConfig,
+  });
+
   const {
-    openaiApiKey,
-    openaiModel,
-    openaiBaseUrl,
-    anthropicApiKey,
-    anthropicModel,
-    anthropicBaseUrl,
-    aiProviderType,
-  } = inferenceConfig;
-  if (aiProviderType === "openai") {
-    return generateRequestWithOpenAI({
-      apiKey: openaiApiKey ?? "",
-      model: openaiModel ?? "",
-      baseUrl: openaiBaseUrl,
-      persona,
-      method,
-      path,
+    object: generatedObject,
+    warnings,
+    usage,
+  } = await generateObject({
+    model: provider,
+    schema: requestSchema,
+    prompt: await invokeRequestGenerationPrompt({
       handler,
       handlerContext,
       history,
       openApiSpec,
       middleware,
       middlewareContext,
-    }).then(
-      (parsedArgs) => {
-        return { data: parsedArgs, error: null };
-      },
-      (error) => {
-        if (error instanceof Error) {
-          return { data: null, error: { message: error.message } };
-        }
-        return { data: null, error: { message: "Unknown error" } };
-      },
-    );
-  }
-  if (aiProviderType === "anthropic") {
-    return generateRequestWithAnthropic({
-      apiKey: anthropicApiKey ?? "",
-      baseUrl: anthropicBaseUrl,
-      model: anthropicModel ?? "",
       persona,
       method,
       path,
-      handler,
-      handlerContext,
-      history,
-      openApiSpec,
-      middleware,
-      middlewareContext,
-    }).then(
-      (parsedArgs) => {
-        return { data: parsedArgs, error: null };
-      },
-      (error) => {
-        if (error instanceof Error) {
-          return { data: null, error: { message: error.message } };
-        }
-        return { data: null, error: { message: "Unknown error" } };
-      },
-    );
-  }
+    }),
+  });
+
+  logger.debug("Generated request, warnings, usage", {
+    generatedObject,
+    warnings,
+    usage,
+  });
 
-  return { data: null, error: { message: "Unknown AI provider" } };
+  return { data: generatedObject, error: null };
 }