@link-assistant/agent 0.12.3 → 0.13.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.12.3",
+  "version": "0.13.1",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",

package/src/auth/plugins.ts

@@ -2630,6 +2630,173 @@ const AlibabaPlugin: AuthPlugin = {
   },
 };
 
+/**
+ * Kilo Gateway constants
+ * @see https://github.com/Kilo-Org/kilo/blob/main/packages/kilo-gateway/src/api/constants.ts
+ */
+const KILO_API_BASE = 'https://api.kilo.ai';
+const KILO_POLL_INTERVAL_MS = 3000;
+
+/**
+ * Kilo Gateway Auth Plugin
+ * Supports device authorization flow for Kilo Gateway
+ *
+ * @see https://github.com/Kilo-Org/kilo/blob/main/packages/kilo-gateway/src/auth/device-auth.ts
+ */
+const KiloPlugin: AuthPlugin = {
+  provider: 'kilo',
+  methods: [
+    {
+      label: 'Kilo Gateway (Device Authorization)',
+      type: 'oauth',
+      async authorize() {
+        // Initiate device authorization
+        const initResponse = await fetch(
+          `${KILO_API_BASE}/api/device-auth/codes`,
+          {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+          }
+        );
+
+        if (!initResponse.ok) {
+          if (initResponse.status === 429) {
+            log.error(() => ({
+              message:
+                'kilo device auth rate limited - too many pending requests',
+            }));
+            return {
+              method: 'auto' as const,
+              async callback(): Promise<AuthResult> {
+                return { type: 'failed' };
+              },
+            };
+          }
+          log.error(() => ({
+            message: 'kilo device auth initiation failed',
+            status: initResponse.status,
+          }));
+          return {
+            method: 'auto' as const,
+            async callback(): Promise<AuthResult> {
+              return { type: 'failed' };
+            },
+          };
+        }
+
+        const authData = (await initResponse.json()) as {
+          code: string;
+          verificationUrl: string;
+          expiresIn: number;
+        };
+
+        return {
+          url: authData.verificationUrl,
+          instructions: `Enter code: ${authData.code}\nWaiting for authorization...`,
+          method: 'auto' as const,
+          async callback(): Promise<AuthResult> {
+            const maxAttempts = Math.ceil(
+              (authData.expiresIn * 1000) / KILO_POLL_INTERVAL_MS
+            );
+
+            for (let attempt = 0; attempt < maxAttempts; attempt++) {
+              await new Promise((resolve) =>
+                setTimeout(resolve, KILO_POLL_INTERVAL_MS)
+              );
+
+              const pollResponse = await fetch(
+                `${KILO_API_BASE}/api/device-auth/codes/${authData.code}`
+              );
+
+              if (pollResponse.status === 202) {
+                // Still pending
+                continue;
+              }
+
+              if (pollResponse.status === 403) {
+                log.error(() => ({
+                  message: 'kilo device auth denied by user',
+                }));
+                return { type: 'failed' };
+              }
+
+              if (pollResponse.status === 410) {
+                log.error(() => ({
+                  message: 'kilo device auth code expired',
+                }));
+                return { type: 'failed' };
+              }
+
+              if (!pollResponse.ok) {
+                log.error(() => ({
+                  message: 'kilo device auth poll failed',
+                  status: pollResponse.status,
+                }));
+                return { type: 'failed' };
+              }
+
+              const data = (await pollResponse.json()) as {
+                status: string;
+                token?: string;
+                userEmail?: string;
+              };
+
+              if (data.status === 'approved' && data.token) {
+                log.info(() => ({
+                  message: 'kilo device auth approved',
+                  email: data.userEmail,
+                }));
+
+                // Token from Kilo device auth is long-lived (1 year)
+                const TOKEN_EXPIRATION_MS = 365 * 24 * 60 * 60 * 1000;
+                return {
+                  type: 'success',
+                  provider: 'kilo',
+                  refresh: data.token,
+                  access: data.token,
+                  expires: Date.now() + TOKEN_EXPIRATION_MS,
+                };
+              }
+            }
+
+            log.error(() => ({
+              message: 'kilo device auth timed out',
+            }));
+            return { type: 'failed' };
+          },
+        };
+      },
+    },
+    {
+      label: 'API Key',
+      type: 'api',
+      async authorize(inputs: Record<string, string>) {
+        const key = inputs['key'];
+        if (!key) return { type: 'failed' };
+        return {
+          type: 'success',
+          provider: 'kilo',
+          key,
+        };
+      },
+    },
+  ],
+  async loader(getAuth) {
+    const auth = await getAuth();
+    if (!auth) return {};
+
+    if (auth.type === 'api') {
+      return { apiKey: auth.key };
+    }
+
+    if (auth.type === 'oauth') {
+      return { apiKey: auth.access };
+    }
+
+    return {};
+  },
+};
+
 /**
  * Registry of all auth plugins
  */
@@ -2640,6 +2807,7 @@ const plugins: Record<string, AuthPlugin> = {
   google: GooglePlugin,
   'qwen-coder': QwenPlugin,
   alibaba: AlibabaPlugin,
+  kilo: KiloPlugin,
 };
 
 /**

package/src/bun/index.ts

@@ -13,26 +13,69 @@ export namespace BunProc {
   // Lock key for serializing package installations to prevent race conditions
   const INSTALL_LOCK_KEY = 'bun-install';
 
+  // Default timeout for subprocess commands (2 minutes)
+  // This prevents indefinite hangs from known Bun issues:
+  // - HTTP 304 response handling (https://github.com/oven-sh/bun/issues/5831)
+  // - Failed dependency fetch (https://github.com/oven-sh/bun/issues/26341)
+  // - IPv6 configuration issues
+  const DEFAULT_TIMEOUT_MS = 120000;
+
+  // Timeout specifically for package installation (60 seconds)
+  // Package installations should complete within this time for typical packages
+  const INSTALL_TIMEOUT_MS = 60000;
+
+  export const TimeoutError = NamedError.create(
+    'BunTimeoutError',
+    z.object({
+      cmd: z.array(z.string()),
+      timeoutMs: z.number(),
+    })
+  );
+
   export async function run(
     cmd: string[],
-    options?: Bun.SpawnOptions.OptionsObject<any, any, any>
+    options?: Bun.SpawnOptions.OptionsObject<any, any, any> & {
+      timeout?: number;
+    }
   ) {
+    const timeout = options?.timeout ?? DEFAULT_TIMEOUT_MS;
+
     log.info(() => ({
       message: 'running',
       cmd: [which(), ...cmd],
-      ...options,
+      timeout,
+      cwd: options?.cwd,
     }));
+
     const result = Bun.spawn([which(), ...cmd], {
       ...options,
       stdout: 'pipe',
       stderr: 'pipe',
+      timeout, // Automatically kills process after timeout
+      killSignal: 'SIGTERM', // Graceful termination signal
       env: {
         ...process.env,
         ...options?.env,
         BUN_BE_BUN: '1',
       },
     });
+
     const code = await result.exited;
+
+    // Check if process was killed due to timeout
+    if (result.signalCode === 'SIGTERM' && code !== 0) {
+      log.error(() => ({
+        message: 'command timed out',
+        cmd: [which(), ...cmd],
+        timeout,
+        signalCode: result.signalCode,
+      }));
+      throw new TimeoutError({
+        cmd: [which(), ...cmd],
+        timeoutMs: timeout,
+      });
+    }
+
     const stdout = result.stdout
       ? typeof result.stdout === 'number'
         ? result.stdout
@@ -84,6 +127,13 @@ export namespace BunProc {
     );
   }
 
+  /**
+   * Check if an error is a timeout error
+   */
+  function isTimeoutError(error: unknown): boolean {
+    return error instanceof TimeoutError;
+  }
+
   /**
    * Wait for a specified duration
    */
@@ -139,12 +189,13 @@ export namespace BunProc {
       version,
     }));
 
-    // Retry logic for cache-related errors
+    // Retry logic for cache-related errors and timeout errors
     let lastError: Error | undefined;
     for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
       try {
         await BunProc.run(args, {
           cwd: Global.Path.cache,
+          timeout: INSTALL_TIMEOUT_MS, // Use specific timeout for package installation
         });
 
         log.info(() => ({
@@ -159,6 +210,7 @@ export namespace BunProc {
       } catch (e) {
         const errorMsg = e instanceof Error ? e.message : String(e);
         const isCacheError = isCacheRelatedError(errorMsg);
+        const isTimeout = isTimeoutError(e);
 
         log.warn(() => ({
           message: 'package installation attempt failed',
@@ -168,11 +220,15 @@ export namespace BunProc {
           maxRetries: MAX_RETRIES,
           error: errorMsg,
           isCacheError,
+          isTimeout,
         }));
 
-        if (isCacheError && attempt < MAX_RETRIES) {
+        // Retry on cache-related errors or timeout errors
+        if ((isCacheError || isTimeout) && attempt < MAX_RETRIES) {
           log.info(() => ({
-            message: 'retrying installation after cache-related error',
+            message: isTimeout
+              ? 'retrying installation after timeout (possible network issue)'
+              : 'retrying installation after cache-related error',
             pkg,
             version,
             attempt,
@@ -184,7 +240,7 @@ export namespace BunProc {
           continue;
         }
 
-        // Non-cache error or final attempt - log and throw
+        // Non-retriable error or final attempt - log and throw
         log.error(() => ({
           message: 'package installation failed',
           pkg,
@@ -192,10 +248,11 @@ export namespace BunProc {
           error: errorMsg,
           stack: e instanceof Error ? e.stack : undefined,
           possibleCacheCorruption: isCacheError,
+          timedOut: isTimeout,
           attempts: attempt,
         }));
 
-        // Provide helpful recovery instructions for cache-related errors
+        // Provide helpful recovery instructions
         if (isCacheError) {
           log.error(() => ({
             message:
@@ -203,6 +260,15 @@ export namespace BunProc {
           }));
         }
 
+        if (isTimeout) {
+          log.error(() => ({
+            message:
+              'Package installation timed out. This may be due to network issues or Bun hanging. ' +
+              'Try: 1) Check network connectivity, 2) Run "bun pm cache rm" to clear cache, ' +
+              '3) Check for IPv6 issues (try disabling IPv6)',
+          }));
+        }
+
         throw new InstallFailedError(
           { pkg, version, details: errorMsg },
           {

package/src/cli/cmd/auth.ts

@@ -128,8 +128,9 @@ export const AuthLoginCommand = cmd({
       'github-copilot': 1,
       openai: 2,
       google: 3,
-      openrouter: 4,
-      vercel: 5,
+      kilo: 4,
+      openrouter: 5,
+      vercel: 6,
     };
 
     // Note: Using `select` instead of `autocomplete` because `autocomplete` is only

package/src/index.js

@@ -172,8 +172,10 @@ async function parseModelConfig(argv) {
       modelID = modelID || 'kimi-k2.5-free';
     }
 
+    // Log raw and parsed values to help diagnose model routing issues (#171)
     Log.Default.info(() => ({
       message: 'using explicit provider/model',
+      rawModel: modelArg,
       providerID,
       modelID,
     }));

package/src/provider/provider.ts

@@ -324,19 +324,21 @@ export namespace Provider {
     },
     /**
      * Kilo provider - access to 500+ AI models through Kilo Gateway
-     * Uses OpenAI-compatible API at https://api.kilo.ai/api/gateway
+     * Uses OpenRouter-compatible API at https://api.kilo.ai/api/openrouter
      *
-     * Free models available without API key (using 'public' key):
+     * Authentication required: run `agent auth login` and select "Kilo Gateway"
+     * For API key authentication, set KILO_API_KEY environment variable
+     *
+     * Free models available after authentication:
      * - GLM-5 (z-ai/glm-5) - Free limited time, flagship Z.AI model
      * - GLM 4.7 (z-ai/glm-4.7:free) - Free, agent-centric model
      * - Kimi K2.5 (moonshot/kimi-k2.5:free) - Free, agentic capabilities
      * - MiniMax M2.1 (minimax/m2.1:free) - Free, general-purpose
      * - Giga Potato (giga-potato:free) - Free evaluation model
      *
-     * For paid models, set KILO_API_KEY environment variable
-     *
      * @see https://kilo.ai/docs/gateway
      * @see https://kilo.ai/docs/advanced-usage/free-and-budget-models
+     * @see https://github.com/Kilo-Org/kilo/tree/main/packages/kilo-gateway
      */
     kilo: async (input) => {
       const hasKey = await (async () => {
@@ -345,8 +347,7 @@ export namespace Provider {
         return false;
       })();
 
-      // For free models, we can use 'public' as the API key
-      // For paid models, user needs to set KILO_API_KEY
+      // Filter to only free models when no API key
       if (!hasKey) {
         for (const [key, value] of Object.entries(input.models)) {
           // Keep only free models (cost.input === 0) when no API key
@@ -355,13 +356,44 @@ export namespace Provider {
         }
       }
 
+      // Build options
+      const options: Record<string, any> = {};
+
+      // Kilo-specific headers for the OpenRouter-compatible API
+      // @see https://github.com/Kilo-Org/kilo/blob/main/packages/kilo-gateway/src/headers.ts
+      const headers: Record<string, string> = {
+        'User-Agent': 'opencode-kilo-provider',
+        'X-KILOCODE-EDITORNAME': 'link-assistant-agent',
+      };
+
+      // Pass KILO_ORG_ID if available
+      if (process.env['KILO_ORG_ID']) {
+        headers['X-KILOCODE-ORGANIZATIONID'] = process.env['KILO_ORG_ID'];
+      }
+
+      options.headers = headers;
+
+      // Use auth token if available (from `agent auth login` -> Kilo device auth)
+      if (!hasKey) {
+        // Without authentication, use 'anonymous' key
+        // Note: The Kilo API may reject anonymous requests for completions.
+        // Users should authenticate via `agent auth login` for reliable access.
+        options.apiKey = 'anonymous';
+      } else {
+        // If we have stored auth, the loader will provide the token
+        const auth = await Auth.get(input.id);
+        if (auth) {
+          if (auth.type === 'api') {
+            options.apiKey = auth.key;
+          } else if (auth.type === 'oauth') {
+            options.apiKey = auth.access;
+          }
+        }
+      }
+
       return {
         autoload: Object.keys(input.models).length > 0,
-        options: hasKey
-          ? {}
-          : {
-              apiKey: 'public',
-            },
+        options,
       };
     },
     /**
@@ -769,13 +801,14 @@ export namespace Provider {
     database['kilo'] = {
       id: 'kilo',
       name: 'Kilo Gateway',
-      npm: '@ai-sdk/openai-compatible',
-      api: 'https://api.kilo.ai/api/gateway',
+      npm: '@openrouter/ai-sdk-provider',
+      api: 'https://api.kilo.ai/api/openrouter',
       env: ['KILO_API_KEY'],
       models: {
-        // GLM-5 - Flagship Z.AI model, free for limited time
+        // GLM-5 - Flagship Z.AI model, free tier
+        // Kilo API model ID: z-ai/glm-5:free (NOT z-ai/glm-5 which is paid)
         'glm-5-free': {
-          id: 'z-ai/glm-5',
+          id: 'z-ai/glm-5:free',
           name: 'GLM-5 (Free)',
           release_date: '2026-02-11',
           attachment: false,
@@ -789,7 +822,7 @@ export namespace Provider {
             cache_write: 0,
           },
           limit: {
-            context: 202752,
+            context: 202800,
             output: 131072,
           },
           modalities: {
@@ -798,10 +831,11 @@ export namespace Provider {
           },
           options: {},
         },
-        // GLM 4.7 - Agent-centric model, free
-        'glm-4.7-free': {
-          id: 'z-ai/glm-4.7:free',
-          name: 'GLM 4.7 (Free)',
+        // GLM 4.5 Air - Free Z.AI model (replaces non-existent glm-4.7:free)
+        // Kilo API model ID: z-ai/glm-4.5-air:free
+        'glm-4.5-air-free': {
+          id: 'z-ai/glm-4.5-air:free',
+          name: 'GLM 4.5 Air (Free)',
           release_date: '2026-01-15',
           attachment: false,
           reasoning: true,
@@ -815,7 +849,7 @@ export namespace Provider {
           },
           limit: {
             context: 131072,
-            output: 65536,
+            output: 96000,
           },
           modalities: {
             input: ['text'],
@@ -823,13 +857,14 @@ export namespace Provider {
           },
           options: {},
         },
-        // Kimi K2.5 - Agentic capabilities, free
-        'kimi-k2.5-free': {
-          id: 'moonshot/kimi-k2.5:free',
-          name: 'Kimi K2.5 (Free)',
-          release_date: '2025-12-01',
+        // MiniMax M2.5 - General-purpose, free (upgraded from M2.1)
+        // Kilo API model ID: minimax/minimax-m2.5:free
+        'minimax-m2.5-free': {
+          id: 'minimax/minimax-m2.5:free',
+          name: 'MiniMax M2.5 (Free)',
+          release_date: '2026-01-01',
           attachment: false,
-          reasoning: false,
+          reasoning: true,
           temperature: true,
           tool_call: true,
           cost: {
@@ -839,8 +874,8 @@ export namespace Provider {
             cache_write: 0,
           },
           limit: {
-            context: 131072,
-            output: 65536,
+            context: 204800,
+            output: 131072,
           },
           modalities: {
             input: ['text'],
@@ -848,13 +883,14 @@ export namespace Provider {
           },
           options: {},
         },
-        // MiniMax M2.1 - General-purpose, free
-        'minimax-m2.1-free': {
-          id: 'minimax/m2.1:free',
-          name: 'MiniMax M2.1 (Free)',
-          release_date: '2025-11-01',
-          attachment: false,
-          reasoning: false,
+        // Giga Potato - Free evaluation model
+        // Kilo API model ID: giga-potato (no :free suffix)
+        'giga-potato-free': {
+          id: 'giga-potato',
+          name: 'Giga Potato (Free)',
+          release_date: '2026-01-01',
+          attachment: true,
+          reasoning: true,
           temperature: true,
           tool_call: true,
           cost: {
@@ -864,19 +900,20 @@ export namespace Provider {
             cache_write: 0,
           },
           limit: {
-            context: 131072,
-            output: 65536,
+            context: 256000,
+            output: 32000,
           },
           modalities: {
-            input: ['text'],
+            input: ['text', 'image'],
             output: ['text'],
           },
           options: {},
         },
-        // Giga Potato - Free evaluation model
-        'giga-potato-free': {
-          id: 'giga-potato:free',
-          name: 'Giga Potato (Free)',
+        // Trinity Large Preview - Preview model from Arcee AI
+        // Kilo API model ID: arcee-ai/trinity-large-preview:free
+        'trinity-large-preview': {
+          id: 'arcee-ai/trinity-large-preview:free',
+          name: 'Trinity Large Preview (Free)',
           release_date: '2026-01-01',
           attachment: false,
           reasoning: false,
@@ -889,8 +926,8 @@ export namespace Provider {
             cache_write: 0,
           },
           limit: {
-            context: 65536,
-            output: 32768,
+            context: 131000,
+            output: 65536,
           },
           modalities: {
             input: ['text'],
@@ -898,15 +935,16 @@ export namespace Provider {
           },
           options: {},
         },
-        // Trinity Large Preview - Preview model from Arcee AI
-        'trinity-large-preview': {
-          id: 'arcee/trinity-large-preview',
-          name: 'Trinity Large Preview (Free)',
-          release_date: '2026-01-01',
+        // DeepSeek R1 - Reasoning model, free
+        // Kilo API model ID: deepseek/deepseek-r1-0528:free
+        'deepseek-r1-free': {
+          id: 'deepseek/deepseek-r1-0528:free',
+          name: 'DeepSeek R1 (Free)',
+          release_date: '2025-05-28',
           attachment: false,
-          reasoning: false,
+          reasoning: true,
           temperature: true,
-          tool_call: true,
+          tool_call: false,
           cost: {
             input: 0,
             output: 0,
@@ -914,8 +952,8 @@ export namespace Provider {
             cache_write: 0,
           },
           limit: {
-            context: 65536,
-            output: 32768,
+            context: 163840,
+            output: 163840,
           },
           modalities: {
             input: ['text'],
@@ -1293,9 +1331,9 @@ export namespace Provider {
     if (providerID === 'kilo') {
       priority = [
         'glm-5-free',
-        'glm-4.7-free',
-        'kimi-k2.5-free',
-        'minimax-m2.1-free',
+        'glm-4.5-air-free',
+        'minimax-m2.5-free',
+        'deepseek-r1-free',
         'giga-potato-free',
       ];
     }
@@ -1391,10 +1429,9 @@ export namespace Provider {
    * Priority for free models:
    * 1. If model is uniquely available in one provider, use that provider
    * 2. If model is available in multiple providers, prioritize based on free model availability:
-   *    - kilo: glm-5-free, glm-4.7-free, minimax-m2.1-free, giga-potato-free (unique to Kilo)
-   *    - opencode: minimax-m2.5-free, big-pickle, gpt-5-nano (unique to OpenCode)
-   *    - SHARED: kimi-k2.5-free (available in both)
-   * 3. For shared models like kimi-k2.5-free, prefer OpenCode first, then fall back to Kilo on rate limit
+   *    - kilo: glm-5-free, glm-4.5-air-free, minimax-m2.5-free, giga-potato-free, deepseek-r1-free (unique to Kilo)
+   *    - opencode: big-pickle, gpt-5-nano (unique to OpenCode)
+   * 3. For shared models, prefer OpenCode first, then fall back to Kilo on rate limit
    *
    * @param modelID - Short model name without provider prefix
    * @returns Provider ID that should handle this model, or undefined if not found
@@ -1408,9 +1445,11 @@ export namespace Provider {
     // Models unique to Kilo (GLM models from Z.AI are only free on Kilo)
     const kiloUniqueModels = [
       'glm-5-free',
-      'glm-4.7-free',
+      'glm-4.5-air-free',
+      'minimax-m2.5-free',
       'giga-potato-free',
       'trinity-large-preview',
+      'deepseek-r1-free',
     ];
 
     // Check if it's a Kilo-unique model
@@ -1515,10 +1554,8 @@ export namespace Provider {
    * If user specifies "kilo/kimi-k2.5-free", no fallback will occur.
    */
   const SHARED_FREE_MODELS: Record<string, string[]> = {
-    // kimi-k2.5-free is available in both OpenCode and Kilo
-    'kimi-k2.5-free': ['opencode', 'kilo'],
-    // Note: minimax-m2.1-free is Kilo only, minimax-m2.5-free is OpenCode only
-    // They are different model versions, not shared
+    // Currently no shared models between OpenCode and Kilo providers.
+    // Kilo models use different IDs than OpenCode models.
   };
 
   /**