cowork-os 0.3.21 → 0.3.25

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

@@ -29,6 +29,8 @@ export class BedrockProvider implements LLMProvider {
   private client: BedrockRuntimeClient;
   private model: string;
 
+  private static readonly toolNameRegex = /^[a-zA-Z0-9_-]+$/;
+
   constructor(config: LLMProviderConfig) {
     const clientConfig: BedrockRuntimeClientConfig = {
       region: config.awsRegion || 'us-east-1',
@@ -56,9 +58,10 @@ export class BedrockProvider implements LLMProvider {
   }
 
   async createMessage(request: LLMRequest): Promise<LLMResponse> {
-    const messages = this.convertMessages(request.messages);
+    const toolNameMap = request.tools ? this.buildToolNameMap(request.tools) : undefined;
+    const messages = this.convertMessages(request.messages, toolNameMap);
     const system = this.convertSystem(request.system);
-    const toolConfig = request.tools ? this.convertTools(request.tools) : undefined;
+    const toolConfig = request.tools ? this.convertTools(request.tools, toolNameMap) : undefined;
 
     const command = new ConverseCommand({
       modelId: request.model,
@@ -77,7 +80,7 @@ export class BedrockProvider implements LLMProvider {
         // Pass abort signal to allow cancellation
         request.signal ? { abortSignal: request.signal } : undefined
       );
-      return this.convertResponse(response);
+      return this.convertResponse(response, toolNameMap);
     } catch (error: any) {
       // Handle abort errors gracefully
       if (error.name === 'AbortError' || error.message?.includes('aborted')) {
@@ -135,7 +138,7 @@ export class BedrockProvider implements LLMProvider {
     return [{ text: system }];
   }
 
-  private convertMessages(messages: LLMMessage[]): Message[] {
+  private convertMessages(messages: LLMMessage[], toolNameMap?: ToolNameMap): Message[] {
     return messages.map((msg) => {
       const content: ContentBlock[] = [];
 
@@ -146,10 +149,11 @@ export class BedrockProvider implements LLMProvider {
           if (item.type === 'text') {
             content.push({ text: item.text });
           } else if (item.type === 'tool_use') {
+            const mappedName = toolNameMap?.toProvider.get(item.name) || item.name;
             content.push({
               toolUse: {
                 toolUseId: item.id,
-                name: item.name,
+                name: mappedName,
                 input: item.input,
               },
             });
@@ -172,11 +176,11 @@ export class BedrockProvider implements LLMProvider {
     });
   }
 
-  private convertTools(tools: LLMTool[]): ToolConfiguration {
+  private convertTools(tools: LLMTool[], toolNameMap?: ToolNameMap): ToolConfiguration {
     return {
       tools: tools.map((tool) => ({
         toolSpec: {
-          name: tool.name,
+          name: toolNameMap?.toProvider.get(tool.name) || tool.name,
           description: tool.description,
           inputSchema: {
             json: tool.input_schema,
@@ -186,7 +190,7 @@ export class BedrockProvider implements LLMProvider {
     };
   }
 
-  private convertResponse(response: any): LLMResponse {
+  private convertResponse(response: any, toolNameMap?: ToolNameMap): LLMResponse {
     const content: LLMContent[] = [];
 
     if (response.output?.message?.content) {
@@ -197,10 +201,11 @@ export class BedrockProvider implements LLMProvider {
             text: block.text,
           });
         } else if (block.toolUse) {
+          const mappedName = toolNameMap?.fromProvider.get(block.toolUse.name) || block.toolUse.name;
           content.push({
             type: 'tool_use',
             id: block.toolUse.toolUseId,
-            name: block.toolUse.name,
+            name: mappedName,
             input: block.toolUse.input,
           });
         }
@@ -219,6 +224,49 @@ export class BedrockProvider implements LLMProvider {
     };
   }
 
+  private buildToolNameMap(tools: LLMTool[]): ToolNameMap {
+    const toProvider = new Map<string, string>();
+    const fromProvider = new Map<string, string>();
+    const used = new Set<string>();
+
+    for (const tool of tools) {
+      let base = this.normalizeToolName(tool.name);
+      if (!base) {
+        base = `tool_${this.shortHash(tool.name)}`;
+      }
+
+      let candidate = base;
+      if (used.has(candidate)) {
+        const hashed = `${base}_${this.shortHash(tool.name)}`;
+        candidate = hashed;
+        let counter = 1;
+        while (used.has(candidate)) {
+          candidate = `${hashed}_${counter++}`;
+        }
+      }
+
+      used.add(candidate);
+      toProvider.set(tool.name, candidate);
+      fromProvider.set(candidate, tool.name);
+    }
+
+    return { toProvider, fromProvider };
+  }
+
+  private normalizeToolName(name: string): string {
+    const sanitized = name.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return BedrockProvider.toolNameRegex.test(sanitized) ? sanitized : '';
+  }
+
+  private shortHash(input: string): string {
+    let hash = 2166136261;
+    for (let i = 0; i < input.length; i++) {
+      hash ^= input.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(36);
+  }
+
   private mapStopReason(reason: StopReason | undefined): LLMResponse['stopReason'] {
     switch (reason) {
       case 'end_turn':
@@ -234,3 +282,8 @@ export class BedrockProvider implements LLMProvider {
     }
   }
 }
+
+interface ToolNameMap {
+  toProvider: Map<string, string>;
+  fromProvider: Map<string, string>;
+}

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,11 @@ export { OllamaProvider } from './ollama-provider';
 export { GeminiProvider } from './gemini-provider';
 export { OpenRouterProvider } from './openrouter-provider';
 export { OpenAIProvider } from './openai-provider';
+export { AzureOpenAIProvider } from './azure-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';
   }