@link-assistant/agent 0.12.1 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "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/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.
   };
 
   /**

package/src/session/processor.ts

@@ -1,6 +1,11 @@
 import type { ModelsDev } from '../provider/models';
 import { MessageV2 } from './message-v2';
-import { type StreamTextResult, type Tool as AITool, APICallError } from 'ai';
+import {
+  type StreamTextResult,
+  type Tool as AITool,
+  APICallError,
+  JSONParseError,
+} from 'ai';
 import { Log } from '../util/log';
 import { Identifier } from '../id/id';
 import { Session } from '.';
@@ -205,6 +210,22 @@ export namespace SessionProcessor {
                   break;
                 }
                 case 'error':
+                  // Skip stream parse errors (malformed SSE from gateway/provider)
+                  // The AI SDK emits these as error events but continues the stream.
+                  // Following OpenAI Codex pattern: log and skip bad events.
+                  // See: https://github.com/link-assistant/agent/issues/169
+                  if (JSONParseError.isInstance(value.error)) {
+                    log.warn(() => ({
+                      message:
+                        'skipping malformed SSE event (stream parse error)',
+                      errorName: (value.error as Error)?.name,
+                      errorMessage: (value.error as Error)?.message?.substring(
+                        0,
+                        200
+                      ),
+                    }));
+                    continue;
+                  }
                   throw value.error;
 
                 case 'start-step':
@@ -364,7 +385,7 @@ export namespace SessionProcessor {
               providerID: input.providerID,
             });
 
-            // Check if error is retryable (APIError, SocketConnectionError, or TimeoutError)
+            // Check if error is retryable (APIError, SocketConnectionError, TimeoutError)
             const isRetryableAPIError =
               error?.name === 'APIError' && error.data.isRetryable;
             const isRetryableSocketError =