@llm-translate/cli 1.0.0-next.1

package/src/providers/openai.ts

@@ -0,0 +1,308 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import { generateText, streamText } from 'ai';
+import type { ProviderName } from '../types/index.js';
+import type {
+  LLMProvider,
+  ProviderConfig,
+  ChatRequest,
+  ChatResponse,
+  ModelInfo,
+} from './interface.js';
+import { TranslationError, ErrorCode } from '../errors.js';
+import { estimateTokens } from '../utils/tokens.js';
+
+// ============================================================================
+// Model Information
+// ============================================================================
+
+const MODEL_INFO: Record<string, ModelInfo> = {
+  // GPT-4o models (latest)
+  'gpt-4o': {
+    maxContextTokens: 128000,
+    supportsStreaming: true,
+    costPer1kInput: 0.0025,
+    costPer1kOutput: 0.01,
+  },
+  'gpt-4o-2024-11-20': {
+    maxContextTokens: 128000,
+    supportsStreaming: true,
+    costPer1kInput: 0.0025,
+    costPer1kOutput: 0.01,
+  },
+  'gpt-4o-2024-08-06': {
+    maxContextTokens: 128000,
+    supportsStreaming: true,
+    costPer1kInput: 0.0025,
+    costPer1kOutput: 0.01,
+  },
+  // GPT-4o mini (cost-effective)
+  'gpt-4o-mini': {
+    maxContextTokens: 128000,
+    supportsStreaming: true,
+    costPer1kInput: 0.00015,
+    costPer1kOutput: 0.0006,
+  },
+  'gpt-4o-mini-2024-07-18': {
+    maxContextTokens: 128000,
+    supportsStreaming: true,
+    costPer1kInput: 0.00015,
+    costPer1kOutput: 0.0006,
+  },
+  // GPT-4 Turbo
+  'gpt-4-turbo': {
+    maxContextTokens: 128000,
+    supportsStreaming: true,
+    costPer1kInput: 0.01,
+    costPer1kOutput: 0.03,
+  },
+  'gpt-4-turbo-2024-04-09': {
+    maxContextTokens: 128000,
+    supportsStreaming: true,
+    costPer1kInput: 0.01,
+    costPer1kOutput: 0.03,
+  },
+  // GPT-4 (original)
+  'gpt-4': {
+    maxContextTokens: 8192,
+    supportsStreaming: true,
+    costPer1kInput: 0.03,
+    costPer1kOutput: 0.06,
+  },
+  // GPT-3.5 Turbo
+  'gpt-3.5-turbo': {
+    maxContextTokens: 16385,
+    supportsStreaming: true,
+    costPer1kInput: 0.0005,
+    costPer1kOutput: 0.0015,
+  },
+  // o1 models (reasoning)
+  'o1': {
+    maxContextTokens: 200000,
+    supportsStreaming: false,
+    costPer1kInput: 0.015,
+    costPer1kOutput: 0.06,
+  },
+  'o1-preview': {
+    maxContextTokens: 128000,
+    supportsStreaming: false,
+    costPer1kInput: 0.015,
+    costPer1kOutput: 0.06,
+  },
+  'o1-mini': {
+    maxContextTokens: 128000,
+    supportsStreaming: false,
+    costPer1kInput: 0.003,
+    costPer1kOutput: 0.012,
+  },
+};
+
+// Use GPT-4o mini as default for cost-efficiency
+const DEFAULT_MODEL = 'gpt-4o-mini';
+
+// ============================================================================
+// OpenAI Provider Implementation
+// ============================================================================
+
+export class OpenAIProvider implements LLMProvider {
+  readonly name: ProviderName = 'openai';
+  readonly defaultModel: string;
+  private readonly client: ReturnType<typeof createOpenAI>;
+
+  constructor(config: ProviderConfig = {}) {
+    const apiKey = config.apiKey ?? process.env['OPENAI_API_KEY'];
+
+    if (!apiKey) {
+      throw new TranslationError(ErrorCode.PROVIDER_AUTH_FAILED, {
+        provider: 'openai',
+        message: 'OPENAI_API_KEY environment variable is not set',
+      });
+    }
+
+    this.client = createOpenAI({
+      apiKey,
+      baseURL: config.baseUrl,
+    });
+
+    this.defaultModel = config.defaultModel ?? DEFAULT_MODEL;
+  }
+
+  async chat(request: ChatRequest): Promise<ChatResponse> {
+    const model = request.model ?? this.defaultModel;
+
+    try {
+      const messages = this.convertMessages(request.messages);
+
+      const result = await generateText({
+        model: this.client(model),
+        messages,
+        temperature: request.temperature ?? 0,
+        maxTokens: request.maxTokens ?? 4096,
+      });
+
+      return {
+        content: result.text,
+        usage: {
+          inputTokens: result.usage?.promptTokens ?? 0,
+          outputTokens: result.usage?.completionTokens ?? 0,
+        },
+        model,
+        finishReason: mapFinishReason(result.finishReason),
+      };
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Convert messages to Vercel AI SDK format
+   * OpenAI doesn't support cache control like Claude, so we simplify content
+   */
+  private convertMessages(
+    messages: Array<{
+      role: 'system' | 'user' | 'assistant';
+      content: string | Array<{ type: 'text'; text: string }>;
+    }>
+  ) {
+    return messages.map((msg) => {
+      // If content is an array of parts, concatenate text
+      if (Array.isArray(msg.content)) {
+        return {
+          role: msg.role,
+          content: msg.content.map((part) => part.text).join(''),
+        };
+      }
+      return { role: msg.role, content: msg.content };
+    });
+  }
+
+  async *stream(request: ChatRequest): AsyncIterable<string> {
+    const model = request.model ?? this.defaultModel;
+    const modelInfo = this.getModelInfo(model);
+
+    // o1 models don't support streaming
+    if (!modelInfo.supportsStreaming) {
+      const response = await this.chat(request);
+      yield response.content;
+      return;
+    }
+
+    try {
+      const messages = this.convertMessages(request.messages);
+
+      const result = streamText({
+        model: this.client(model),
+        messages,
+        temperature: request.temperature ?? 0,
+        maxTokens: request.maxTokens ?? 4096,
+      });
+
+      for await (const chunk of result.textStream) {
+        yield chunk;
+      }
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  countTokens(text: string): number {
+    // Use estimation since exact counting requires tiktoken
+    return estimateTokens(text);
+  }
+
+  getModelInfo(model?: string): ModelInfo {
+    const modelName = model ?? this.defaultModel;
+    return (
+      MODEL_INFO[modelName] ?? {
+        maxContextTokens: 128000,
+        supportsStreaming: true,
+      }
+    );
+  }
+
+  private handleError(error: unknown): TranslationError {
+    if (error instanceof TranslationError) {
+      return error;
+    }
+
+    const errorMessage =
+      error instanceof Error ? error.message : String(error);
+
+    // Check for rate limiting
+    if (
+      errorMessage.includes('rate_limit') ||
+      errorMessage.includes('429') ||
+      errorMessage.includes('Rate limit')
+    ) {
+      return new TranslationError(ErrorCode.PROVIDER_RATE_LIMITED, {
+        provider: 'openai',
+        message: errorMessage,
+      });
+    }
+
+    // Check for auth errors
+    if (
+      errorMessage.includes('authentication') ||
+      errorMessage.includes('401') ||
+      errorMessage.includes('invalid_api_key') ||
+      errorMessage.includes('Incorrect API key')
+    ) {
+      return new TranslationError(ErrorCode.PROVIDER_AUTH_FAILED, {
+        provider: 'openai',
+        message: errorMessage,
+      });
+    }
+
+    // Check for quota exceeded
+    if (
+      errorMessage.includes('quota') ||
+      errorMessage.includes('insufficient_quota')
+    ) {
+      return new TranslationError(ErrorCode.PROVIDER_ERROR, {
+        provider: 'openai',
+        message: 'API quota exceeded. Please check your billing settings.',
+      });
+    }
+
+    // Check for context length errors
+    if (
+      errorMessage.includes('context_length_exceeded') ||
+      errorMessage.includes('maximum context length')
+    ) {
+      return new TranslationError(ErrorCode.CHUNK_TOO_LARGE, {
+        provider: 'openai',
+        message: errorMessage,
+      });
+    }
+
+    return new TranslationError(ErrorCode.PROVIDER_ERROR, {
+      provider: 'openai',
+      message: errorMessage,
+    });
+  }
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+function mapFinishReason(
+  reason: string | null | undefined
+): 'stop' | 'length' | 'error' {
+  switch (reason) {
+    case 'stop':
+      return 'stop';
+    case 'length':
+    case 'max_tokens':
+      return 'length';
+    default:
+      return 'error';
+  }
+}
+
+// ============================================================================
+// Factory Function
+// ============================================================================
+
+export function createOpenAIProvider(config: ProviderConfig = {}): LLMProvider {
+  return new OpenAIProvider(config);
+}

package/src/providers/registry.ts

@@ -0,0 +1,153 @@
+import type { ProviderName } from '../types/index.js';
+import type { LLMProvider, ProviderConfig, ProviderFactory } from './interface.js';
+import { TranslationError, ErrorCode } from '../errors.js';
+import { createClaudeProvider } from './claude.js';
+import { createOpenAIProvider } from './openai.js';
+import { createOllamaProvider } from './ollama.js';
+
+// ============================================================================
+// Provider Registry
+// ============================================================================
+
+const providers = new Map<ProviderName, ProviderFactory>();
+
+export function registerProvider(
+  name: ProviderName,
+  factory: ProviderFactory
+): void {
+  providers.set(name, factory);
+}
+
+export function getProvider(
+  name: ProviderName,
+  config: ProviderConfig = {}
+): LLMProvider {
+  const factory = providers.get(name);
+
+  if (!factory) {
+    throw new TranslationError(ErrorCode.PROVIDER_NOT_FOUND, {
+      provider: name,
+      available: Array.from(providers.keys()),
+    });
+  }
+
+  return factory(config);
+}
+
+export function hasProvider(name: ProviderName): boolean {
+  return providers.has(name);
+}
+
+export function getAvailableProviders(): ProviderName[] {
+  return Array.from(providers.keys());
+}
+
+// ============================================================================
+// Provider Configuration from Environment
+// ============================================================================
+
+export function getProviderConfigFromEnv(name: ProviderName): ProviderConfig {
+  switch (name) {
+    case 'claude':
+      return {
+        apiKey: process.env['ANTHROPIC_API_KEY'],
+        // defaultModel is handled by the provider itself
+      };
+
+    case 'openai':
+      return {
+        apiKey: process.env['OPENAI_API_KEY'],
+        defaultModel: 'gpt-4o',
+      };
+
+    case 'ollama':
+      return {
+        baseUrl: process.env['OLLAMA_BASE_URL'] ?? 'http://localhost:11434',
+        defaultModel: 'llama3.2', // Better multilingual support than llama2
+      };
+
+    case 'custom':
+      return {
+        apiKey: process.env['LLM_API_KEY'],
+        baseUrl: process.env['LLM_BASE_URL'],
+      };
+
+    default:
+      return {};
+  }
+}
+
+// ============================================================================
+// Create Provider with Fallback
+// ============================================================================
+
+export interface CreateProviderOptions {
+  primary: ProviderName;
+  fallback?: ProviderName[];
+  config?: Partial<Record<ProviderName, ProviderConfig>>;
+}
+
+// ============================================================================
+// Auto-register Built-in Providers
+// ============================================================================
+
+registerProvider('claude', createClaudeProvider);
+registerProvider('openai', createOpenAIProvider);
+registerProvider('ollama', createOllamaProvider);
+
+// ============================================================================
+// Create Provider with Fallback
+// ============================================================================
+
+/**
+ * Check if a provider can be used (has required credentials)
+ * Ollama doesn't require an API key, only a running server
+ */
+function canUseProvider(name: ProviderName, config: ProviderConfig): boolean {
+  if (!hasProvider(name)) {
+    return false;
+  }
+
+  // Ollama doesn't require an API key
+  if (name === 'ollama') {
+    return true;
+  }
+
+  // Other providers require an API key
+  return !!config.apiKey;
+}
+
+export function createProviderWithFallback(
+  options: CreateProviderOptions
+): LLMProvider {
+  const { primary, fallback = [], config = {} } = options;
+
+  // Try primary provider
+  const primaryConfig = {
+    ...getProviderConfigFromEnv(primary),
+    ...config[primary],
+  };
+
+  if (canUseProvider(primary, primaryConfig)) {
+    return getProvider(primary, primaryConfig);
+  }
+
+  // Try fallback providers
+  for (const fallbackName of fallback) {
+    const fallbackConfig = {
+      ...getProviderConfigFromEnv(fallbackName),
+      ...config[fallbackName],
+    };
+
+    if (canUseProvider(fallbackName, fallbackConfig)) {
+      return getProvider(fallbackName, fallbackConfig);
+    }
+  }
+
+  // No provider available
+  throw new TranslationError(ErrorCode.PROVIDER_AUTH_FAILED, {
+    primary,
+    fallback,
+    message: 'No API key found for any configured provider',
+  });
+}

package/src/server/index.ts

@@ -0,0 +1,152 @@
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { serve, type ServerType } from '@hono/node-server';
+import { HTTPException } from 'hono/http-exception';
+
+import { createAuthMiddleware } from './middleware/auth.js';
+import { createLoggerMiddleware } from './middleware/logger.js';
+import { healthRouter } from './routes/health.js';
+import { translateRouter } from './routes/translate.js';
+import type { ServerConfig, ErrorResponse, HonoVariables } from './types.js';
+
+// ============================================================================
+// Server Factory
+// ============================================================================
+
+/**
+ * Create and configure the Hono application
+ */
+export function createApp(options: ServerConfig) {
+  const app = new Hono<{ Variables: HonoVariables }>();
+
+  // Request logging (first middleware)
+  app.use('*', createLoggerMiddleware({
+    json: options.jsonLogging ?? false,
+  }));
+
+  // CORS middleware (before auth)
+  if (options.enableCors) {
+    app.use('*', cors({
+      origin: '*',
+      allowMethods: ['GET', 'POST', 'OPTIONS'],
+      allowHeaders: ['Content-Type', 'Authorization', 'X-API-Key'],
+      exposeHeaders: ['X-Request-Id'],
+      maxAge: 86400,
+    }));
+  }
+
+  // Health endpoints (no auth required)
+  app.route('/health', healthRouter);
+
+  // Authentication middleware for /translate
+  app.use('/translate/*', createAuthMiddleware({
+    enabled: options.enableAuth,
+    apiKey: options.apiKey,
+  }));
+
+  // Also apply auth to the base /translate endpoint
+  app.use('/translate', createAuthMiddleware({
+    enabled: options.enableAuth,
+    apiKey: options.apiKey,
+  }));
+
+  // Translation endpoint
+  app.route('/translate', translateRouter);
+
+  // Global error handler
+  app.onError((error, c) => {
+    if (error instanceof HTTPException) {
+      return c.json<ErrorResponse>(
+        {
+          error: error.message,
+          code: 'HTTP_ERROR',
+        },
+        error.status
+      );
+    }
+
+    console.error('Unhandled error:', error);
+
+    return c.json<ErrorResponse>(
+      {
+        error: 'Internal server error',
+        code: 'INTERNAL_ERROR',
+      },
+      500
+    );
+  });
+
+  // 404 handler
+  app.notFound((c) => {
+    return c.json<ErrorResponse>(
+      {
+        error: 'Not found',
+        code: 'NOT_FOUND',
+      },
+      404
+    );
+  });
+
+  return app;
+}
+
+// ============================================================================
+// Server Startup
+// ============================================================================
+
+/**
+ * Start the HTTP server with graceful shutdown
+ */
+export function startServer(options: ServerConfig): ServerType {
+  const app = createApp(options);
+
+  const server = serve({
+    fetch: app.fetch,
+    port: options.port,
+    hostname: options.host,
+  });
+
+  // Log startup information
+  console.log(`\nllm-translate server started`);
+  console.log(`  - Address: http://${options.host}:${options.port}`);
+  console.log(`  - Health: http://${options.host}:${options.port}/health`);
+  console.log(`  - Translate: http://${options.host}:${options.port}/translate`);
+  console.log(`  - Auth: ${options.enableAuth ? 'enabled' : 'disabled'}`);
+  console.log(`  - CORS: ${options.enableCors ? 'enabled' : 'disabled'}`);
+  console.log('');
+
+  // Graceful shutdown handlers
+  const shutdown = (signal: string) => {
+    console.log(`\nReceived ${signal}, shutting down gracefully...`);
+
+    server.close((err) => {
+      if (err) {
+        console.error('Error during shutdown:', err);
+        process.exit(1);
+      }
+      console.log('Server closed');
+      process.exit(0);
+    });
+
+    // Force exit after timeout
+    setTimeout(() => {
+      console.error('Forced shutdown after timeout');
+      process.exit(1);
+    }, 10000);
+  };
+
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+  process.on('SIGINT', () => shutdown('SIGINT'));
+
+  return server;
+}
+
+// ============================================================================
+// Exports
+// ============================================================================
+
+export type { ServerConfig } from './types.js';
+export { createAuthMiddleware } from './middleware/auth.js';
+export { createLoggerMiddleware } from './middleware/logger.js';
+export { healthRouter } from './routes/health.js';
+export { translateRouter } from './routes/translate.js';

package/src/server/middleware/auth.ts

@@ -0,0 +1,93 @@
+import { createMiddleware } from 'hono/factory';
+import { HTTPException } from 'hono/http-exception';
+import type { Context, Next } from 'hono';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface AuthConfig {
+  enabled: boolean;
+  apiKey?: string;
+}
+
+// ============================================================================
+// Authentication Middleware
+// ============================================================================
+
+/**
+ * API Key authentication middleware
+ * Supports both X-API-Key header and Authorization: Bearer token
+ */
+export function createAuthMiddleware(config: AuthConfig) {
+  return createMiddleware(async (c: Context, next: Next) => {
+    // Skip auth if disabled
+    if (!config.enabled) {
+      return next();
+    }
+
+    // Get API key from config or environment
+    const expectedKey = config.apiKey ?? process.env.TRANSLATE_API_KEY;
+
+    if (!expectedKey) {
+      // No API key configured, skip auth (warning should be logged at startup)
+      return next();
+    }
+
+    // Check X-API-Key header first
+    let providedKey = c.req.header('X-API-Key');
+
+    // Fall back to Authorization: Bearer <token>
+    if (!providedKey) {
+      const authHeader = c.req.header('Authorization');
+      if (authHeader?.startsWith('Bearer ')) {
+        providedKey = authHeader.slice(7);
+      }
+    }
+
+    if (!providedKey) {
+      throw new HTTPException(401, {
+        message:
+          'API key required. Provide via X-API-Key header or Authorization: Bearer <token>',
+      });
+    }
+
+    // Constant-time comparison to prevent timing attacks
+    if (!timingSafeEqual(providedKey, expectedKey)) {
+      throw new HTTPException(401, {
+        message: 'Invalid API key',
+      });
+    }
+
+    return next();
+  });
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Timing-safe string comparison to prevent timing attacks
+ * @param a First string
+ * @param b Second string
+ * @returns true if strings are equal
+ */
+function timingSafeEqual(a: string, b: string): boolean {
+  if (a.length !== b.length) {
+    // Still perform comparison to maintain constant time
+    // even when lengths differ
+    let result = 1;
+    const maxLen = Math.max(a.length, b.length);
+    for (let i = 0; i < maxLen; i++) {
+      result |= (a.charCodeAt(i % a.length) || 0) ^ (b.charCodeAt(i % b.length) || 0);
+    }
+    return false;
+  }
+
+  let result = 0;
+  for (let i = 0; i < a.length; i++) {
+    result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return result === 0;
+}