cowork-os 0.3.21 → 0.3.23

package/src/electron/agent/llm/github-copilot-provider.ts

@@ -0,0 +1,117 @@
+import { LLMProvider, LLMProviderConfig, LLMRequest, LLMResponse } from './types';
+import { OpenAICompatibleProvider } from './openai-compatible-provider';
+
+const COPILOT_TOKEN_URL = 'https://api.github.com/copilot_internal/v2/token';
+const DEFAULT_COPILOT_BASE_URL = 'https://api.individual.githubcopilot.com';
+
+type CopilotTokenCache = {
+  token: string;
+  expiresAt: number;
+  baseUrl: string;
+};
+
+function isTokenValid(cache: CopilotTokenCache, now = Date.now()): boolean {
+  return cache.expiresAt - now > 5 * 60 * 1000;
+}
+
+function parseCopilotTokenResponse(payload: any): { token: string; expiresAt: number } {
+  if (!payload || typeof payload !== 'object') {
+    throw new Error('Unexpected response from Copilot token endpoint');
+  }
+  const token = payload.token;
+  const expiresAt = payload.expires_at;
+  if (typeof token !== 'string' || !token.trim()) {
+    throw new Error('Copilot token response missing token');
+  }
+
+  if (typeof expiresAt === 'number' && Number.isFinite(expiresAt)) {
+    return { token, expiresAt: expiresAt > 10_000_000_000 ? expiresAt : expiresAt * 1000 };
+  }
+
+  if (typeof expiresAt === 'string' && expiresAt.trim()) {
+    const parsed = Number.parseInt(expiresAt, 10);
+    if (!Number.isFinite(parsed)) {
+      throw new Error('Copilot token response has invalid expires_at');
+    }
+    return { token, expiresAt: parsed > 10_000_000_000 ? parsed : parsed * 1000 };
+  }
+
+  throw new Error('Copilot token response missing expires_at');
+}
+
+function deriveCopilotBaseUrl(token: string): string {
+  const match = token.match(/(?:^|;)\s*proxy-ep=([^;\s]+)/i);
+  const proxyEp = match?.[1]?.trim();
+  if (!proxyEp) return DEFAULT_COPILOT_BASE_URL;
+  const host = proxyEp.replace(/^https?:\/\//, '').replace(/^proxy\./i, 'api.');
+  return host ? `https://${host}` : DEFAULT_COPILOT_BASE_URL;
+}
+
+export class GitHubCopilotProvider implements LLMProvider {
+  readonly type = 'github-copilot' as const;
+  private githubToken: string;
+  private model: string;
+  private static cache?: CopilotTokenCache;
+
+  constructor(config: LLMProviderConfig) {
+    const token = config.providerApiKey;
+    if (!token) {
+      throw new Error('GitHub token is required for Copilot. Configure it in Settings.');
+    }
+    this.githubToken = token;
+    this.model = config.model || 'gpt-4o';
+  }
+
+  async createMessage(request: LLMRequest): Promise<LLMResponse> {
+    const client = await this.getClient(request.model || this.model);
+    return client.createMessage(request);
+  }
+
+  async testConnection(): Promise<{ success: boolean; error?: string }> {
+    try {
+      const client = await this.getClient(this.model);
+      return await client.testConnection();
+    } catch (error: any) {
+      return { success: false, error: error.message || 'Failed to connect to Copilot' };
+    }
+  }
+
+  private async getClient(model: string): Promise<OpenAICompatibleProvider> {
+    const auth = await this.getCopilotAuth();
+    return new OpenAICompatibleProvider({
+      type: 'github-copilot',
+      providerName: 'GitHub Copilot',
+      apiKey: auth.token,
+      baseUrl: auth.baseUrl,
+      defaultModel: model,
+    });
+  }
+
+  private async getCopilotAuth(): Promise<CopilotTokenCache> {
+    if (GitHubCopilotProvider.cache && isTokenValid(GitHubCopilotProvider.cache)) {
+      return GitHubCopilotProvider.cache;
+    }
+
+    const response = await fetch(COPILOT_TOKEN_URL, {
+      method: 'GET',
+      headers: {
+        Accept: 'application/json',
+        Authorization: `Bearer ${this.githubToken}`,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Copilot token exchange failed: HTTP ${response.status}`);
+    }
+
+    const json = await response.json();
+    const parsed = parseCopilotTokenResponse(json);
+    const cache: CopilotTokenCache = {
+      token: parsed.token,
+      expiresAt: parsed.expiresAt,
+      baseUrl: deriveCopilotBaseUrl(parsed.token),
+    };
+    GitHubCopilotProvider.cache = cache;
+    return cache;
+  }
+}

package/src/electron/agent/llm/groq-provider.ts

@@ -0,0 +1,39 @@
+import { LLMProvider, LLMProviderConfig, LLMRequest, LLMResponse } from './types';
+import { OpenAICompatibleProvider } from './openai-compatible-provider';
+
+const GROQ_BASE_URL = 'https://api.groq.com/openai/v1';
+const DEFAULT_GROQ_MODEL = 'llama-3.1-8b-instant';
+
+export class GroqProvider implements LLMProvider {
+  readonly type = 'groq' as const;
+  private client: OpenAICompatibleProvider;
+
+  constructor(config: LLMProviderConfig) {
+    const apiKey = config.groqApiKey;
+    if (!apiKey) {
+      throw new Error('Groq API key is required. Configure it in Settings.');
+    }
+
+    const baseUrl = config.groqBaseUrl || GROQ_BASE_URL;
+
+    this.client = new OpenAICompatibleProvider({
+      type: 'groq',
+      providerName: 'Groq',
+      apiKey,
+      baseUrl,
+      defaultModel: config.model || DEFAULT_GROQ_MODEL,
+    });
+  }
+
+  createMessage(request: LLMRequest): Promise<LLMResponse> {
+    return this.client.createMessage(request);
+  }
+
+  testConnection() {
+    return this.client.testConnection();
+  }
+
+  getAvailableModels() {
+    return this.client.getAvailableModels();
+  }
+}

package/src/electron/agent/llm/index.ts

@@ -5,5 +5,10 @@ export { OllamaProvider } from './ollama-provider';
 export { GeminiProvider } from './gemini-provider';
 export { OpenRouterProvider } from './openrouter-provider';
 export { OpenAIProvider } from './openai-provider';
+export { GroqProvider } from './groq-provider';
+export { XAIProvider } from './xai-provider';
+export { KimiProvider } from './kimi-provider';
+export { AnthropicCompatibleProvider } from './anthropic-compatible-provider';
+export { GitHubCopilotProvider } from './github-copilot-provider';
 export { OpenAIOAuth, OpenAIOAuthTokens } from './openai-oauth';
 export { LLMProviderFactory, LLMSettings, CachedModelInfo } from './provider-factory';

package/src/electron/agent/llm/kimi-provider.ts

@@ -0,0 +1,39 @@
+import { LLMProvider, LLMProviderConfig, LLMRequest, LLMResponse } from './types';
+import { OpenAICompatibleProvider } from './openai-compatible-provider';
+
+const KIMI_BASE_URL = 'https://api.moonshot.ai/v1';
+const DEFAULT_KIMI_MODEL = 'kimi-k2.5';
+
+export class KimiProvider implements LLMProvider {
+  readonly type = 'kimi' as const;
+  private client: OpenAICompatibleProvider;
+
+  constructor(config: LLMProviderConfig) {
+    const apiKey = config.kimiApiKey;
+    if (!apiKey) {
+      throw new Error('Kimi API key is required. Configure it in Settings.');
+    }
+
+    const baseUrl = config.kimiBaseUrl || KIMI_BASE_URL;
+
+    this.client = new OpenAICompatibleProvider({
+      type: 'kimi',
+      providerName: 'Kimi',
+      apiKey,
+      baseUrl,
+      defaultModel: config.model || DEFAULT_KIMI_MODEL,
+    });
+  }
+
+  createMessage(request: LLMRequest): Promise<LLMResponse> {
+    return this.client.createMessage(request);
+  }
+
+  testConnection() {
+    return this.client.testConnection();
+  }
+
+  getAvailableModels() {
+    return this.client.getAvailableModels();
+  }
+}

package/src/electron/agent/llm/openai-compatible-provider.ts

@@ -0,0 +1,153 @@
+import {
+  LLMProvider,
+  LLMProviderType,
+  LLMRequest,
+  LLMResponse,
+} from './types';
+import {
+  toOpenAICompatibleMessages,
+  toOpenAICompatibleTools,
+  fromOpenAICompatibleResponse,
+} from './openai-compatible';
+
+export interface OpenAICompatibleProviderOptions {
+  type: LLMProviderType;
+  providerName: string;
+  apiKey: string;
+  baseUrl: string;
+  defaultModel: string;
+  extraHeaders?: Record<string, string>;
+}
+
+export class OpenAICompatibleProvider implements LLMProvider {
+  readonly type: LLMProviderType;
+  private apiKey: string;
+  private baseUrl: string;
+  private defaultModel: string;
+  private providerName: string;
+  private extraHeaders?: Record<string, string>;
+
+  constructor(options: OpenAICompatibleProviderOptions) {
+    this.type = options.type;
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl;
+    this.defaultModel = options.defaultModel;
+    this.providerName = options.providerName;
+    this.extraHeaders = options.extraHeaders;
+  }
+
+  async createMessage(request: LLMRequest): Promise<LLMResponse> {
+    const messages = toOpenAICompatibleMessages(request.messages, request.system);
+    const tools = request.tools ? toOpenAICompatibleTools(request.tools) : undefined;
+
+    try {
+      const model = request.model || this.defaultModel;
+      console.log(`[${this.providerName}] Calling API with model: ${model}`);
+
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+        ...(this.extraHeaders || {}),
+      };
+      if (this.apiKey) {
+        headers.Authorization = `Bearer ${this.apiKey}`;
+      }
+
+      const response = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          model,
+          messages,
+          max_tokens: request.maxTokens,
+          ...(tools && { tools, tool_choice: 'auto' }),
+        }),
+        signal: request.signal,
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({})) as { error?: { message?: string } };
+        throw new Error(
+          `${this.providerName} API error: ${response.status} ${response.statusText}` +
+          (errorData.error?.message ? ` - ${errorData.error.message}` : '')
+        );
+      }
+
+      const data = await response.json() as any;
+      return fromOpenAICompatibleResponse(data);
+    } catch (error: any) {
+      if (error.name === 'AbortError' || error.message?.includes('aborted')) {
+        console.log(`[${this.providerName}] Request aborted`);
+        throw new Error('Request cancelled');
+      }
+
+      console.error(`[${this.providerName}] API error:`, {
+        message: error.message,
+        status: error.status,
+      });
+      throw error;
+    }
+  }
+
+  async testConnection(): Promise<{ success: boolean; error?: string }> {
+    try {
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+        ...(this.extraHeaders || {}),
+      };
+      if (this.apiKey) {
+        headers.Authorization = `Bearer ${this.apiKey}`;
+      }
+
+      const response = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          model: this.defaultModel,
+          messages: [{ role: 'user', content: 'Hi' }],
+          max_tokens: 10,
+        }),
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({})) as { error?: { message?: string } };
+        return {
+          success: false,
+          error: errorData.error?.message || `HTTP ${response.status}: ${response.statusText}`,
+        };
+      }
+
+      return { success: true };
+    } catch (error: any) {
+      return {
+        success: false,
+        error: error.message || `Failed to connect to ${this.providerName} API`,
+      };
+    }
+  }
+
+  async getAvailableModels(): Promise<Array<{ id: string; name: string }>> {
+    try {
+      const headers: Record<string, string> = {};
+      if (this.apiKey) {
+        headers.Authorization = `Bearer ${this.apiKey}`;
+      }
+
+      const response = await fetch(`${this.baseUrl}/models`, {
+        headers,
+      });
+
+      if (!response.ok) {
+        return [];
+      }
+
+      const data = await response.json() as { data?: any[] };
+      return (data.data || []).map((model: any) => ({
+        id: model.id,
+        name: model.id,
+      }));
+    } catch (error) {
+      console.error(`[${this.providerName}] Failed to fetch models:`, error);
+      return [];
+    }
+  }
+}

package/src/electron/agent/llm/openai-compatible.ts

@@ -0,0 +1,133 @@
+import {
+  LLMContent,
+  LLMMessage,
+  LLMResponse,
+  LLMTool,
+} from './types';
+
+export function toOpenAICompatibleMessages(
+  messages: LLMMessage[],
+  system?: string
+): Array<{ role: string; content: any; tool_call_id?: string; tool_calls?: any[] }> {
+  const result: Array<{ role: string; content: any; tool_call_id?: string; tool_calls?: any[] }> = [];
+
+  if (system) {
+    result.push({ role: 'system', content: system });
+  }
+
+  for (const msg of messages) {
+    if (typeof msg.content === 'string') {
+      result.push({ role: msg.role, content: msg.content });
+      continue;
+    }
+
+    for (const item of msg.content) {
+      if (item.type === 'tool_result') {
+        result.push({
+          role: 'tool',
+          content: item.content,
+          tool_call_id: item.tool_use_id,
+        });
+      } else if (item.type === 'tool_use') {
+        result.push({
+          role: 'assistant',
+          content: null,
+          tool_calls: [{
+            id: item.id,
+            type: 'function',
+            function: {
+              name: item.name,
+              arguments: JSON.stringify(item.input),
+            },
+          }],
+        });
+      } else if (item.type === 'text') {
+        result.push({ role: msg.role, content: item.text });
+      }
+    }
+  }
+
+  return result;
+}
+
+export function toOpenAICompatibleTools(tools: LLMTool[]): Array<{
+  type: 'function';
+  function: {
+    name: string;
+    description: string;
+    parameters: any;
+  };
+}> {
+  return tools.map((tool) => ({
+    type: 'function' as const,
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.input_schema,
+    },
+  }));
+}
+
+export function fromOpenAICompatibleResponse(response: any): LLMResponse {
+  const content: LLMContent[] = [];
+  const choice = response.choices?.[0];
+
+  if (!choice) {
+    return {
+      content: [{ type: 'text', text: '' }],
+      stopReason: 'end_turn',
+    };
+  }
+
+  const message = choice.message;
+
+  if (message?.content) {
+    content.push({
+      type: 'text',
+      text: message.content,
+    });
+  }
+
+  if (message?.tool_calls) {
+    for (const toolCall of message.tool_calls) {
+      if (toolCall.type === 'function') {
+        content.push({
+          type: 'tool_use',
+          id: toolCall.id,
+          name: toolCall.function.name,
+          input: JSON.parse(toolCall.function.arguments || '{}'),
+        });
+      }
+    }
+  }
+
+  if (content.length === 0) {
+    content.push({ type: 'text', text: '' });
+  }
+
+  return {
+    content,
+    stopReason: mapStopReason(choice.finish_reason),
+    usage: response.usage
+      ? {
+          inputTokens: response.usage.prompt_tokens || 0,
+          outputTokens: response.usage.completion_tokens || 0,
+        }
+      : undefined,
+  };
+}
+
+export function mapStopReason(finishReason?: string): LLMResponse['stopReason'] {
+  switch (finishReason) {
+    case 'stop':
+      return 'end_turn';
+    case 'length':
+      return 'max_tokens';
+    case 'tool_calls':
+      return 'tool_use';
+    case 'content_filter':
+      return 'stop_sequence';
+    default:
+      return 'end_turn';
+  }
+}

package/src/electron/agent/llm/openai-oauth.ts

@@ -20,11 +20,12 @@ export interface OpenAIOAuthTokens {
  * Convert pi-ai OAuthCredentials to our token format
  */
 function credentialsToTokens(credentials: OAuthCredentials): OpenAIOAuthTokens {
+  const email = typeof credentials.email === 'string' ? credentials.email : undefined;
   return {
     access_token: credentials.access,
     refresh_token: credentials.refresh,
     expires_at: credentials.expires,
-    email: credentials.email,
+    email,
   };
 }
 

package/src/electron/agent/llm/openrouter-provider.ts

@@ -15,7 +15,7 @@ import {
 export class OpenRouterProvider implements LLMProvider {
   readonly type = 'openrouter' as const;
   private apiKey: string;
-  private baseUrl = 'https://openrouter.ai/api/v1';
+  private baseUrl: string;
   private defaultModel: string;
 
   constructor(config: LLMProviderConfig) {
@@ -25,6 +25,7 @@ export class OpenRouterProvider implements LLMProvider {
     }
 
     this.apiKey = apiKey;
+    this.baseUrl = config.openrouterBaseUrl || 'https://openrouter.ai/api/v1';
     this.defaultModel = config.model || 'anthropic/claude-3.5-sonnet';
   }