@vibe-lang/runtime 0.2.5

package/src/runtime/ai/providers/google.ts

@@ -0,0 +1,201 @@
+// Google Generative AI Provider Implementation using official SDK
+
+import { GoogleGenAI } from '@google/genai';
+import type { AIRequest, AIResponse, AIToolCall, ThinkingLevel } from '../types';
+import { AIError } from '../types';
+import { buildSystemMessage, buildContextMessage, buildPromptMessage, buildToolSystemMessage } from '../formatters';
+import { toGoogleFunctionDeclarations } from '../tool-schema';
+
+/** Map thinking level to Google Gemini 3 thinkingLevel */
+const THINKING_LEVEL_MAP: Record<ThinkingLevel, string | null> = {
+  none: null,       // Don't set thinkingConfig
+  low: 'low',
+  medium: 'medium',
+  high: 'high',
+  max: 'high',      // Gemini 3 Flash max is 'high'
+};
+
+/** Generate a unique ID for tool calls (Google doesn't provide one) */
+function generateToolCallId(): string {
+  return `call_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+
+/**
+ * Execute an AI request using the Google Gen AI SDK.
+ */
+export async function executeGoogle(request: AIRequest): Promise<AIResponse> {
+  const { prompt, contextText, targetType, model, tools, previousToolCalls, toolResults } = request;
+
+  // Create Google Gen AI client
+  const client = new GoogleGenAI({ apiKey: model.apiKey });
+
+  // Build combined prompt (Google uses a simpler message format)
+  const baseSystemInstruction = buildSystemMessage();
+  const toolSystemMessage = tools?.length ? buildToolSystemMessage(tools) : null;
+  const systemInstruction = toolSystemMessage
+    ? `${baseSystemInstruction}\n\n${toolSystemMessage}`
+    : baseSystemInstruction;
+
+  const contextMessage = buildContextMessage(contextText);
+  const promptMessage = buildPromptMessage(prompt);
+
+  // Combine into single prompt for Google
+  const parts: string[] = [];
+  if (contextMessage) parts.push(contextMessage);
+  parts.push(promptMessage);
+  const combinedPrompt = parts.join('\n\n');
+
+  // Build conversation contents - either simple prompt or multi-turn with tool results
+  type ContentPart = { text: string } | { functionCall: { name: string; args: Record<string, unknown> } } | { functionResponse: { name: string; response: unknown } };
+  type Content = { role: 'user' | 'model'; parts: ContentPart[] };
+
+  let contents: string | Content[];
+
+  if (previousToolCalls?.length && toolResults?.length) {
+    // Multi-turn conversation with tool results
+    // 1. Original user message
+    const userMessage: Content = {
+      role: 'user',
+      parts: [{ text: combinedPrompt }],
+    };
+
+    // 2. Model message with function calls (including thoughtSignature for Gemini 3)
+    const modelParts: ContentPart[] = previousToolCalls.map(call => {
+      const part: ContentPart = {
+        functionCall: {
+          name: call.toolName,
+          args: call.args,
+        },
+      };
+      // Include thoughtSignature if present (required for Gemini 3)
+      if (call.thoughtSignature) {
+        (part as Record<string, unknown>).thoughtSignature = call.thoughtSignature;
+      }
+      return part;
+    });
+    const modelMessage: Content = {
+      role: 'model',
+      parts: modelParts,
+    };
+
+    // 3. User message with function responses
+    const responseParts: ContentPart[] = toolResults.map((result, i) => ({
+      functionResponse: {
+        name: previousToolCalls[i].toolName,
+        response: result.error
+          ? { error: result.error }
+          : { result: result.result },
+      },
+    }));
+    const responseMessage: Content = {
+      role: 'user',
+      parts: responseParts,
+    };
+
+    contents = [userMessage, modelMessage, responseMessage];
+  } else {
+    // Simple single prompt
+    contents = combinedPrompt;
+  }
+
+  try {
+    // Build generation config
+    const generationConfig: Record<string, unknown> = {};
+
+    // Add thinking config if level specified
+    const thinkingLevel = model.thinkingLevel as ThinkingLevel | undefined;
+    const googleThinkingLevel = thinkingLevel ? THINKING_LEVEL_MAP[thinkingLevel] : null;
+    if (googleThinkingLevel) {
+      generationConfig.thinkingConfig = {
+        thinkingLevel: googleThinkingLevel,
+      };
+    }
+
+    // Build config with optional tools
+    const config: Record<string, unknown> = {
+      systemInstruction,
+      ...generationConfig,
+    };
+
+    // Add tools if provided
+    if (tools?.length) {
+      config.tools = [{ functionDeclarations: toGoogleFunctionDeclarations(tools) }];
+    }
+
+    // Make API request
+    // Cast contents to unknown to avoid strict SDK type checking (we build valid content)
+    const response = await client.models.generateContent({
+      model: model.name,
+      contents: contents as unknown as Parameters<typeof client.models.generateContent>[0]['contents'],
+      config,
+    });
+
+    // Extract text content
+    const content = response.text ?? '';
+
+    // Extract function calls from response parts (including thoughtSignature for Gemini 3)
+    const responseParts = (response.candidates?.[0]?.content?.parts ?? []) as Array<{
+      text?: string;
+      functionCall?: { name: string; args: Record<string, unknown> };
+      thoughtSignature?: string;
+    }>;
+    const functionCallParts = responseParts.filter((p) => p.functionCall);
+    let toolCalls: AIToolCall[] | undefined;
+    if (functionCallParts.length > 0) {
+      toolCalls = functionCallParts.map((p) => ({
+        id: generateToolCallId(),
+        toolName: p.functionCall!.name,
+        args: p.functionCall!.args,
+        thoughtSignature: p.thoughtSignature,
+      }));
+    }
+
+    // Determine stop reason
+    const finishReason = response.candidates?.[0]?.finishReason as string | undefined;
+    const stopReason =
+      finishReason === 'STOP'
+        ? (toolCalls?.length ? 'tool_use' : 'end')
+        : finishReason === 'MAX_TOKENS'
+          ? 'length'
+          : finishReason === 'SAFETY'
+            ? 'content_filter'
+            : 'end';
+
+    // Extract usage from response including cached and thinking tokens
+    const meta = response.usageMetadata as Record<string, unknown> | undefined;
+    const usage = meta
+      ? {
+          inputTokens: Number(meta.promptTokenCount ?? 0),
+          outputTokens: Number(meta.candidatesTokenCount ?? 0),
+          cachedInputTokens: meta.cachedContentTokenCount ? Number(meta.cachedContentTokenCount) : undefined,
+          thinkingTokens: meta.thoughtsTokenCount ? Number(meta.thoughtsTokenCount) : undefined,
+        }
+      : undefined;
+
+    // For text responses, parsedValue is just the content
+    // For typed responses, the value comes from return tool calls (handled by tool-loop)
+    return { content, parsedValue: content, usage, toolCalls, stopReason };
+  } catch (error) {
+    // Handle Google API errors
+    if (error instanceof Error) {
+      const message = error.message.toLowerCase();
+      const isRetryable =
+        message.includes('429') ||
+        message.includes('rate limit') ||
+        message.includes('500') ||
+        message.includes('503') ||
+        message.includes('service unavailable');
+
+      // Extract status code if present
+      const statusMatch = error.message.match(/(\d{3})/);
+      const statusCode = statusMatch ? parseInt(statusMatch[1]) : undefined;
+
+      throw new AIError(
+        `Google API error: ${error.message}`,
+        statusCode,
+        isRetryable
+      );
+    }
+    throw error;
+  }
+}

package/src/runtime/ai/providers/openai.ts

@@ -0,0 +1,156 @@
+// OpenAI Provider Implementation using official SDK
+
+import OpenAI from 'openai';
+import type { AIRequest, AIResponse, AIToolCall, ThinkingLevel } from '../types';
+import { AIError } from '../types';
+import { buildMessages } from '../formatters';
+import { toOpenAITools } from '../tool-schema';
+
+/** OpenAI provider configuration */
+export const OPENAI_CONFIG = {
+  defaultUrl: 'https://api.openai.com/v1',
+};
+
+/** Map thinking level to OpenAI reasoning_effort */
+const REASONING_EFFORT_MAP: Record<ThinkingLevel, string> = {
+  none: 'none',
+  low: 'low',
+  medium: 'medium',
+  high: 'high',
+  max: 'xhigh',  // OpenAI uses 'xhigh' for max reasoning
+};
+
+/**
+ * Execute an AI request using the OpenAI SDK.
+ */
+export async function executeOpenAI(request: AIRequest): Promise<AIResponse> {
+  const { prompt, contextText, targetType, model, tools, previousToolCalls, toolResults } = request;
+
+  // Create OpenAI client
+  const client = new OpenAI({
+    apiKey: model.apiKey,
+    baseURL: model.url ?? OPENAI_CONFIG.defaultUrl,
+  });
+
+  // Build base messages
+  const baseMessages = buildMessages(prompt, contextText, tools);
+
+  // Build conversation messages - either simple or multi-turn with tool results
+  type ChatMessage = OpenAI.ChatCompletionMessageParam;
+  let messages: ChatMessage[] = baseMessages.map((m) => ({
+    role: m.role as 'system' | 'user' | 'assistant',
+    content: m.content,
+  }));
+
+  // Add tool call history if present (multi-turn conversation)
+  if (previousToolCalls?.length && toolResults?.length) {
+    // Add assistant message with tool calls
+    const assistantMessage: ChatMessage = {
+      role: 'assistant',
+      content: null,
+      tool_calls: previousToolCalls.map(call => ({
+        id: call.id,
+        type: 'function' as const,
+        function: {
+          name: call.toolName,
+          arguments: JSON.stringify(call.args),
+        },
+      })),
+    };
+    messages.push(assistantMessage);
+
+    // Add tool result messages
+    for (let i = 0; i < toolResults.length; i++) {
+      const result = toolResults[i];
+      const call = previousToolCalls[i];
+      const toolMessage: ChatMessage = {
+        role: 'tool',
+        tool_call_id: call.id,
+        content: result.error
+          ? `Error: ${result.error}`
+          : typeof result.result === 'string'
+            ? result.result
+            : JSON.stringify(result.result),
+      };
+      messages.push(toolMessage);
+    }
+  }
+
+  try {
+    // Build request parameters
+    const params: OpenAI.ChatCompletionCreateParamsNonStreaming = {
+      model: model.name,
+      messages,
+    };
+
+    // Add tools if provided
+    if (tools?.length) {
+      params.tools = toOpenAITools(tools) as OpenAI.ChatCompletionTool[];
+    }
+
+    // Add reasoning effort if thinking level specified
+    const thinkingLevel = model.thinkingLevel as ThinkingLevel | undefined;
+    if (thinkingLevel) {
+      (params as unknown as Record<string, unknown>).reasoning_effort = REASONING_EFFORT_MAP[thinkingLevel];
+    }
+
+    // Make API request
+    const completion = await client.chat.completions.create(params);
+
+    // Extract message
+    const message = completion.choices[0]?.message;
+    const content = message?.content ?? '';
+    const finishReason = completion.choices[0]?.finish_reason;
+
+    // Extract usage including cached and reasoning tokens
+    const rawUsage = completion.usage as unknown as Record<string, unknown> | undefined;
+    const promptDetails = rawUsage?.prompt_tokens_details as Record<string, unknown> | undefined;
+    const completionDetails = rawUsage?.completion_tokens_details as Record<string, unknown> | undefined;
+    const usage = rawUsage
+      ? {
+          inputTokens: Number(rawUsage.prompt_tokens ?? 0),
+          outputTokens: Number(rawUsage.completion_tokens ?? 0),
+          cachedInputTokens: promptDetails?.cached_tokens ? Number(promptDetails.cached_tokens) : undefined,
+          thinkingTokens: completionDetails?.reasoning_tokens ? Number(completionDetails.reasoning_tokens) : undefined,
+        }
+      : undefined;
+
+    // Parse tool calls if present
+    let toolCalls: AIToolCall[] | undefined;
+    if (message?.tool_calls?.length) {
+      toolCalls = message.tool_calls
+        .filter((tc): tc is OpenAI.ChatCompletionMessageToolCall & { function: { name: string; arguments: string } } =>
+          'function' in tc && tc.function !== undefined
+        )
+        .map((tc) => ({
+          id: tc.id,
+          toolName: tc.function.name,
+          args: JSON.parse(tc.function.arguments),
+        }));
+    }
+
+    // Determine stop reason
+    const stopReason =
+      finishReason === 'tool_calls'
+        ? 'tool_use'
+        : finishReason === 'length'
+          ? 'length'
+          : finishReason === 'content_filter'
+            ? 'content_filter'
+            : 'end';
+
+    // For text responses, parsedValue is just the content
+    // For typed responses, the value comes from return tool calls (handled by tool-loop)
+    return { content, parsedValue: content, usage, toolCalls, stopReason };
+  } catch (error) {
+    if (error instanceof OpenAI.APIError) {
+      const isRetryable = error.status === 429 || (error.status ?? 0) >= 500;
+      throw new AIError(
+        `OpenAI API error (${error.status}): ${error.message}`,
+        error.status,
+        isRetryable
+      );
+    }
+    throw error;
+  }
+}

package/src/runtime/ai/retry.ts

@@ -0,0 +1,100 @@
+// Retry utilities for AI operations
+
+import { AIError, type RetryOptions } from './types';
+
+/**
+ * Check if an error is retryable (5xx, 429, or network error).
+ */
+export function isRetryableError(error: unknown): boolean {
+  if (error instanceof AIError) {
+    return error.isRetryable;
+  }
+
+  // Network errors
+  if (error instanceof TypeError && error.message.includes('fetch')) {
+    return true;
+  }
+
+  // Check for status codes
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    // Network-related errors
+    if (
+      message.includes('network') ||
+      message.includes('timeout') ||
+      message.includes('econnreset') ||
+      message.includes('econnrefused') ||
+      message.includes('socket')
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Calculate delay for exponential backoff with jitter.
+ * Formula: min(maxDelay, baseDelay * 2^attempt) * (0.5 + random(0.5))
+ */
+export function calculateDelay(
+  attempt: number,
+  baseDelayMs = 1000,
+  maxDelayMs = 30000
+): number {
+  const exponentialDelay = baseDelayMs * Math.pow(2, attempt);
+  const cappedDelay = Math.min(exponentialDelay, maxDelayMs);
+  // Add jitter: 50% to 100% of the delay
+  const jitter = 0.5 + Math.random() * 0.5;
+  return Math.floor(cappedDelay * jitter);
+}
+
+/**
+ * Sleep for a given number of milliseconds.
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Execute a function with retry logic.
+ * Retries on 5xx, 429, and network errors with exponential backoff.
+ */
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  options: RetryOptions
+): Promise<T> {
+  const { maxRetries, baseDelayMs = 1000, maxDelayMs = 30000 } = options;
+  let lastError: Error | null = null;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+
+      // Check if error is retryable and we have attempts left
+      if (!isRetryableError(error) || attempt >= maxRetries) {
+        throw lastError;
+      }
+
+      // Wait before retrying
+      const delay = calculateDelay(attempt, baseDelayMs, maxDelayMs);
+      await sleep(delay);
+    }
+  }
+
+  // This should never be reached, but TypeScript needs it
+  throw lastError ?? new Error('Retry failed');
+}
+
+/**
+ * Create an AIError from an HTTP response.
+ */
+export function createAIErrorFromResponse(
+  status: number,
+  message: string
+): AIError {
+  const isRetryable = status === 429 || (status >= 500 && status < 600);
+  return new AIError(message, status, isRetryable);
+}