free-antigravity-cli 1.0.0

package/src/proxy/shared.ts

@@ -0,0 +1,102 @@
+/**
+ * Shared state module for proxy orchestration.
+ * Extracted from proxy.js to decouple translators from main orchestration.
+ */
+
+// ─── Types ────────────────────────────────────────────────────────────────
+
+export interface StreamContext {
+  accumulatedText: string;
+  accumulatedReasoning: string;
+  toolCalls: Record<number, { id: string; name: string; arguments: string }>;
+}
+
+export interface StateTimestamps {
+  streamCtx: Map<string, number>;
+  toolCallIds: Map<string, number>;
+  translatedCalls: Map<string, number>;
+  reasoning: Map<string, number>;
+}
+
+export interface TranslatedCallInfo {
+  originalName: string;
+  translatedName: string;
+  cmd: string;
+  cwd: string;
+}
+
+// ─── State ────────────────────────────────────────────────────────────────
+
+/** modelName → { "functionName": "original_tool_call_id" } */
+export const modelToolCallIds = new Map<string, Record<string, string>>();
+
+/** modelName → preserved reasoning_content from previous turn */
+export const modelReasoningContent = new Map<string, string>();
+
+/** streamId → { accumulatedText, accumulatedReasoning, toolCalls } */
+export const activeStreamContexts = new Map<string, StreamContext>();
+
+/** toolCallId → { originalName, translatedName, cmd, cwd } */
+export const translatedToolCalls = new Map<string, TranslatedCallInfo>();
+
+/** State entry timestamps for periodic cleanup */
+export const stateTimestamps: StateTimestamps = {
+  streamCtx: new Map(),
+  toolCallIds: new Map(),
+  translatedCalls: new Map(),
+  reasoning: new Map(),
+};
+
+// ─── Helpers ──────────────────────────────────────────────────────────────
+
+export function touchStateTimestamp(map: Map<string, number>, key: string): void {
+  map.set(key, Date.now());
+}
+
+// ─── Periodic Cleanup (managed lifecycle) ─────────────────────────────────
+
+let cleanupInterval: ReturnType<typeof setInterval> | null = null;
+
+export function startCleanupInterval(): void {
+  if (cleanupInterval) return; // already running
+  cleanupInterval = setInterval(() => {
+    const now = Date.now();
+    const STREAM_TTL = 600_000; // 10 minutes for active stream contexts
+    const TOOL_TTL = 1_800_000; // 30 minutes for tool call IDs & reasoning
+
+    for (const [key, ts] of stateTimestamps.streamCtx) {
+      if (now - ts > STREAM_TTL) {
+        activeStreamContexts.delete(key);
+        stateTimestamps.streamCtx.delete(key);
+      }
+    }
+    for (const [key, ts] of stateTimestamps.toolCallIds) {
+      if (now - ts > TOOL_TTL) {
+        modelToolCallIds.delete(key);
+        stateTimestamps.toolCallIds.delete(key);
+      }
+    }
+    for (const [key, ts] of stateTimestamps.translatedCalls) {
+      if (now - ts > TOOL_TTL) {
+        translatedToolCalls.delete(key);
+        stateTimestamps.translatedCalls.delete(key);
+      }
+    }
+    for (const [key, ts] of stateTimestamps.reasoning) {
+      if (now - ts > TOOL_TTL) {
+        modelReasoningContent.delete(key);
+        stateTimestamps.reasoning.delete(key);
+      }
+    }
+  }, 300_000);
+}
+
+export function stopCleanupInterval(): void {
+  if (cleanupInterval) {
+    clearInterval(cleanupInterval);
+    cleanupInterval = null;
+  }
+}
+
+// Auto-start for backward compatibility (will be replaced by proxy.ts lifecycle)
+startCleanupInterval();

package/src/proxy/translators/anthropic.ts

@@ -0,0 +1,420 @@
+/**
+ * Anthropic provider translator.
+ * Handles Gemini ↔ Anthropic request/response mapping and streaming SSE events.
+ */
+
+import { log } from '../../logger';
+import {
+  fixParamTypes,
+  translateToolCallToNative,
+  formatTranslatedResponse,
+  normalizeToolArgs,
+  ToolCallArgs,
+} from './utils';
+import {
+  modelToolCallIds,
+  activeStreamContexts,
+  translatedToolCalls,
+  stateTimestamps,
+  touchStateTimestamp,
+  StreamContext,
+} from '../shared';
+import { detectModelCapabilitiesByName } from '../modelUtils';
+
+// ─── Types ────────────────────────────────────────────────────────────────
+
+interface GeminiTool {
+  functionDeclarations?: GeminiFunctionDeclaration[];
+}
+
+interface GeminiFunctionDeclaration {
+  name: string;
+  description?: string;
+  parameters?: GeminiParameters;
+}
+
+interface GeminiParameters {
+  type: string;
+  properties?: Record<string, unknown>;
+}
+
+interface AnthropicTool {
+  name: string;
+  description: string;
+  input_schema: Record<string, unknown>;
+}
+
+interface GeminiContent {
+  role?: string;
+  parts?: GeminiPart[];
+}
+
+interface GeminiPart {
+  text?: string;
+  thought?: boolean;
+  functionCall?: GeminiFunctionCall;
+  functionResponse?: GeminiFunctionResponse;
+}
+
+interface GeminiFunctionCall {
+  name: string;
+  args: Record<string, unknown>;
+  id?: string;
+}
+
+interface GeminiFunctionResponse {
+  name: string;
+  response: unknown;
+  id?: string;
+}
+
+interface GeminiRequestBody {
+  systemInstruction?: { parts: GeminiPart[] };
+  contents?: GeminiContent[];
+  tools?: GeminiTool[];
+  generationConfig?: {
+    temperature?: number;
+    maxOutputTokens?: number;
+  };
+}
+
+interface AnthropicContentBlock {
+  type: 'text' | 'tool_use' | 'tool_result' | 'thinking';
+  text?: string;
+  thinking?: string;
+  id?: string;
+  name?: string;
+  input?: Record<string, unknown>;
+  tool_use_id?: string;
+  content?: string | AnthropicContentBlock[];
+}
+
+type AnthropicMessageRole = 'user' | 'assistant';
+
+interface AnthropicMessage {
+  role: AnthropicMessageRole;
+  content: string | AnthropicContentBlock[];
+}
+
+interface AnthropicRequestBody {
+  model: string;
+  messages: AnthropicMessage[];
+  system?: string;
+  max_tokens: number;
+  temperature?: number;
+  tools?: AnthropicTool[];
+}
+
+interface AnthropicResponse {
+  content?: AnthropicContentBlock[];
+  usage?: {
+    input_tokens: number;
+    output_tokens: number;
+  };
+  stop_reason?: string;
+  type?: string;
+  message?: { id: string };
+  index?: number;
+  content_block?: AnthropicContentBlock;
+  delta?: {
+    type?: string;
+    text?: string;
+    thinking?: string;
+    partial_json?: string;
+    stop_reason?: string;
+  };
+}
+
+interface GeminiGenerateContentResponse {
+  candidates: GeminiCandidate[];
+  usageMetadata?: GeminiUsageMetadata;
+}
+
+interface GeminiCandidate {
+  content: {
+    parts: GeminiPart[];
+    role: string;
+  };
+  finishReason: string;
+  index: number;
+}
+
+interface GeminiUsageMetadata {
+  promptTokenCount: number;
+  candidatesTokenCount: number;
+  totalTokenCount: number;
+}
+
+// ─── REQUEST: Gemini → Anthropic ──────────────────────────────────────────
+
+function mapGeminiToolsToAnthropic(geminiTools: GeminiTool[]): AnthropicTool[] {
+  if (!geminiTools || !Array.isArray(geminiTools)) return [];
+  const anthropicTools: AnthropicTool[] = [];
+  for (const toolGroup of geminiTools) {
+    if (toolGroup.functionDeclarations && Array.isArray(toolGroup.functionDeclarations)) {
+      for (const func of toolGroup.functionDeclarations) {
+        const params = func.parameters
+          ? (JSON.parse(JSON.stringify(func.parameters)) as Record<string, unknown>)
+          : { type: 'OBJECT', properties: {} };
+        if (params.type && typeof params.type === 'string') {
+          (params as Record<string, string>).type = (params.type as string).toLowerCase();
+        }
+        if (params.properties) {
+          fixParamTypes(params.properties as Record<string, unknown>);
+        }
+        anthropicTools.push({
+          name: func.name,
+          description: func.description || '',
+          input_schema: params,
+        });
+      }
+    }
+  }
+  return anthropicTools;
+}
+
+export function mapGeminiToAnthropic(geminiBody: GeminiRequestBody, modelName: string): AnthropicRequestBody {
+  const messages: AnthropicMessage[] = [];
+  let system: string | undefined = undefined;
+
+  if (geminiBody.systemInstruction && geminiBody.systemInstruction.parts) {
+    system = geminiBody.systemInstruction.parts.map((p) => p.text || '').join('');
+  }
+
+  if (geminiBody.contents) {
+    for (const item of geminiBody.contents) {
+      if (item.parts) {
+        const hasFunctionCall = item.parts.some((p) => p.functionCall);
+        const hasFunctionResponse = item.parts.some((p) => p.functionResponse);
+
+        if (hasFunctionCall && item.role === 'model') {
+          const contentBlocks: AnthropicContentBlock[] = [];
+          for (const p of item.parts) {
+            if (p.text) contentBlocks.push({ type: 'text', text: p.text });
+            if (p.functionCall) {
+              const callId = p.functionCall.id || 'call_' + Math.random().toString(36).slice(2, 10);
+              let originalName = p.functionCall.name;
+              let originalArgs = p.functionCall.args;
+              const translatedInfo = translatedToolCalls.get(callId);
+              if (translatedInfo) {
+                originalName = translatedInfo.originalName;
+                originalArgs = { CommandLine: translatedInfo.cmd, Cwd: translatedInfo.cwd };
+              }
+              contentBlocks.push({
+                type: 'tool_use',
+                id: callId,
+                name: originalName,
+                input:
+                  typeof originalArgs === 'string'
+                    ? (JSON.parse(originalArgs) as Record<string, unknown>)
+                    : (originalArgs as Record<string, unknown>),
+              });
+            }
+          }
+          messages.push({ role: 'assistant', content: contentBlocks });
+        } else if (hasFunctionResponse) {
+          const contentBlocks: AnthropicContentBlock[] = [];
+          for (const p of item.parts) {
+            if (p.functionResponse) {
+              const funcName = p.functionResponse.name || '';
+              const modelTCIds = modelToolCallIds.get(modelName) || {};
+              const toolCallId = p.functionResponse.id || modelTCIds[funcName] || 'call_' + funcName;
+              const responseData = p.functionResponse.response;
+              let contentStr = '';
+              const translatedInfo = translatedToolCalls.get(toolCallId);
+              if (translatedInfo) {
+                contentStr = formatTranslatedResponse(translatedInfo, responseData);
+              } else {
+                contentStr = typeof responseData === 'string' ? responseData : JSON.stringify(responseData || {});
+              }
+              contentBlocks.push({
+                type: 'tool_result',
+                tool_use_id: toolCallId,
+                content: contentStr,
+              });
+            }
+          }
+          messages.push({ role: 'user', content: contentBlocks });
+        } else {
+          const roleStr = item.role === 'model' ? 'assistant' : item.role || 'user';
+          let content = '';
+          if (item.parts) content = item.parts.map((p) => p.text || '').join('');
+          if (roleStr === 'system') {
+            system = (system || '') + '\n' + content;
+          } else {
+            messages.push({ role: roleStr as AnthropicMessageRole, content });
+          }
+        }
+      }
+    }
+  }
+
+  const result: AnthropicRequestBody = {
+    model: modelName,
+    messages,
+    system,
+    max_tokens: geminiBody.generationConfig?.maxOutputTokens ?? 16000,
+  };
+
+  // Claude thinking models don't support temperature (centralized detection)
+  const { isThinkingModel } = detectModelCapabilitiesByName(modelName);
+  if (!isThinkingModel) {
+    const temp = geminiBody.generationConfig?.temperature;
+    if (temp !== undefined && temp !== null) result.temperature = temp;
+  }
+
+  if (geminiBody.tools && Array.isArray(geminiBody.tools)) {
+    const anthTools = mapGeminiToolsToAnthropic(geminiBody.tools);
+    if (anthTools.length > 0) result.tools = anthTools;
+  }
+
+  return result;
+}
+
+// ─── RESPONSE: Anthropic → Gemini ─────────────────────────────────────────
+
+export function mapAnthropicToGemini(anthRes: AnthropicResponse, modelName: string): GeminiGenerateContentResponse {
+  const contentBlocks = anthRes.content || [];
+  const parts: GeminiPart[] = [];
+  const functionCalls: GeminiPart[] = [];
+
+  for (const block of contentBlocks) {
+    if (block.type === 'text' && block.text) {
+      parts.push({ text: block.text });
+    } else if (block.type === 'thinking' && block.thinking) {
+      parts.push({ text: block.thinking, thought: true });
+    } else if (block.type === 'tool_use') {
+      const modelTCIds = modelToolCallIds.get(modelName) || {};
+      modelTCIds[block.name || ''] = block.id || '';
+      modelToolCallIds.set(modelName, modelTCIds);
+      touchStateTimestamp(stateTimestamps.toolCallIds, modelName);
+
+      const normalizedInput = normalizeToolArgs(block.name || '', block.input || {});
+      const translated = translateToolCallToNative(block.name || '', normalizedInput);
+      if (translated.name !== block.name) {
+        translated.args = normalizeToolArgs(translated.name, translated.args) as Record<string, unknown>;
+        translatedToolCalls.set(block.id || '', {
+          originalName: block.name || '',
+          translatedName: translated.name,
+          cmd: (normalizedInput.CommandLine as string) || '',
+          cwd: (normalizedInput.Cwd as string) || '',
+        });
+        touchStateTimestamp(stateTimestamps.translatedCalls, block.id || '');
+      }
+
+      functionCalls.push({
+        functionCall: { name: translated.name, args: translated.args as Record<string, unknown>, id: block.id },
+      });
+    }
+  }
+
+  if (functionCalls.length > 0) {
+    return {
+      candidates: [
+        { content: { parts: [...parts, ...functionCalls], role: 'model' }, finishReason: 'TOOL_CALL', index: 0 },
+      ],
+      usageMetadata: {
+        promptTokenCount: anthRes.usage?.input_tokens || 0,
+        candidatesTokenCount: anthRes.usage?.output_tokens || 0,
+        totalTokenCount: (anthRes.usage?.input_tokens || 0) + (anthRes.usage?.output_tokens || 0),
+      },
+    };
+  }
+
+  const finishReason =
+    anthRes.stop_reason === 'end_turn' ? 'STOP' : anthRes.stop_reason === 'max_tokens' ? 'MAX_TOKENS' : 'OTHER';
+
+  return {
+    candidates: [{ content: { parts, role: 'model' }, finishReason, index: 0 }],
+    usageMetadata: {
+      promptTokenCount: anthRes.usage?.input_tokens || 0,
+      candidatesTokenCount: anthRes.usage?.output_tokens || 0,
+      totalTokenCount: (anthRes.usage?.input_tokens || 0) + (anthRes.usage?.output_tokens || 0),
+    },
+  };
+}
+
+// ─── STREAM CHUNK: Anthropic SSE → Gemini ─────────────────────────────────
+
+export function mapAnthropicChunkToGemini(chunk: AnthropicResponse, modelName: string): GeminiCandidate | null {
+  const type = chunk.type;
+  const streamId = chunk.message?.id || 'anthropic_stream';
+
+  if (!activeStreamContexts.has(streamId)) {
+    activeStreamContexts.set(streamId, { accumulatedText: '', accumulatedReasoning: '', toolCalls: {} });
+    touchStateTimestamp(stateTimestamps.streamCtx, streamId);
+  }
+  const context = activeStreamContexts.get(streamId)!;
+
+  if (type === 'content_block_start') {
+    const block = chunk.content_block;
+    const idx = chunk.index ?? 0;
+    if (block?.type === 'tool_use') {
+      context.toolCalls[idx] = { id: block.id || '', name: block.name || '', arguments: '' };
+    }
+  }
+
+  if (type === 'content_block_delta') {
+    const delta = chunk.delta;
+    const idx = chunk.index ?? 0;
+    if (delta?.type === 'text_delta') {
+      const text = delta.text || '';
+      context.accumulatedText += text;
+      return { content: { parts: [{ text }], role: 'model' }, finishReason: 'OTHER', index: 0 };
+    } else if (delta?.type === 'thinking_delta') {
+      const thinkingText = delta.thinking || '';
+      context.accumulatedReasoning += thinkingText;
+      return {
+        content: { parts: [{ text: thinkingText, thought: true }], role: 'model' },
+        finishReason: 'OTHER',
+        index: 0,
+      };
+    } else if (delta?.type === 'input_delta') {
+      if (context.toolCalls[idx]) {
+        context.toolCalls[idx].arguments += delta.partial_json || '';
+      }
+    }
+  }
+
+  if (type === 'message_delta') {
+    const delta = chunk.delta;
+    if (delta?.stop_reason === 'tool_use') {
+      const parts: GeminiPart[] = Object.values(context.toolCalls).map((tc) => {
+        let args: ToolCallArgs = {};
+        try {
+          args = JSON.parse(tc.arguments);
+        } catch (e) {
+          log.debug('[Anthropic] Stream tool args parse fallback:', (e as Error).message);
+          args = {};
+        }
+        args = normalizeToolArgs(tc.name, args) as ToolCallArgs;
+        const modelTCIds = modelToolCallIds.get(modelName) || {};
+        modelTCIds[tc.name] = tc.id;
+        modelToolCallIds.set(modelName, modelTCIds);
+        touchStateTimestamp(stateTimestamps.toolCallIds, modelName);
+        const translated = translateToolCallToNative(tc.name, args);
+        if (translated.name !== tc.name) {
+          translatedToolCalls.set(tc.id, {
+            originalName: tc.name,
+            translatedName: translated.name,
+            cmd: args.CommandLine || '',
+            cwd: args.Cwd || '',
+          });
+          touchStateTimestamp(stateTimestamps.translatedCalls, tc.id);
+        }
+        return { functionCall: { name: translated.name, args: translated.args as Record<string, unknown>, id: tc.id } };
+      });
+      activeStreamContexts.delete(streamId);
+      return { content: { parts, role: 'model' }, finishReason: 'TOOL_CALL', index: 0 };
+    }
+  }
+
+  if (type === 'message_stop') {
+    activeStreamContexts.delete(streamId);
+    return { content: { parts: [], role: 'model' }, finishReason: 'STOP', index: 0 };
+  }
+
+  return null;
+}
+
+export { mapGeminiToolsToAnthropic };

package/src/proxy/translators/google.ts

@@ -0,0 +1,162 @@
+/**
+ * Google AI Studio Translator.
+ *
+ * Google AI Studio speaks Gemini format natively, so request/response
+ * translation is a passthrough. The main addition is SSE streaming chunk
+ * parsing and proper endpoint URL handling.
+ */
+
+import { log } from '../../logger';
+
+// ─── Types ────────────────────────────────────────────────────────────────
+
+interface GeminiPart {
+  text?: string;
+  functionCall?: { name: string; args: Record<string, unknown> };
+  functionResponse?: { name: string; response: Record<string, unknown> };
+  thought?: boolean;
+  inlineData?: { mimeType: string; data: string };
+  fileData?: { mimeType: string; fileUri: string };
+}
+
+interface GeminiContent {
+  parts?: GeminiPart[];
+  role?: string;
+}
+
+interface GeminiCandidate {
+  content?: GeminiContent;
+  finishReason?: string;
+  index?: number;
+  safetyRatings?: unknown[];
+}
+
+interface GeminiStreamChunk {
+  candidates?: GeminiCandidate[];
+  usageMetadata?: unknown;
+  modelVersion?: string;
+}
+
+interface GeminiRequestBody {
+  model?: string;
+  modelId?: string;
+  contents?: GeminiContent[];
+  systemInstruction?: { parts: { text?: string }[] };
+  tools?: unknown[];
+  generationConfig?: {
+    temperature?: number;
+    maxOutputTokens?: number;
+    topP?: number;
+    topK?: number;
+    stopSequences?: string[];
+  };
+}
+
+// ─── Request Translation (Passthrough) ────────────────────────────────────
+
+/**
+ * Google AI Studio uses the same Gemini format — just pass through.
+ * The caller handles URL routing (streamGenerateContent vs generateContent).
+ */
+export function mapGeminiToGoogle(geminiBody: GeminiRequestBody, modelName: string): GeminiRequestBody {
+  // Ensure the external model name is set
+  const body: GeminiRequestBody = { ...geminiBody };
+  if (modelName && !body.model) {
+    body.model = modelName;
+  }
+  return body;
+}
+
+// ─── Response Translation (Passthrough) ───────────────────────────────────
+
+/**
+ * Google AI Studio returns Gemini-format responses directly.
+ * Just pass through — the proxy wraps it in the Cloud Code envelope.
+ */
+export function mapGoogleToGemini(googleRes: unknown, _modelName: string): unknown {
+  // Google AI Studio response is already in Gemini format
+  // Wrapped by caller in { response, traceId, metadata }
+  return googleRes;
+}
+
+// ─── Streaming Chunk Translation ──────────────────────────────────────────
+
+/**
+ * Parse a Google AI Studio SSE streaming chunk into a Gemini candidate.
+ *
+ * Google AI Studio streams JSON chunks like:
+ *   {"candidates":[{"content":{"parts":[{"text":"Hello"}],"role":"model"},...}]}
+ *
+ * Each chunk contains complete candidate objects (not deltas).
+ */
+export function mapGoogleChunkToGemini(chunk: unknown, _modelName: string): GeminiCandidate | null {
+  if (!chunk || typeof chunk !== 'object') return null;
+
+  const data = chunk as GeminiStreamChunk;
+
+  // Extract first candidate
+  if (!data.candidates || data.candidates.length === 0) return null;
+
+  const candidate = data.candidates[0];
+
+  // Check if there's actual content to emit
+  const parts = candidate.content?.parts;
+  if (!parts || parts.length === 0) {
+    // Might be a final chunk with just finishReason
+    if (candidate.finishReason) {
+      return {
+        content: { parts: [], role: 'model' },
+        finishReason: candidate.finishReason,
+        index: candidate.index ?? 0,
+      };
+    }
+    return null;
+  }
+
+  return {
+    content: candidate.content,
+    finishReason: candidate.finishReason || 'OTHER',
+    index: candidate.index ?? 0,
+    safetyRatings: candidate.safetyRatings,
+  };
+}
+
+// ─── URL Helpers ──────────────────────────────────────────────────────────
+
+/**
+ * Constructs the correct Google AI Studio endpoint URL based on streaming mode.
+ *
+ * Google AI Studio uses different endpoints:
+ *   - Non-streaming: :generateContent
+ *   - Streaming:     :streamGenerateContent
+ *
+ * If the user's URL already contains one of these endpoints, it's kept as-is.
+ */
+export function getGoogleApiUrl(baseUrl: string, modelName: string, isStream: boolean): string {
+  let url = baseUrl;
+
+  // If the URL doesn't already specify a method, append one
+  if (!url.includes(':generateContent') && !url.includes(':streamGenerateContent')) {
+    // Strip trailing slash if present
+    url = url.replace(/\/$/, '');
+
+    // Check if the URL ends with the model path (e.g. /models/gemini-1.5-pro)
+    const modelPathPattern = /\/models\/([^\/]+)$/;
+    const modelMatch = modelPathPattern.exec(url);
+
+    if (modelMatch) {
+      // URL like .../v1beta/models/gemini-1.5-pro → append :method
+      const method = isStream ? ':streamGenerateContent' : ':generateContent';
+      url += method;
+    } else if (modelName) {
+      // Append full path with model name
+      const method = isStream ? ':streamGenerateContent' : ':generateContent';
+      url += `models/${modelName}${method}`;
+    } else {
+      // Fallback: assume the URL is already complete
+      log.warn('[GoogleTranslator] Could not determine model name for URL construction');
+    }
+  }
+
+  return url;
+}