feat: add support for multiple LLM providers (Anthropic, Gemini, Bedrock, OpenRouter, Grok)

- Add new LLM provider implementations for Anthropic, Gemini, AWS Bedrock, OpenRouter, and xAI Grok
- Refactor LLM provider interface to support provider-specific credential requirements
- Add CredentialInput type for declarative credential collection
- Update config collection to dynamically prompt for provider-specific credentials
- Modify env file generation to work with any LLM provider
- Replace hardcoded openaiApiKey with generic llmApiKey and llmAdditionalInputs fields
- AWS Bedrock now prompts for Access Key ID, Secret Key, and Region as needed

Author: rogeriochaves

src/config-collection/collect-config.ts

@@ -9,6 +9,7 @@ import type {
 import { buildLanguageChoices } from "./choice-builders/language-choices.js";
 import { buildFrameworkChoices } from "./choice-builders/framework-choices.js";
 import { buildCodingAssistantChoices } from "./choice-builders/coding-assistant-choices.js";
+import { getAllLLMProviders } from "../providers/llm-providers/index.js";
 import { validateOpenAIKey } from "./validators/openai-key.js";
 import { validateLangWatchKey } from "./validators/langwatch-key.js";
 import { validateProjectGoal } from "./validators/project-goal.js";
@@ -46,17 +47,48 @@ export const collectConfig = async (): Promise<ProjectConfig> => {
       choices: await buildCodingAssistantChoices(),
     });
 
+    const allProviders = getAllLLMProviders();
     const llmProvider = await select<LLMProvider>({
       message: "What LLM provider do you want to use?",
-      choices: [{ name: "OpenAI", value: "openai" }],
+      choices: allProviders.map((p) => ({ name: p.displayName, value: p.id as LLMProvider })),
     });
 
-    const openaiApiKey = await password({
-      message: "Enter your OpenAI API key:",
+    const selectedProvider = allProviders.find((p) => p.id === llmProvider);
+    const providerDisplayName = selectedProvider?.displayName || llmProvider;
+
+    const llmApiKey = await password({
+      message: `Enter your ${providerDisplayName} API key:`,
       mask: "*",
-      validate: validateOpenAIKey,
+      validate: llmProvider === "openai" ? validateOpenAIKey : (value) => {
+        if (!value || value.length < 5) {
+          return "API key is required and must be at least 5 characters";
+        }
+        return true;
+      },
     });
 
+    // Collect additional credentials if the provider needs them
+    let llmAdditionalInputs: Record<string, string> | undefined;
+    if (selectedProvider?.additionalCredentials && selectedProvider.additionalCredentials.length > 0) {
+      llmAdditionalInputs = {};
+
+      for (const credential of selectedProvider.additionalCredentials) {
+        if (credential.type === "password") {
+          llmAdditionalInputs[credential.key] = await password({
+            message: `Enter your ${credential.label}:`,
+            mask: "*",
+            validate: credential.validate,
+          });
+        } else {
+          llmAdditionalInputs[credential.key] = await input({
+            message: `Enter your ${credential.label}:`,
+            default: credential.defaultValue,
+            validate: credential.validate,
+          });
+        }
+      }
+    }
+
     console.log(chalk.gray("\nTo get your LangWatch API key, visit:"));
     console.log(chalk.blue.underline("https://app.langwatch.ai/authorize\n"));
 
@@ -76,7 +108,8 @@ export const collectConfig = async (): Promise<ProjectConfig> => {
       framework,
       codingAssistant,
       llmProvider,
-      openaiApiKey,
+      llmApiKey,
+      llmAdditionalInputs,
       langwatchApiKey,
       projectGoal,
     };

src/project-scaffolding/create-project-structure.ts

@@ -31,8 +31,7 @@ export const createProjectStructure = async ({
 
   await generateEnvFiles({
     projectPath,
-    openaiApiKey: config.openaiApiKey,
-    langwatchApiKey: config.langwatchApiKey,
+    config,
   });
 
   await generateGitignore({ projectPath });

src/project-scaffolding/file-generators/env-files.ts

@@ -1,44 +1,55 @@
 import * as fs from "fs/promises";
 import * as path from "path";
+import type { ProjectConfig } from "../../types.js";
+import { getLLMProvider } from "../../providers/llm-providers/index.js";
 
 /**
  * Generates .env.example and .env files with API key placeholders.
  *
  * @param params - Parameters object
  * @param params.projectPath - Absolute path to project root
- * @param params.openaiApiKey - OpenAI API key to include in .env
- * @param params.langwatchApiKey - LangWatch API key to include in .env
+ * @param params.config - Project configuration with LLM provider details
  * @returns Promise that resolves when files are written
  *
  * @example
  * ```ts
- * await generateEnvFiles({ projectPath: '/path', openaiApiKey: 'sk-...', langwatchApiKey: 'sk-lw-...' });
+ * await generateEnvFiles({ projectPath: '/path', config });
  * ```
  */
 export const generateEnvFiles = async ({
   projectPath,
-  openaiApiKey,
-  langwatchApiKey,
+  config,
 }: {
   projectPath: string;
-  openaiApiKey: string;
-  langwatchApiKey: string;
+  config: ProjectConfig;
 }): Promise<void> => {
-  const envExample = `# LLM Provider API Keys
-OPENAI_API_KEY=your_openai_api_key_here
+  const provider = getLLMProvider({ provider: config.llmProvider });
+  const envVars = provider.getEnvVariables({
+    apiKey: config.llmApiKey,
+    additionalInputs: config.llmAdditionalInputs,
+  });
 
-# LangWatch
-LANGWATCH_API_KEY=your_langwatch_api_key_here
-`;
+  // Generate .env.example with placeholders
+  const envExampleLines = [
+    "# LLM Provider API Keys",
+    ...envVars.map((v) => `${v.key}=your_${v.key.toLowerCase()}_here`),
+    "",
+    "# LangWatch",
+    "LANGWATCH_API_KEY=your_langwatch_api_key_here",
+  ];
+  const envExample = envExampleLines.join("\n") + "\n";
 
   await fs.writeFile(path.join(projectPath, ".env.example"), envExample);
 
-  const envContent = `# LLM Provider API Keys
-OPENAI_API_KEY=${openaiApiKey}
-
-# LangWatch
-LANGWATCH_API_KEY=${langwatchApiKey}
-`;
+  // Generate .env with actual values
+  const envContentLines = [
+    "# LLM Provider API Keys",
+    ...envVars.map((v) => `${v.key}=${v.value}`),
+    "",
+    "# LangWatch",
+    `LANGWATCH_API_KEY=${config.langwatchApiKey}`,
+  ];
+  const envContent = envContentLines.join("\n") + "\n";
 
   await fs.writeFile(path.join(projectPath, ".env"), envContent);
 };

src/providers/llm-providers/anthropic/index.ts

@@ -0,0 +1,14 @@
+import type { LLMProviderProvider } from "../index.js";
+
+/**
+ * Anthropic (Claude) LLM provider implementation.
+ */
+export const AnthropicProvider: LLMProviderProvider = {
+  id: "anthropic",
+  displayName: "Anthropic (Claude)",
+
+  getEnvVariables: ({ apiKey }) => [
+    { key: "ANTHROPIC_API_KEY", value: apiKey },
+  ],
+};
+

src/providers/llm-providers/bedrock/index.ts

@@ -0,0 +1,59 @@
+import type { LLMProviderProvider } from "../index.js";
+
+/**
+ * AWS Bedrock LLM provider implementation.
+ * Requires AWS credentials (access key, secret key, and region).
+ */
+export const BedrockProvider: LLMProviderProvider = {
+  id: "bedrock",
+  displayName: "AWS Bedrock",
+
+  additionalCredentials: [
+    {
+      key: "awsSecretKey",
+      label: "AWS Secret Access Key",
+      type: "password",
+      validate: (value) => {
+        if (!value || value.length < 10) {
+          return "AWS Secret Access Key is required";
+        }
+        return true;
+      },
+    },
+    {
+      key: "awsRegion",
+      label: "AWS Region (e.g., us-east-1)",
+      type: "text",
+      defaultValue: "us-east-1",
+      validate: (value) => {
+        if (!value || value.length < 5) {
+          return "AWS Region is required";
+        }
+        return true;
+      },
+    },
+  ],
+
+  getEnvVariables: ({ apiKey, additionalInputs }) => {
+    const envVars = [
+      { key: "AWS_ACCESS_KEY_ID", value: apiKey },
+    ];
+
+    if (additionalInputs?.awsSecretKey) {
+      envVars.push({
+        key: "AWS_SECRET_ACCESS_KEY",
+        value: additionalInputs.awsSecretKey,
+      });
+    }
+
+    if (additionalInputs?.awsRegion) {
+      envVars.push({
+        key: "AWS_REGION",
+        value: additionalInputs.awsRegion,
+      });
+    }
+
+    return envVars;
+  },
+};
+

src/providers/llm-providers/gemini/index.ts

@@ -0,0 +1,15 @@
+import type { LLMProviderProvider } from "../index.js";
+
+/**
+ * Google Gemini LLM provider implementation.
+ */
+export const GeminiProvider: LLMProviderProvider = {
+  id: "gemini",
+  displayName: "Google Gemini",
+
+  getEnvVariables: ({ apiKey }) => [
+    { key: "GOOGLE_API_KEY", value: apiKey },
+    { key: "GEMINI_API_KEY", value: apiKey },
+  ],
+};
+

src/providers/llm-providers/grok/index.ts

@@ -0,0 +1,14 @@
+import type { LLMProviderProvider } from "../index.js";
+
+/**
+ * xAI Grok LLM provider implementation.
+ */
+export const GrokProvider: LLMProviderProvider = {
+  id: "grok",
+  displayName: "xAI (Grok)",
+
+  getEnvVariables: ({ apiKey }) => [
+    { key: "XAI_API_KEY", value: apiKey },
+  ],
+};
+

src/providers/llm-providers/index.ts

@@ -1,10 +1,23 @@
 import { OpenAIProvider } from "./openai/index.js";
+import { AnthropicProvider } from "./anthropic/index.js";
+import { GeminiProvider } from "./gemini/index.js";
+import { BedrockProvider } from "./bedrock/index.js";
+import { OpenRouterProvider } from "./openrouter/index.js";
+import { GrokProvider } from "./grok/index.js";
 
 export type EnvVariable = {
   key: string;
   value: string;
 };
 
+export type CredentialInput = {
+  key: string;
+  label: string;
+  type: "password" | "text";
+  defaultValue?: string;
+  validate?: (value: string) => string | boolean;
+};
+
 /**
  * Interface for LLM provider configuration.
  * Each provider returns environment variables needed for API access.
@@ -19,15 +32,26 @@ export interface LLMProviderProvider {
   readonly id: string;
   readonly displayName: string;
 
+  /** Optional additional credentials this provider needs (beyond the main API key) */
+  readonly additionalCredentials?: CredentialInput[];
+
   /** Returns environment variables needed for this provider */
-  getEnvVariables(params: { apiKey: string }): EnvVariable[];
+  getEnvVariables(params: {
+    apiKey: string;
+    additionalInputs?: Record<string, string>;
+  }): EnvVariable[];
 
   /** Validates API key format/connectivity */
   validateApiKey?(params: { apiKey: string }): Promise<boolean>;
 }
 
 const PROVIDERS: Record<string, LLMProviderProvider> = {
   openai: OpenAIProvider,
+  anthropic: AnthropicProvider,
+  gemini: GeminiProvider,
+  bedrock: BedrockProvider,
+  openrouter: OpenRouterProvider,
+  grok: GrokProvider,
 };
 
 /**

src/providers/llm-providers/openai/index.ts

@@ -7,6 +7,8 @@ export const OpenAIProvider: LLMProviderProvider = {
   id: "openai",
   displayName: "OpenAI",
 
-  getEnvVariables: ({ apiKey }) => [{ key: "OPENAI_API_KEY", value: apiKey }],
+  getEnvVariables: ({ apiKey }) => [
+    { key: "OPENAI_API_KEY", value: apiKey },
+  ],
 };
 

src/providers/llm-providers/openrouter/index.ts

@@ -0,0 +1,14 @@
+import type { LLMProviderProvider } from "../index.js";
+
+/**
+ * OpenRouter LLM provider implementation.
+ */
+export const OpenRouterProvider: LLMProviderProvider = {
+  id: "openrouter",
+  displayName: "OpenRouter",
+
+  getEnvVariables: ({ apiKey }) => [
+    { key: "OPENROUTER_API_KEY", value: apiKey },
+  ],
+};
+