@xortex/xcode 3.0.0

package/services/api/firstTokenDate.ts

@@ -0,0 +1,60 @@
+import axios from 'src/utils/axios.js'
+import { getOauthConfig } from '../../constants/oauth.js'
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js'
+import { getAuthHeaders } from '../../utils/http.js'
+import { logError } from '../../utils/log.js'
+import { getClaudeCodeUserAgent } from '../../utils/userAgent.js'
+
+/**
+ * Fetch the user's first Claude Code token date and store in config.
+ * This is called after successful login to cache when they started using Claude Code.
+ */
+export async function fetchAndStoreClaudeCodeFirstTokenDate(): Promise<void> {
+  try {
+    const config = getGlobalConfig()
+
+    if (config.claudeCodeFirstTokenDate !== undefined) {
+      return
+    }
+
+    const authHeaders = getAuthHeaders()
+    if (authHeaders.error) {
+      logError(new Error(`Failed to get auth headers: ${authHeaders.error}`))
+      return
+    }
+
+    const oauthConfig = getOauthConfig()
+    const url = `${oauthConfig.BASE_API_URL}/api/organization/claude_code_first_token_date`
+
+    const response = await axios.get(url, {
+      headers: {
+        ...authHeaders.headers,
+        'User-Agent': getClaudeCodeUserAgent(),
+      },
+      timeout: 10000,
+    })
+
+    const firstTokenDate = response.data?.first_token_date ?? null
+
+    // Validate the date if it's not null
+    if (firstTokenDate !== null) {
+      const dateTime = new Date(firstTokenDate).getTime()
+      if (isNaN(dateTime)) {
+        logError(
+          new Error(
+            `Received invalid first_token_date from API: ${firstTokenDate}`,
+          ),
+        )
+        // Don't save invalid dates
+        return
+      }
+    }
+
+    saveGlobalConfig(current => ({
+      ...current,
+      claudeCodeFirstTokenDate: firstTokenDate,
+    }))
+  } catch (error) {
+    logError(error)
+  }
+}

package/services/api/gemini.ts

@@ -0,0 +1,359 @@
+import { GoogleGenerativeAI, type GenerateContentStreamResult } from '@google/generative-ai';
+import type { AssistantMessage, Message, StreamEvent } from '../../types/message.js';
+import type { Tool } from '../../Tool.js';
+import type { SystemPrompt } from '../../utils/systemPromptType.js';
+import { convertToGeminiMessages, convertToGeminiTools } from './geminiAdapter.js';
+
+const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY || '');
+
+export interface QueryWithModelOptions {
+  tools?: Tool[];
+  // Other options from Claude...
+}
+
+export async function queryModelWithoutStreaming({
+  systemPrompt,
+  messages,
+  model = 'gemini-2.5-pro',
+  tools = [],
+  options = {} as any,
+}: {
+  systemPrompt: SystemPrompt;
+  messages: Message[];
+  model?: string;
+  tools?: Tool[];
+  options?: any;
+}): Promise<AssistantMessage> {
+  let geminiTools: any = tools.length > 0 ? [{ functionDeclarations: convertToGeminiTools(tools) }] : undefined;
+  
+  const extraSchemas = options.extraToolSchemas || [];
+  const hasWebSearch = extraSchemas.some((s: any) => s.type === 'web_search_20250305' || s.name === 'web_search');
+  
+  if (hasWebSearch) {
+    if (!geminiTools) geminiTools = [];
+    geminiTools.push({ googleSearch: {} });
+  }
+  
+  const generativeModel = genAI.getGenerativeModel({
+    model,
+    tools: geminiTools as any,
+    systemInstruction: {
+      role: 'system',
+      parts: [{ text: Array.isArray(systemPrompt) ? systemPrompt.join('\n') : systemPrompt as unknown as string }],
+    },
+  });
+
+  const geminiMessages = convertToGeminiMessages(messages);
+  const result = await generativeModel.generateContent({
+    contents: geminiMessages,
+  });
+
+  const response = result.response;
+  const parts = response.candidates?.[0]?.content?.parts || [];
+  
+  // Convert Gemini response back to Anthropic-style AssistantMessage
+  const content: any[] = [];
+  for (const part of parts) {
+    if (part.text) {
+      content.push({ type: 'text', text: part.text });
+    } else if (part.functionCall) {
+      content.push({
+        type: 'tool_use',
+        id: `call_${Math.random().toString(36).substring(7)}`,
+        name: part.functionCall.name,
+        input: part.functionCall.args,
+      });
+    }
+  }
+
+  return {
+    message: {
+      role: 'assistant',
+      content,
+    } as any,
+    uuid: 'uuid_not_used',
+  } as any;
+}
+
+export async function queryHaiku(options: any) {
+  return queryModelWithoutStreaming({ ...options, model: 'gemini-1.5-flash' });
+}
+
+export async function* queryWithModel({
+  systemPrompt,
+  userPrompt,
+  options,
+}: {
+  systemPrompt: SystemPrompt;
+  userPrompt: string;
+  signal: AbortSignal;
+  options: QueryWithModelOptions | any;
+}): AsyncGenerator<StreamEvent, AssistantMessage, void> {
+  const tools = options.tools || [];
+  // process.stderr.write(`[DBG] queryWithModel received ${tools.length} tools\n`);
+  // for (const t of tools) {
+  //   process.stderr.write(`[DBG] Tool: ${t.name} - ${typeof t.description}\n`);
+  // }
+  let geminiTools: any = tools.length > 0 ? [{ functionDeclarations: convertToGeminiTools(tools) }] : undefined;
+
+  const extraSchemas = options.extraToolSchemas || [];
+  const hasWebSearch = extraSchemas.some((s: any) => s.type === 'web_search_20250305' || s.name === 'web_search');
+  
+  if (hasWebSearch) {
+    if (!geminiTools) geminiTools = [];
+    geminiTools.push({ googleSearch: {} });
+  }
+
+  process.stderr.write(`[DBG Gemini] userPrompt: "${userPrompt.substring(0, 100)}..."\n`);
+
+  const generativeModel = genAI.getGenerativeModel({
+    model: 'gemini-2.5-pro',
+    tools: geminiTools as any,
+    systemInstruction: {
+      role: 'system',
+      parts: [{ text: Array.isArray(systemPrompt) ? systemPrompt.join('\n') : systemPrompt as unknown as string }],
+    },
+  });
+
+  const messages: Message[] = [{ role: 'user', content: userPrompt } as any];
+  process.stderr.write(`[DBG Gemini] messages: ${JSON.stringify(messages)}\n`);
+  
+  const geminiMessages = convertToGeminiMessages(messages);
+  process.stderr.write(`[DBG Gemini] geminiMessages: ${JSON.stringify(geminiMessages)}\n`);
+  
+  const result = await generativeModel.generateContentStream({
+    contents: convertToGeminiMessages(messages),
+  });
+
+  const content: any[] = [];
+  
+  process.stderr.write(`[DBG queryModelWithStreaming] starting to stream...\n`);
+  
+  for await (const chunk of result.stream) {
+    process.stderr.write(`[DBG queryModelWithStreaming] chunk: ${JSON.stringify(chunk)}\n`);
+    const parts = chunk.candidates?.[0]?.content?.parts || [];
+    for (const part of parts) {
+      if (part.text) {
+        process.stderr.write(`[DBG queryModelWithStreaming] yielding text: "${part.text.substring(0, 100)}"\n`);
+        yield { type: 'text', text: part.text } as any;
+        // Append text to last block if it's text
+        if (content.length > 0 && content[content.length - 1].type === 'text') {
+          content[content.length - 1].text += part.text;
+        } else {
+          content.push({ type: 'text', text: part.text });
+        }
+      } else if (part.functionCall) {
+        const toolUse = {
+          type: 'tool_use',
+          id: `call_${Math.random().toString(36).substring(7)}`,
+          name: part.functionCall.name,
+          input: part.functionCall.args,
+        };
+        yield toolUse as any;
+        content.push(toolUse);
+      }
+    }
+  }
+  
+  process.stderr.write(`[DBG queryModelWithStreaming] stream done, final content: ${JSON.stringify(content)}\n`);
+
+  return {
+    message: {
+      role: 'assistant',
+      content,
+    } as any,
+    uuid: 'uuid_not_used',
+  } as any;
+}
+
+export function getCacheControl(options: any = {}) {
+  return { type: 'ephemeral', ttl: '1h', scope: options.scope };
+}
+
+export function getAPIMetadata() {
+  return { user_id: 'gemini_user' };
+}
+
+export async function verifyApiKey(apiKey: string, isNonInteractive: boolean) {
+  if (isNonInteractive) return true;
+  if (!apiKey || apiKey.trim() === '') return false;
+  try {
+    const model = genAI.getGenerativeModel({ model: 'gemini-1.5-flash' });
+    await model.generateContent("hello");
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+export function updateUsage(usage: any, partUsage: any) {
+  if (!partUsage) return { ...usage };
+  return {
+    input_tokens: (usage?.input_tokens || 0) + (partUsage?.input_tokens || 0),
+    output_tokens: (usage?.output_tokens || 0) + (partUsage?.output_tokens || 0),
+    cache_creation_input_tokens: 0,
+    cache_read_input_tokens: 0,
+    server_tool_use: usage?.server_tool_use || {},
+    service_tier: usage?.service_tier,
+    cache_creation: usage?.cache_creation || {},
+    inference_geo: usage?.inference_geo,
+    iterations: usage?.iterations,
+    speed: usage?.speed,
+  };
+}
+
+export function accumulateUsage(totalUsage: any, messageUsage: any) {
+  return {
+    input_tokens: (totalUsage?.input_tokens || 0) + (messageUsage?.input_tokens || 0),
+    output_tokens: (totalUsage?.output_tokens || 0) + (messageUsage?.output_tokens || 0),
+    cache_creation_input_tokens: 0,
+    cache_read_input_tokens: 0,
+    server_tool_use: totalUsage?.server_tool_use || {},
+    service_tier: totalUsage?.service_tier,
+    cache_creation: totalUsage?.cache_creation || {},
+    inference_geo: totalUsage?.inference_geo,
+    iterations: totalUsage?.iterations,
+    speed: totalUsage?.speed,
+  };
+}
+
+export async function* queryModelWithStreaming(options: any) {
+  const messages = options.messages || options;
+  const systemPrompt = options.systemPrompt;
+  
+  const tools = options.tools || [];
+  // process.stderr.write(`[DBG] queryModelWithStreaming received ${tools.length} tools\n`);
+  // for (const t of tools) {
+  //   process.stderr.write(`[DBG] Tool: ${t.name} - ${typeof t.description}\n`);
+  // }
+  let geminiTools: any = tools.length > 0 ? [{ functionDeclarations: convertToGeminiTools(tools) }] : undefined;
+
+  // Check if web search schema is explicitly provided in extraToolSchemas
+  const extraSchemas = options.options?.extraToolSchemas || [];
+  const hasWebSearch = extraSchemas.some((s: any) => s.type === 'web_search_20250305' || s.name === 'web_search');
+  
+  if (hasWebSearch) {
+    if (!geminiTools) geminiTools = [];
+    geminiTools.push({ googleSearch: {} });
+  }
+
+  const systemText = Array.isArray(systemPrompt) ? systemPrompt.join('\n') : (systemPrompt as string || '');
+
+  const generativeModel = genAI.getGenerativeModel({
+    model: 'gemini-2.5-pro',
+    tools: geminiTools as any,
+    systemInstruction: {
+      role: 'system',
+      parts: [{ text: systemText }],
+    },
+  });
+
+  const geminiMsgs = convertToGeminiMessages(messages);
+  
+  let result;
+  try {
+    result = await generativeModel.generateContentStream({
+      contents: geminiMsgs,
+    });
+  } catch (err: any) {
+    throw err;
+  }
+
+  const content: any[] = [];
+  
+  try {
+    if (!result.stream) {
+      // Try getting response directly instead of stream
+      const parts = result.response?.candidates?.[0]?.content?.parts || [];
+      for (const part of parts) {
+        if (part.text) {
+          const assistantMessage = {
+            type: 'assistant' as const,
+            message: {
+              role: 'assistant' as const,
+              content: [{ type: 'text' as const, text: part.text }],
+            },
+            uuid: crypto.randomUUID(),
+          };
+          yield assistantMessage;
+          content.push({ type: 'text', text: part.text });
+        }
+      }
+    } else {
+      // Accumulate text chunks and yield as a single message at the end
+      let allTextParts: string[] = [];
+      
+      for await (const chunk of result.stream) {
+        const parts = chunk.candidates?.[0]?.content?.parts || [];
+        
+        for (const part of parts) {
+          if (part.text) {
+            // Accumulate text
+            allTextParts.push(part.text);
+          } else if (part.functionCall) {
+            // When we get a function call, first yield any accumulated text
+            if (allTextParts.length > 0) {
+              const combinedText = allTextParts.join('');
+              const assistantMessage = {
+                type: 'assistant' as const,
+                message: {
+                  role: 'assistant' as const,
+                  content: [{ type: 'text' as const, text: combinedText }],
+                },
+                uuid: crypto.randomUUID(),
+              };
+              yield assistantMessage;
+              content.push({ type: 'text', text: combinedText });
+              allTextParts = [];
+            }
+            
+            // Then yield the tool use
+            const toolUseId = `call_${Math.random().toString(36).substring(7)}`;
+            const toolUse = {
+              type: 'tool_use' as const,
+              id: toolUseId,
+              name: part.functionCall.name,
+              input: part.functionCall.args || {},
+            };
+            
+            const toolMessage = {
+              type: 'assistant' as const,
+              message: {
+                role: 'assistant' as const,
+                content: [toolUse],
+              },
+              uuid: crypto.randomUUID(),
+            };
+            yield toolMessage;
+            content.push(toolUse);
+          }
+        }
+      }
+      
+      // Yield any remaining accumulated text at the end
+      if (allTextParts.length > 0) {
+        const combinedText = allTextParts.join('');
+        const assistantMessage = {
+          type: 'assistant' as const,
+          message: {
+            role: 'assistant' as const,
+            content: [{ type: 'text' as const, text: combinedText }],
+          },
+          uuid: crypto.randomUUID(),
+        };
+        yield assistantMessage;
+        content.push({ type: 'text', text: combinedText });
+      }
+    }
+  } catch (streamErr: any) {
+    throw streamErr;
+  }
+  
+  return {
+    message: {
+      role: 'assistant',
+      content,
+    } as any,
+    uuid: 'uuid_not_used',
+  } as any;
+}

package/services/api/geminiAdapter.ts

@@ -0,0 +1,123 @@
+import type {
+  Content,
+  FunctionDeclaration,
+  Part,
+} from '@google/generative-ai';
+import type { Tool } from '../../Tool.js';
+import type { Message } from '../../types/message.js';
+import { zodToJsonSchema } from '../../utils/zodToJsonSchema.js';
+
+export function convertToGeminiTools(tools: Tool[]): FunctionDeclaration[] {
+  return tools.map((tool) => {
+    const desc = typeof tool.description === 'string'
+      ? tool.description
+      : (tool.searchHint || (tool.userFacingName ? tool.userFacingName({}) : `A tool for ${tool.name}`));
+    
+    const jsonSchema: any = 'inputJSONSchema' in tool && tool.inputJSONSchema
+      ? tool.inputJSONSchema
+      : zodToJsonSchema(tool.inputSchema);
+      
+    // Strip $schema if it exists, as Gemini might reject it
+    const { $schema, ...parameters } = jsonSchema || {};
+    
+    // Gemini also rejects additionalProperties in objects and propertyNames
+    // We need to recursively strip these out
+    const cleanSchema = (schema: any): any => {
+      if (!schema || typeof schema !== 'object') return schema;
+      
+      if (Array.isArray(schema)) {
+        return schema.map(cleanSchema);
+      }
+      
+      const cleaned: any = {};
+      for (const [key, value] of Object.entries(schema)) {
+        if (key === 'additionalProperties' || key === 'propertyNames' || key === 'exclusiveMinimum') {
+          continue;
+        }
+        if (key === 'const') {
+           // Gemini does not support const, map it to enum
+           cleaned['enum'] = [value];
+           continue;
+        }
+        cleaned[key] = cleanSchema(value);
+      }
+      return cleaned;
+    };
+    
+    return {
+      name: tool.name,
+      description: desc,
+      parameters: cleanSchema(parameters) as any,
+    };
+  });
+}
+
+export function convertToGeminiMessages(messages: Message[]): Content[] {
+  const result: Content[] = [];
+  
+  for (let idx = 0; idx < messages.length; idx++) {
+    const msg = messages[idx] as any;
+    
+    // Handle wrapped message format: {type, message: {role, content}, ...}
+    // or direct format: {role, content, ...}
+    const innerMsg = msg.message || msg;
+    const role = innerMsg.role === 'assistant' ? 'model' : 'user';
+    const parts: Part[] = [];
+    
+    const content = innerMsg.content ?? msg.content;
+    
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block.type === 'text') {
+          parts.push({ text: block.text });
+        } else if (block.type === 'tool_use') {
+          const toolName = block.name || 'unknown_tool';
+          // Gemini expects args as an object, not a JSON string
+          let toolArgs: any = block.input;
+          // If input is a string, try to parse it
+          if (typeof block.input === 'string') {
+            try {
+              toolArgs = JSON.parse(block.input);
+            } catch {
+              toolArgs = { value: block.input };
+            }
+          }
+          parts.push({
+            functionCall: {
+              name: toolName,
+              args: toolArgs || {},
+            },
+          });
+        } else if (block.type === 'tool_result') {
+          // Tool result needs name and response - use id if name is missing
+          const toolName = block.name || block.id || 'unknown_tool';
+          const toolContent = typeof block.content === 'string' ? block.content : JSON.stringify(block.content || '');
+          parts.push({
+            functionResponse: {
+              name: toolName,
+              response: { result: toolContent },
+            },
+          });
+        }
+      }
+    } else if (typeof content === 'string') {
+      if (content.trim()) {
+        parts.push({ text: content });
+      }
+    }
+
+    // Only add messages that have content and have valid parts
+    // Skip messages that would result in empty parts (which causes Gemini API errors)
+    const validParts = parts.filter(p => 
+      (p as any).text !== undefined || 
+      (p as any).functionCall !== undefined || 
+      (p as any).functionResponse !== undefined
+    );
+    
+    if (validParts.length > 0) {
+      result.push({ role, parts: validParts });
+    }
+  }
+  
+  return result;
+}