gaunt-sloth-assistant 0.1.5 → 0.3.0

package/src/commands/reviewCommand.ts

@@ -0,0 +1,223 @@
+import { Command, Option } from 'commander';
+import type { SlothContext } from '#src/config.js';
+import { slothContext } from '#src/config.js';
+import { readBackstory, readGuidelines, readReviewInstructions } from '#src/prompt.js';
+import { readMultipleFilesFromCurrentDir } from '#src/utils.js';
+import { displayError } from '#src/consoleUtils.js';
+import { getStringFromStdin } from '#src/systemUtils.js';
+
+/**
+ * Requirements providers. Expected to be in `.providers/` dir
+ */
+const REQUIREMENTS_PROVIDERS = {
+  'jira-legacy': 'jiraIssueLegacyProvider.js',
+  jira: 'jiraIssueProvider.js',
+  text: 'text.js',
+  file: 'file.js',
+} as const;
+
+type RequirementsProviderType = keyof typeof REQUIREMENTS_PROVIDERS;
+
+/**
+ * Content providers. Expected to be in `.providers/` dir
+ */
+const CONTENT_PROVIDERS = {
+  gh: 'ghPrDiffProvider.js',
+  text: 'text.js',
+  file: 'file.js',
+} as const;
+
+type ContentProviderType = keyof typeof CONTENT_PROVIDERS;
+
+interface ReviewCommandOptions {
+  file?: string[];
+  requirements?: string;
+  requirementsProvider?: RequirementsProviderType;
+  contentProvider?: ContentProviderType;
+  message?: string;
+}
+
+interface PrCommandOptions {
+  file?: string[];
+  requirementsProvider?: RequirementsProviderType;
+}
+
+export function reviewCommand(program: Command, context: SlothContext): void {
+  program
+    .command('review')
+    .description('Review provided diff or other content')
+    .argument(
+      '[contentId]',
+      'Optional content ID argument to retrieve content with content provider'
+    )
+    .alias('r')
+    // TODO add provider to get results of git --no-pager diff
+    .option(
+      '-f, --file [files...]',
+      'Input files. Content of these files will be added BEFORE the diff, but after requirements'
+    )
+    // TODO figure out what to do with this (we probably want to merge it with requirementsId)?
+    .option('-r, --requirements <requirements>', 'Requirements for this review.')
+    .addOption(
+      new Option(
+        '-p, --requirements-provider <requirementsProvider>',
+        'Requirements provider for this review.'
+      ).choices(Object.keys(REQUIREMENTS_PROVIDERS))
+    )
+    .addOption(
+      new Option('--content-provider <contentProvider>', 'Content  provider').choices(
+        Object.keys(CONTENT_PROVIDERS)
+      )
+    )
+    .option('-m, --message <message>', 'Extra message to provide just before the content')
+    .action(async (contentId: string | undefined, options: ReviewCommandOptions) => {
+      const { initConfig } = await import('#src/config.js');
+      await initConfig();
+      const systemMessage = [
+        readBackstory(),
+        readGuidelines(slothContext.config.projectGuidelines),
+        readReviewInstructions(slothContext.config.projectReviewInstructions),
+      ];
+      const content: string[] = [];
+      const requirementsId = options.requirements;
+      const requirementsProvider =
+        options.requirementsProvider ??
+        (context.config?.review?.requirementsProvider as RequirementsProviderType | undefined) ??
+        (context.config?.requirementsProvider as RequirementsProviderType | undefined);
+      const contentProvider =
+        options.contentProvider ??
+        (context.config?.review?.contentProvider as ContentProviderType | undefined) ??
+        (context.config?.contentProvider as ContentProviderType | undefined);
+
+      // TODO consider calling these in parallel
+      const requirements = await getRequirementsFromProvider(requirementsProvider, requirementsId);
+      if (requirements) {
+        content.push(requirements);
+      }
+
+      const providedContent = await getContentFromProvider(contentProvider, contentId);
+      if (providedContent) {
+        content.push(providedContent);
+      }
+
+      if (options.file) {
+        content.push(readMultipleFilesFromCurrentDir(options.file));
+      }
+      let stringFromStdin = getStringFromStdin();
+      if (stringFromStdin) {
+        content.push(stringFromStdin);
+      }
+      if (options.message) {
+        content.push(options.message);
+      }
+      const { review } = await import('#src/modules/reviewModule.js');
+      // TODO make the prefix configurable
+      await review('gth-DIFF-review', systemMessage.join('\n'), content.join('\n'));
+    });
+
+  program
+    .command('pr')
+    .description(
+      'Review provided Pull Request in current directory. ' +
+        'This command is similar to `review`, but default content provider is `gh`. ' +
+        '(assuming that GH cli is installed and authenticated for current project'
+    )
+    .argument('<prId>', 'Pull request ID to review.')
+    .argument(
+      '[requirementsId]',
+      'Optional requirements ID argument to retrieve requirements with requirements provider'
+    )
+    .addOption(
+      new Option(
+        '-p, --requirements-provider <requirementsProvider>',
+        'Requirements provider for this review.'
+      ).choices(Object.keys(REQUIREMENTS_PROVIDERS))
+    )
+    .option(
+      '-f, --file [files...]',
+      'Input files. Content of these files will be added BEFORE the diff, but after requirements'
+    )
+    .action(async (prId: string, requirementsId: string | undefined, options: PrCommandOptions) => {
+      const { initConfig } = await import('#src/config.js');
+      await initConfig();
+
+      const systemMessage = [
+        readBackstory(),
+        readGuidelines(slothContext.config.projectGuidelines),
+        readReviewInstructions(slothContext.config.projectReviewInstructions),
+      ];
+      const content: string[] = [];
+      const requirementsProvider =
+        options.requirementsProvider ??
+        (context.config?.pr?.requirementsProvider as RequirementsProviderType | undefined) ??
+        (context.config?.requirementsProvider as RequirementsProviderType | undefined);
+
+      // Handle requirements
+      const requirements = await getRequirementsFromProvider(requirementsProvider, requirementsId);
+      if (requirements) {
+        content.push(requirements);
+      }
+
+      if (options.file) {
+        content.push(readMultipleFilesFromCurrentDir(options.file));
+      }
+
+      // Get PR diff using the 'gh' provider
+      const providerPath = `#src/providers/${CONTENT_PROVIDERS['gh']}`;
+      const { get } = await import(providerPath);
+      content.push(await get(null, prId));
+
+      const { review } = await import('#src/modules/reviewModule.js');
+      // TODO make the prefix configurable
+      // TODO consider including requirements id
+      // TODO sanitize prId
+      await review(`gth-PR-${prId}-review`, systemMessage.join('\n'), content.join('\n'));
+    });
+
+  async function getRequirementsFromProvider(
+    requirementsProvider: RequirementsProviderType | undefined,
+    requirementsId: string | undefined
+  ): Promise<string> {
+    return getFromProvider(
+      requirementsProvider,
+      requirementsId,
+      (context.config?.requirementsProviderConfig ?? {})[requirementsProvider as string],
+      REQUIREMENTS_PROVIDERS
+    );
+  }
+
+  async function getContentFromProvider(
+    contentProvider: ContentProviderType | undefined,
+    contentId: string | undefined
+  ): Promise<string> {
+    return getFromProvider(
+      contentProvider,
+      contentId,
+      (context.config?.contentProviderConfig ?? {})[contentProvider as string],
+      CONTENT_PROVIDERS
+    );
+  }
+
+  async function getFromProvider(
+    provider: RequirementsProviderType | ContentProviderType | undefined,
+    id: string | undefined,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    config: any,
+    legitPredefinedProviders: typeof REQUIREMENTS_PROVIDERS | typeof CONTENT_PROVIDERS
+  ): Promise<string> {
+    if (typeof provider === 'string') {
+      // Use one of the predefined providers
+      if (legitPredefinedProviders[provider as keyof typeof legitPredefinedProviders]) {
+        const providerPath = `#src/providers/${legitPredefinedProviders[provider as keyof typeof legitPredefinedProviders]}`;
+        const { get } = await import(providerPath);
+        return await get(config, id);
+      } else {
+        displayError(`Unknown provider: ${provider}. Continuing without it.`);
+      }
+    } else if (typeof provider === 'function') {
+      // Type assertion to handle function call
+      return await (provider as (id: string | undefined) => Promise<string>)(id);
+    }
+    return '';
+  }
+}

package/src/config.ts

@@ -0,0 +1,269 @@
+import path from 'node:path/posix';
+import { v4 as uuidv4 } from 'uuid';
+import { displayDebug, displayError, displayInfo, displayWarning } from '#src/consoleUtils.js';
+import { importExternalFile, writeFileIfNotExistsWithMessages } from '#src/utils.js';
+import { existsSync, readFileSync } from 'node:fs';
+import { error, exit, getCurrentDir } from '#src/systemUtils.js';
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+
+export interface SlothConfig extends BaseSlothConfig {
+  llm: BaseChatModel; // FIXME this is still bad keeping instance in config is probably not best choice
+  contentProvider: string;
+  requirementsProvider: string;
+  projectGuidelines: string;
+  projectReviewInstructions: string;
+  commands: {
+    pr: {
+      contentProvider: string;
+    };
+  };
+}
+
+/**
+ * Raw, unprocessed sloth config
+ */
+export interface RawSlothConfig extends BaseSlothConfig {
+  llm: LLMConfig;
+}
+
+/**
+ * Do not export this one
+ */
+interface BaseSlothConfig {
+  llm: unknown;
+  contentProvider?: string;
+  requirementsProvider?: string;
+  projectGuidelines?: string;
+  projectReviewInstructions?: string;
+  commands?: {
+    pr: {
+      contentProvider: string;
+    };
+  };
+  review?: {
+    requirementsProvider?: string;
+    contentProvider?: string;
+  };
+  pr?: {
+    requirementsProvider?: string;
+  };
+  requirementsProviderConfig?: Record<string, unknown>;
+  contentProviderConfig?: Record<string, unknown>;
+}
+
+/**
+ * @deprecated
+ * this object has blurred responsibility lines and bad name.
+ */
+export interface SlothContext {
+  config: SlothConfig;
+  session: {
+    configurable: {
+      thread_id: string;
+    };
+  };
+}
+
+export interface LLMConfig extends Record<string, unknown> {
+  type: string;
+  model: string;
+}
+
+export const USER_PROJECT_CONFIG_JS = '.gsloth.config.js';
+export const USER_PROJECT_CONFIG_JSON = '.gsloth.config.json';
+export const USER_PROJECT_CONFIG_MJS = '.gsloth.config.mjs';
+export const GSLOTH_BACKSTORY = '.gsloth.backstory.md';
+export const PROJECT_GUIDELINES = '.gsloth.guidelines.md';
+export const PROJECT_REVIEW_INSTRUCTIONS = '.gsloth.review.md';
+
+export const availableDefaultConfigs = ['vertexai', 'anthropic', 'groq'] as const;
+export type ConfigType = (typeof availableDefaultConfigs)[number];
+
+export const DEFAULT_CONFIG: Partial<SlothConfig> = {
+  llm: undefined,
+  contentProvider: 'file',
+  requirementsProvider: 'file',
+  projectGuidelines: PROJECT_GUIDELINES,
+  projectReviewInstructions: PROJECT_REVIEW_INSTRUCTIONS,
+  commands: {
+    pr: {
+      contentProvider: 'gh',
+    },
+  },
+};
+
+/**
+ * @deprecated
+ * this object has blurred responsibility lines and bad name.
+ * TODO this should be reworked to something more robust
+ */
+export const slothContext = {
+  config: DEFAULT_CONFIG,
+  stdin: '',
+  session: { configurable: { thread_id: uuidv4() } },
+} as Partial<SlothContext> as SlothContext;
+
+export async function initConfig(): Promise<void> {
+  const currentDir = getCurrentDir();
+  const jsonConfigPath = path.join(currentDir, USER_PROJECT_CONFIG_JSON);
+  const jsConfigPath = path.join(currentDir, USER_PROJECT_CONFIG_JS);
+  const mjsConfigPath = path.join(currentDir, USER_PROJECT_CONFIG_MJS);
+
+  // Try loading JSON config file first
+  if (existsSync(jsonConfigPath)) {
+    try {
+      const jsonConfig = JSON.parse(readFileSync(jsonConfigPath, 'utf8')) as RawSlothConfig;
+      // If the config has an LLM with a type, create the appropriate LLM instance
+      if (jsonConfig.llm && typeof jsonConfig.llm === 'object' && 'type' in jsonConfig.llm) {
+        await tryJsonConfig(jsonConfig);
+      } else {
+        error(`${jsonConfigPath} is not in valid format. Should at least define llm.type`);
+        exit(1);
+      }
+    } catch (e) {
+      displayDebug(e instanceof Error ? e : String(e));
+      displayError(
+        `Failed to read config from ${USER_PROJECT_CONFIG_JSON}, will try other formats.`
+      );
+      // Continue to try other formats
+      return tryJsConfig();
+    }
+  } else {
+    // JSON config not found, try JS
+    return tryJsConfig();
+  }
+
+  // Helper function to try loading JS config
+  async function tryJsConfig(): Promise<void> {
+    if (existsSync(jsConfigPath)) {
+      return importExternalFile(jsConfigPath)
+        .then((i: { configure: (module: string) => Promise<Partial<SlothConfig>> }) =>
+          i.configure(jsConfigPath)
+        )
+        .then((config) => {
+          slothContext.config = { ...slothContext.config, ...config };
+        })
+        .catch((e) => {
+          displayDebug(e instanceof Error ? e : String(e));
+          displayError(
+            `Failed to read config from ${USER_PROJECT_CONFIG_JS}, will try other formats.`
+          );
+          // Continue to try other formats
+          return tryMjsConfig();
+        });
+    } else {
+      // JS config not found, try MJS
+      return tryMjsConfig();
+    }
+  }
+
+  // Helper function to try loading MJS config
+  async function tryMjsConfig(): Promise<void> {
+    if (existsSync(mjsConfigPath)) {
+      return importExternalFile(mjsConfigPath)
+        .then((i: { configure: (module: string) => Promise<Partial<SlothConfig>> }) =>
+          i.configure(mjsConfigPath)
+        )
+        .then((config) => {
+          slothContext.config = { ...slothContext.config, ...config };
+        })
+        .catch((e) => {
+          displayDebug(e instanceof Error ? e : String(e));
+          displayError(`Failed to read config from ${USER_PROJECT_CONFIG_MJS}.`);
+          displayError(`No valid configuration found. Please create a valid configuration file.`);
+          exit();
+        });
+    } else {
+      // No config files found
+      displayError(
+        'No configuration file found. Please create one of: ' +
+          `${USER_PROJECT_CONFIG_JSON}, ${USER_PROJECT_CONFIG_JS}, or ${USER_PROJECT_CONFIG_MJS} ` +
+          'in your project directory.'
+      );
+      exit();
+    }
+  }
+}
+
+// Process JSON LLM config by creating the appropriate LLM instance
+export async function tryJsonConfig(jsonConfig: RawSlothConfig): Promise<void> {
+  const llmConfig = jsonConfig?.llm;
+  const llmType = llmConfig?.type?.toLowerCase();
+
+  // Check if the LLM type is in availableDefaultConfigs
+  if (!llmType || !availableDefaultConfigs.includes(llmType as ConfigType)) {
+    displayError(
+      `Unsupported LLM type: ${llmType}. Available types are: ${availableDefaultConfigs.join(', ')}`
+    );
+    exit(1);
+    return;
+  }
+
+  try {
+    // Import the appropriate config module based on the LLM type
+    try {
+      const configModule = await import(`./configs/${llmType}.js`);
+      if (configModule.processJsonConfig) {
+        const llm = (await configModule.processJsonConfig(llmConfig)) as BaseChatModel;
+        slothContext.config = { ...slothContext.config, ...jsonConfig, llm };
+      } else {
+        displayWarning(`Config module for ${llmType} does not have processJsonConfig function.`);
+        exit(1);
+      }
+    } catch (importError) {
+      displayDebug(importError instanceof Error ? importError : String(importError));
+      displayWarning(`Could not import config module for ${llmType}.`);
+      exit(1);
+    }
+  } catch (error) {
+    displayDebug(error instanceof Error ? error : String(error));
+    displayError(`Error creating LLM instance for type ${llmType}.`);
+    exit(1);
+  }
+}
+
+export async function createProjectConfig(configType: string): Promise<void> {
+  displayInfo(`Setting up your project\n`);
+  writeProjectReviewPreamble();
+  displayWarning(`Make sure you add as much detail as possible to your ${PROJECT_GUIDELINES}.\n`);
+
+  // Check if the config type is in availableDefaultConfigs
+  if (!availableDefaultConfigs.includes(configType as ConfigType)) {
+    displayError(
+      `Unsupported config type: ${configType}. Available types are: ${availableDefaultConfigs.join(', ')}`
+    );
+    exit(1);
+    return;
+  }
+
+  displayInfo(`Creating project config for ${configType}`);
+  const vendorConfig = await import(`./configs/${configType}.js`);
+  vendorConfig.init(USER_PROJECT_CONFIG_JSON, slothContext);
+}
+
+export function writeProjectReviewPreamble(): void {
+  const currentDir = getCurrentDir();
+  const reviewPreamblePath = path.join(currentDir, PROJECT_GUIDELINES);
+  writeFileIfNotExistsWithMessages(
+    reviewPreamblePath,
+    'You are doing generic code review.\n' +
+      ' Important! Please remind user to prepare proper AI preamble in' +
+      PROJECT_GUIDELINES +
+      ' for this project. Use decent amount of ⚠️ to highlight lack of config.' +
+      ' Explicitly mention `' +
+      PROJECT_GUIDELINES +
+      '`.'
+  );
+}
+
+/**
+ * @deprecated test only
+ * TODO should be gone together with slothContext itself
+ */
+export function reset() {
+  Object.keys(slothContext).forEach((key) => {
+    delete (slothContext as unknown as Record<string, unknown>)[key];
+  });
+  slothContext.config = DEFAULT_CONFIG as SlothConfig;
+  slothContext.session = { configurable: { thread_id: uuidv4() } };
+}

package/src/configs/anthropic.ts

@@ -0,0 +1,57 @@
+import path from 'node:path';
+import { displayWarning } from '#src/consoleUtils.js';
+import { env, getCurrentDir } from '#src/systemUtils.js';
+import { writeFileIfNotExistsWithMessages } from '#src/utils.js';
+import type { AnthropicInput } from '@langchain/anthropic';
+import type {
+  BaseChatModel,
+  BaseChatModelParams,
+} from '@langchain/core/language_models/chat_models';
+
+// Function to process JSON config and create Anthropic LLM instance
+export async function processJsonConfig(
+  llmConfig: AnthropicInput & BaseChatModelParams
+): Promise<BaseChatModel> {
+  const anthropic = await import('@langchain/anthropic');
+  // Use environment variable if available, otherwise use the config value
+  const anthropicApiKey = env.ANTHROPIC_API_KEY || llmConfig.apiKey;
+  return new anthropic.ChatAnthropic({
+    ...llmConfig,
+    apiKey: anthropicApiKey,
+    model: llmConfig.model || 'claude-3-7-sonnet-20250219',
+  });
+}
+
+const jsContent = `/* eslint-disable */
+export async function configure(importFunction, global) {
+    // this is going to be imported from sloth dependencies,
+    // but can potentially be pulled from global node modules or from this project
+    // At a moment only google-vertexai and anthropic packaged with Sloth, but you can install support for any other langchain llms
+    const anthropic = await importFunction('@langchain/anthropic');
+    return {
+        llm: new anthropic.ChatAnthropic({
+            apiKey: process.env.ANTHROPIC_API_KEY, // Default value, but you can provide the key in many different ways, even as literal
+            model: "claude-3-7-sonnet-20250219" // Don't forget to check new models availability.
+        })
+    };
+}
+`;
+
+const jsonContent = `{
+  "llm": {
+    "type": "anthropic",
+    "apiKey": "your-api-key-here",
+    "model": "claude-3-7-sonnet-20250219"
+  }
+}`;
+
+export function init(configFileName: string): void {
+  const currentDir = getCurrentDir();
+  path.join(currentDir, configFileName);
+
+  // Determine which content to use based on file extension
+  const content = configFileName.endsWith('.json') ? jsonContent : jsContent;
+
+  writeFileIfNotExistsWithMessages(configFileName, content);
+  displayWarning(`You need to update your ${configFileName} to add your Anthropic API key.`);
+}

package/src/configs/fake.ts

@@ -0,0 +1,15 @@
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { displayWarning } from '#src/consoleUtils.js';
+import type { FakeChatInput } from '@langchain/core/utils/testing';
+
+// Function to process JSON config and create Fake LLM instance for testing
+export async function processJsonConfig(llmConfig: FakeChatInput): Promise<BaseChatModel | null> {
+  if (llmConfig.responses) {
+    const test = await import('@langchain/core/utils/testing');
+    return new test.FakeListChatModel(llmConfig);
+  }
+  displayWarning("Fake LLM requires 'responses' array in config");
+  return null;
+}
+
+// No init function needed for fake LLM as it's only used for testing

package/src/configs/groq.ts

@@ -0,0 +1,54 @@
+import path from 'node:path';
+import { displayInfo, displayWarning } from '#src/consoleUtils.js';
+import { env, getCurrentDir } from '#src/systemUtils.js';
+import { writeFileIfNotExistsWithMessages } from '#src/utils.js';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { ChatGroqInput } from '@langchain/groq';
+
+// Function to process JSON config and create Groq LLM instance
+export async function processJsonConfig(llmConfig: ChatGroqInput): Promise<BaseChatModel> {
+  const groq = await import('@langchain/groq');
+  // Use environment variable if available, otherwise use the config value
+  const groqApiKey = env.GROQ_API_KEY || llmConfig.apiKey;
+  return new groq.ChatGroq({
+    ...llmConfig,
+    apiKey: groqApiKey,
+    model: llmConfig.model || 'deepseek-r1-distill-llama-70b',
+  });
+}
+
+const jsContent = `/* eslint-disable */
+export async function configure(importFunction, global) {
+    // this is going to be imported from sloth dependencies,
+    // but can potentially be pulled from global node modules or from this project
+    const groq = await importFunction('@langchain/groq');
+    return {
+        llm: new groq.ChatGroq({
+            model: "deepseek-r1-distill-llama-70b", // Check other models available
+            apiKey: process.env.GROQ_API_KEY, // Default value, but you can provide the key in many different ways, even as literal
+        })
+    };
+}
+`;
+
+const jsonContent = `{
+  "llm": {
+    "type": "groq",
+    "model": "deepseek-r1-distill-llama-70b",
+    "apiKey": "your-api-key-here"
+  }
+}`;
+
+export function init(configFileName: string): void {
+  const currentDir = getCurrentDir();
+  path.join(currentDir, configFileName);
+
+  // Determine which content to use based on file extension
+  const content = configFileName.endsWith('.json') ? jsonContent : jsContent;
+
+  writeFileIfNotExistsWithMessages(configFileName, content);
+  displayInfo(
+    `You can define GROQ_API_KEY environment variable with your Groq API key and it will work with default model.`
+  );
+  displayWarning(`You need to edit your ${configFileName} to configure model.`);
+}

package/src/configs/vertexai.ts

@@ -0,0 +1,53 @@
+import path from 'node:path';
+import { displayWarning } from '#src/consoleUtils.js';
+import { getCurrentDir } from '#src/systemUtils.js';
+import { writeFileIfNotExistsWithMessages } from '#src/utils.js';
+import { ChatVertexAIInput } from '@langchain/google-vertexai';
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+
+const jsContent = `/* eslint-disable */
+export async function configure(importFunction, global) {
+    // this is going to be imported from sloth dependencies,
+    // but can potentially be pulled from global node modules or from this project
+    const vertexAi = await importFunction('@langchain/google-vertexai');
+    return {
+        llm: new vertexAi.ChatVertexAI({
+            model: "gemini-2.5-pro-preview-05-06", // Consider checking for latest recommended model versions
+            // temperature: 0,
+            // Other parameters might be relevant depending on Vertex AI API updates
+            // The project is not in the interface, but it is in documentation
+            // project: 'your-cool-gcloud-project'
+        })
+    }
+}
+`;
+
+const jsonContent = `{
+  "llm": {
+    "type": "vertexai",
+    "model": "gemini-2.5-pro-preview-05-06",
+    "temperature": 0
+  }
+}`;
+
+export function init(configFileName: string): void {
+  const currentDir = getCurrentDir();
+  path.join(currentDir, configFileName);
+
+  // Determine which content to use based on file extension
+  const content = configFileName.endsWith('.json') ? jsonContent : jsContent;
+
+  writeFileIfNotExistsWithMessages(configFileName, content);
+  displayWarning(
+    'For Google VertexAI you likely to need to do `gcloud auth login` and `gcloud auth application-default login`.'
+  );
+}
+
+// Function to process JSON config and create VertexAI LLM instance
+export async function processJsonConfig(llmConfig: ChatVertexAIInput): Promise<BaseChatModel> {
+  const vertexAi = await import('@langchain/google-vertexai');
+  return new vertexAi.ChatVertexAI({
+    ...llmConfig,
+    model: llmConfig.model || 'gemini-2.5-pro-preview-05-06',
+  });
+}