@auto-engineer/ai-gateway 0.11.14 → 0.11.16

package/src/node/config.ts

@@ -0,0 +1,100 @@
+import dotenv from 'dotenv';
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+import createDebug from 'debug';
+import { CustomProviderConfig, AIConfig } from '../core/types';
+
+const debug = createDebug('auto:ai-gateway:config');
+const debugEnv = createDebug('auto:ai-gateway:config:env');
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const envPath = resolve(__dirname, '../../../../.env');
+debug('Loading environment from: %s', envPath);
+dotenv.config({ path: envPath });
+
+function logProviderConfig(providerName: string, apiKey: string | undefined): void {
+  if (apiKey !== undefined) {
+    debug('%s provider configured with API key ending in: ...%s', providerName, apiKey.slice(-4));
+  }
+}
+
+function buildCustomProviderConfig(): CustomProviderConfig | undefined {
+  const name = process.env.CUSTOM_PROVIDER_NAME;
+  const baseUrl = process.env.CUSTOM_PROVIDER_BASE_URL;
+  const apiKey = process.env.CUSTOM_PROVIDER_API_KEY;
+  const defaultModel = process.env.CUSTOM_PROVIDER_DEFAULT_MODEL;
+
+  if (
+    name != null &&
+    name.length > 0 &&
+    baseUrl != null &&
+    baseUrl.length > 0 &&
+    apiKey != null &&
+    apiKey.length > 0 &&
+    defaultModel != null &&
+    defaultModel.length > 0
+  ) {
+    return {
+      name,
+      baseUrl,
+      apiKey,
+      defaultModel,
+    };
+  }
+
+  return undefined;
+}
+
+function buildProviderConfig(): AIConfig {
+  return {
+    openai: process.env.OPENAI_API_KEY != null ? { apiKey: process.env.OPENAI_API_KEY } : undefined,
+    anthropic: process.env.ANTHROPIC_API_KEY != null ? { apiKey: process.env.ANTHROPIC_API_KEY } : undefined,
+    google: process.env.GEMINI_API_KEY != null ? { apiKey: process.env.GEMINI_API_KEY } : undefined,
+    xai: process.env.XAI_API_KEY != null ? { apiKey: process.env.XAI_API_KEY } : undefined,
+    custom: buildCustomProviderConfig(),
+  };
+}
+
+export function configureAIProvider(): AIConfig {
+  debugEnv('Checking environment variables for AI providers');
+
+  const config = buildProviderConfig();
+
+  debugEnv('OpenAI configured: %s', config.openai != null);
+  debugEnv('Anthropic configured: %s', config.anthropic != null);
+  debugEnv('Google configured: %s', config.google != null);
+  debugEnv('XAI configured: %s', config.xai != null);
+  debugEnv('Custom configured: %s', config.custom != null);
+
+  logProviderConfig('OpenAI', config.openai?.apiKey);
+  logProviderConfig('Anthropic', config.anthropic?.apiKey);
+  logProviderConfig('Google', config.google?.apiKey);
+  logProviderConfig('XAI', config.xai?.apiKey);
+
+  if (config.custom != null) {
+    debug(
+      'Custom provider configured: %s at %s with model %s',
+      config.custom.name,
+      config.custom.baseUrl,
+      config.custom.defaultModel,
+    );
+    logProviderConfig('Custom', config.custom.apiKey);
+  }
+
+  const configuredProviders = [config.openai, config.anthropic, config.google, config.xai, config.custom].filter(
+    (p) => p != null,
+  );
+
+  if (configuredProviders.length === 0) {
+    debug('ERROR: No AI providers configured');
+    throw new Error(
+      'At least one AI provider must be configured. Please set OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY, XAI_API_KEY environment variables, or configure a custom provider with CUSTOM_PROVIDER_NAME, CUSTOM_PROVIDER_BASE_URL, CUSTOM_PROVIDER_API_KEY, and CUSTOM_PROVIDER_DEFAULT_MODEL.',
+    );
+  }
+
+  debug('AI configuration complete - %d provider(s) available', configuredProviders.length);
+
+  return config;
+}

package/src/node/index.ts

@@ -0,0 +1,60 @@
+export { AIProvider } from '../core/types';
+export type {
+  CustomProviderConfig,
+  AIConfig,
+  AIContext,
+  AIOptions,
+  StructuredAIOptions,
+  StreamStructuredAIOptions,
+  AIToolValidationError,
+  RegisteredToolForAI,
+} from '../core/types';
+
+export { DEFAULT_MODELS } from '../core/constants';
+
+export { createAIContext, getModel } from '../core/context';
+
+export {
+  generateText,
+  streamText,
+  generateTextStreaming,
+  generateTextWithImage,
+  generateStructuredData,
+  streamStructuredData,
+  generateTextWithTools,
+} from '../core/generators';
+
+export { createCustomProvider } from '../core/providers/custom';
+
+export { configureAIProvider } from './config';
+
+export {
+  getDefaultAIProvider,
+  getDefaultModel,
+  getAvailableProviders,
+  generateTextWithAI,
+  streamTextWithAI,
+  generateTextStreamingWithAI,
+  generateTextWithImageAI,
+  generateStructuredDataWithAI,
+  streamStructuredDataWithAI,
+  generateTextWithToolsAI,
+  resetGlobalContext,
+} from './wrappers';
+
+export {
+  server as mcpServer,
+  registerTool,
+  registerTools,
+  startServer,
+  isServerStarted,
+  getRegisteredTools,
+  getRegisteredToolsForAI,
+  getToolHandler,
+  getSchemaByName,
+  executeRegisteredTool,
+  type ToolHandler,
+  type RegisteredTool,
+} from './mcp-server';
+
+export { z } from 'zod';

package/src/node/mcp-server.ts

@@ -0,0 +1,261 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import createDebug from 'debug';
+
+const debug = createDebug('auto:ai-gateway:mcp');
+const debugServer = createDebug('auto:ai-gateway:mcp:server');
+const debugTools = createDebug('auto:ai-gateway:mcp:tools');
+const debugRegistry = createDebug('auto:ai-gateway:mcp:registry');
+const debugExecution = createDebug('auto:ai-gateway:mcp:execution');
+
+interface ToolResult {
+  content: Array<{
+    type: 'text';
+    text: string;
+  }>;
+  isError?: boolean;
+  [key: string]: unknown;
+}
+
+interface ToolDescription {
+  title: string;
+  description: string;
+  inputSchema: Record<string, z.ZodSchema>;
+  schema?: z.ZodSchema;
+  schemaName?: string;
+  schemaDescription?: string;
+}
+
+type ToolHandler<T extends Record<string, unknown> = Record<string, unknown>> = (params: T) => Promise<ToolResult>;
+
+interface RegisteredTool {
+  name: string;
+  description: ToolDescription;
+  handler: ToolHandler<Record<string, unknown>>;
+  aiSdkTool: {
+    parameters: z.ZodSchema;
+    description: string;
+    execute?: (args: Record<string, unknown>) => Promise<string>;
+  };
+}
+
+debugServer('Creating MCP server instance - name: frontend-implementer, version: 0.1.0');
+const server = new McpServer({
+  name: 'frontend-implementer',
+  version: '0.1.0',
+});
+
+const transport = new StdioServerTransport();
+debugServer('StdioServerTransport created');
+
+let isStarted = false;
+const toolRegistry = new Map<string, RegisteredTool>();
+debugRegistry('Tool registry initialized');
+
+async function cleanup() {
+  debug('Cleanup initiated');
+  console.log('Cleaning up...');
+  await transport.close();
+  debugServer('Transport closed');
+  process.exit(0);
+}
+
+process.on('SIGTERM', () => {
+  void cleanup();
+});
+process.on('SIGINT', () => {
+  void cleanup();
+});
+
+export { server };
+
+function createMcpHandler<T extends Record<string, unknown>>(
+  handler: ToolHandler<T>,
+): (args: Record<string, unknown>, extra: unknown) => Promise<ToolResult> {
+  return (args: Record<string, unknown>, _extra: unknown) => {
+    debugExecution('MCP handler invoked with args: %o', args);
+    return handler(args as T);
+  };
+}
+
+function createAiSdkTool(description: ToolDescription, handler: ToolHandler) {
+  const parameterSchema =
+    Object.keys(description.inputSchema).length > 0 ? z.object(description.inputSchema) : z.object({}).passthrough();
+
+  debugTools('Creating AI SDK tool with %d parameters', Object.keys(description.inputSchema).length);
+
+  return {
+    parameters: parameterSchema,
+    description: description.description,
+    execute: async (args: Record<string, unknown>) => {
+      debugExecution('AI SDK tool execute called with args: %o', args);
+      const result = await handler(args);
+      const textOutput = result.content[0]?.text || '';
+      debugExecution('Tool execution result length: %d', textOutput.length);
+
+      if (description.schema) {
+        try {
+          const parsed = JSON.parse(textOutput) as unknown;
+          description.schema.parse(parsed);
+          debugExecution('Tool output validated against schema successfully');
+          return textOutput;
+        } catch (parseError) {
+          debugExecution('Tool failed to parse/validate JSON output: %O', parseError);
+          return textOutput;
+        }
+      }
+
+      return textOutput;
+    },
+    ...(description.schema && { schema: description.schema }),
+    ...(description.schemaName != null && { schemaName: description.schemaName }),
+    ...(description.schemaDescription != null && { schemaDescription: description.schemaDescription }),
+  };
+}
+
+export function registerTool<T extends Record<string, unknown> = Record<string, unknown>>(
+  name: string,
+  description: ToolDescription,
+  handler: ToolHandler<T>,
+) {
+  debugRegistry('Registering MCP tool: %s', name);
+  console.log(`🔧 Registering MCP tool: ${name}`);
+
+  if (isStarted) {
+    debugRegistry('ERROR: Cannot register tool %s after server has started', name);
+    throw new Error('Cannot register tools after server has started');
+  }
+
+  if (toolRegistry.has(name)) {
+    debugRegistry('Tool %s is already registered, skipping registration', name);
+    console.log(`Tool ${name} is already registered, skipping registration. Total tools: ${toolRegistry.size}`);
+    return;
+  }
+
+  const mcpHandler = createMcpHandler(handler);
+  const aiSdkTool = createAiSdkTool(description, handler as ToolHandler<Record<string, unknown>>);
+
+  const registeredTool: RegisteredTool = {
+    name,
+    description,
+    handler: handler as ToolHandler<Record<string, unknown>>,
+    aiSdkTool,
+  };
+
+  toolRegistry.set(name, registeredTool);
+
+  try {
+    server.registerTool(name, description, mcpHandler);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes('already registered')) {
+      debugRegistry('Tool %s already registered in underlying server, ignoring error', name);
+      console.log(`⚠️ Tool ${name} already registered in underlying server, ignoring duplicate registration error`);
+    } else {
+      throw error;
+    }
+  }
+  debugRegistry('Tool %s registered successfully. Total tools: %d', name, toolRegistry.size);
+  console.log(`✅ Tool ${name} registered successfully. Total tools: ${toolRegistry.size}`);
+}
+
+export function registerTools<T extends Record<string, unknown> = Record<string, unknown>>(
+  tools: Array<{
+    name: string;
+    description: ToolDescription;
+    handler: ToolHandler<T>;
+  }>,
+) {
+  debugRegistry('Batch registering %d tools', tools.length);
+  if (isStarted) {
+    debugRegistry('ERROR: Cannot register tools after server has started');
+    throw new Error('Cannot register tools after server has started');
+  }
+  tools.forEach((tool) => {
+    registerTool(tool.name, tool.description, tool.handler);
+  });
+  debugRegistry('Batch registration complete');
+}
+
+export async function startServer() {
+  if (isStarted) {
+    debugServer('Server already started, skipping');
+    return;
+  }
+
+  debugServer('Starting MCP server...');
+  await server.connect(transport);
+  isStarted = true;
+  debugServer('MCP server started successfully');
+}
+
+export function isServerStarted() {
+  debugServer('Checking server status: %s', isStarted ? 'started' : 'not started');
+  return isStarted;
+}
+
+export function getRegisteredTools(): RegisteredTool[] {
+  const tools = Array.from(toolRegistry.values());
+  debugRegistry('Getting all registered tools: %d tools', tools.length);
+  return tools;
+}
+
+export function getRegisteredToolsForAI(): Record<
+  string,
+  {
+    parameters: z.ZodSchema;
+    description: string;
+    execute?: (args: Record<string, unknown>) => Promise<string>;
+  }
+> {
+  debugRegistry('Getting registered tools for AI. Registry size: %d', toolRegistry.size);
+  console.log(`📋 Getting registered tools for AI. Registry size: ${toolRegistry.size}`);
+  const tools: Record<
+    string,
+    {
+      parameters: z.ZodSchema;
+      description: string;
+      execute?: (args: Record<string, unknown>) => Promise<string>;
+    }
+  > = {};
+  for (const tool of toolRegistry.values()) {
+    tools[tool.name] = tool.aiSdkTool;
+    debugRegistry('  - Tool: %s', tool.name);
+    console.log(`  - Tool: ${tool.name}`);
+  }
+  debugRegistry('Returning %d tools for AI', Object.keys(tools).length);
+  console.log(`📊 Returning ${Object.keys(tools).length} tools for AI`);
+  return tools;
+}
+
+export function getToolHandler(name: string): ToolHandler | undefined {
+  const handler = toolRegistry.get(name)?.handler;
+  debugRegistry('Getting tool handler for %s: %s', name, handler ? 'found' : 'not found');
+  return handler;
+}
+
+export async function executeRegisteredTool(name: string, params: Record<string, unknown>): Promise<ToolResult> {
+  debugExecution('Executing registered tool: %s with params: %o', name, params);
+  const tool = toolRegistry.get(name);
+  if (!tool) {
+    debugExecution('ERROR: Tool %s not found', name);
+    throw new Error(`Tool '${name}' not found`);
+  }
+  const result = await tool.handler(params);
+  debugExecution('Tool %s executed successfully', name);
+  return result;
+}
+
+export function getSchemaByName(schemaName: string): z.ZodSchema | undefined {
+  debugRegistry('Looking for schema with name: %s', schemaName);
+  for (const tool of toolRegistry.values()) {
+    if (tool.description?.schemaName === schemaName) {
+      debugRegistry('Schema %s found in tool %s', schemaName, tool.name);
+      return tool.description.schema;
+    }
+  }
+  debugRegistry('Schema %s not found', schemaName);
+  return undefined;
+}
+
+export type { ToolResult, ToolDescription, ToolHandler, RegisteredTool };

package/src/node/wrappers.ts

@@ -0,0 +1,136 @@
+import { AIContext, AIOptions, StructuredAIOptions, StreamStructuredAIOptions, AIProvider } from '../core/types';
+import {
+  createAIContext,
+  getDefaultProvider as coreGetDefaultProvider,
+  getAvailableProviders as coreGetAvailableProviders,
+  getDefaultModel as coreGetDefaultModel,
+} from '../core/context';
+import {
+  generateText as coreGenerateText,
+  streamText as coreStreamText,
+  generateTextStreaming as coreGenerateTextStreaming,
+  generateTextWithImage as coreGenerateTextWithImage,
+  generateStructuredData as coreGenerateStructuredData,
+  streamStructuredData as coreStreamStructuredData,
+  generateTextWithTools as coreGenerateTextWithTools,
+} from '../core/generators';
+import { configureAIProvider } from './config';
+import { getRegisteredToolsForAI, startServer } from './mcp-server';
+
+let globalContext: AIContext | null = null;
+
+export function resetGlobalContext(): void {
+  globalContext = null;
+}
+
+function getOrCreateContext(): AIContext {
+  if (!globalContext) {
+    const config = configureAIProvider();
+    const defaultProvider = determineDefaultProvider();
+    globalContext = createAIContext(config, defaultProvider);
+  }
+  return globalContext;
+}
+
+function determineDefaultProvider(): AIProvider | undefined {
+  const envProvider = process.env.DEFAULT_AI_PROVIDER?.toLowerCase();
+  switch (envProvider) {
+    case 'openai':
+      return AIProvider.OpenAI;
+    case 'anthropic':
+      return AIProvider.Anthropic;
+    case 'google':
+      return AIProvider.Google;
+    case 'xai':
+      return AIProvider.XAI;
+    default:
+      return undefined;
+  }
+}
+
+export function getDefaultAIProvider(): AIProvider {
+  const context = getOrCreateContext();
+  return coreGetDefaultProvider(context);
+}
+
+export function getDefaultModel(provider: AIProvider): string {
+  const envModel = process.env.DEFAULT_AI_MODEL;
+  if (envModel !== undefined && envModel !== null && envModel.trim().length > 0) {
+    return envModel.trim();
+  }
+
+  const context = getOrCreateContext();
+  return coreGetDefaultModel(provider, context);
+}
+
+export function getAvailableProviders(): AIProvider[] {
+  const context = getOrCreateContext();
+  return coreGetAvailableProviders(context);
+}
+
+export async function generateTextWithAI(prompt: string, options: AIOptions = {}): Promise<string> {
+  const context = getOrCreateContext();
+
+  if (options.includeTools === true) {
+    try {
+      await startServer();
+    } catch (e) {
+      throw new Error(`MCP server failed to start: ${(e as Error).message}`);
+    }
+    const tools = getRegisteredToolsForAI();
+    const result = await coreGenerateTextWithTools(context, prompt, options, tools);
+    return result.text;
+  }
+
+  return coreGenerateText(context, prompt, options);
+}
+
+export async function* streamTextWithAI(prompt: string, options: AIOptions = {}): AsyncGenerator<string> {
+  const context = getOrCreateContext();
+  yield* coreStreamText(context, prompt, options);
+}
+
+export async function generateTextStreamingWithAI(prompt: string, options: AIOptions = {}): Promise<string> {
+  const context = getOrCreateContext();
+  return coreGenerateTextStreaming(context, prompt, options);
+}
+
+export async function generateTextWithImageAI(
+  text: string,
+  imageBase64: string,
+  options: AIOptions = {},
+): Promise<string> {
+  const context = getOrCreateContext();
+  return coreGenerateTextWithImage(context, text, imageBase64, options);
+}
+
+export async function generateStructuredDataWithAI<T>(prompt: string, options: StructuredAIOptions<T>): Promise<T> {
+  const context = getOrCreateContext();
+
+  if (options.includeTools === true) {
+    try {
+      await startServer();
+    } catch (e) {
+      throw new Error(`MCP server failed to start: ${(e as Error).message}`);
+    }
+    const tools = getRegisteredToolsForAI();
+    return coreGenerateStructuredData(context, prompt, options, tools);
+  }
+
+  return coreGenerateStructuredData(context, prompt, options);
+}
+
+export async function streamStructuredDataWithAI<T>(prompt: string, options: StreamStructuredAIOptions<T>): Promise<T> {
+  const context = getOrCreateContext();
+  return coreStreamStructuredData(context, prompt, options);
+}
+
+export async function generateTextWithToolsAI(
+  prompt: string,
+  options: AIOptions = {},
+): Promise<{ text: string; toolCalls?: unknown[] }> {
+  const context = getOrCreateContext();
+  await startServer();
+  const tools = getRegisteredToolsForAI();
+  return coreGenerateTextWithTools(context, prompt, options, tools);
+}

package/src/providers/custom.specs.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createCustomProvider } from './custom';
-import { CustomProviderConfig } from '../constants';
+import { createCustomProvider } from '../core/providers/custom';
+import { CustomProviderConfig } from '../core/types';
 
 interface MockConfig {
   name: string;