@link-assistant/agent 0.26.14 → 0.27.0

package/src/cli/cmd/auth.ts

@@ -359,6 +359,10 @@ export const AuthLoginCommand = cmd({
       togetherai: 'https://api.together.xyz/settings/api-keys',
       deepseek: 'https://platform.deepseek.com/api_keys',
       xai: 'https://console.x.ai',
+      poe: 'https://poe.com/api_key',
+      digitalocean: 'https://cloud.digitalocean.com/gen-ai/model-access-keys',
+      gitlab: 'https://gitlab.com/-/user_settings/personal_access_tokens',
+      azure: 'https://ai.azure.com/',
     };
 
     if (apiKeyUrls[provider]) {

package/src/cli/cmd/models.ts

@@ -1,10 +1,17 @@
 import type { Argv } from 'yargs';
 import { Instance } from '../../project/instance';
 import { Provider } from '../../provider/provider';
+import { ModelsDev } from '../../provider/models';
+import { ModelDiscovery } from '../../provider/model-discovery';
+import { ExtraProviders } from '../../provider/extra-providers';
 import { cmd } from './cmd';
 import { UI } from '../ui';
 import { EOL } from 'os';
 
+function isFree(model: ModelsDev.Model) {
+  return model.cost?.input === 0 && model.cost?.output === 0;
+}
+
 export const ModelsCommand = cmd({
   command: 'models [provider]',
   describe: 'list all available models',
@@ -19,39 +26,87 @@ export const ModelsCommand = cmd({
         describe:
           'use more verbose model output (includes metadata like costs)',
         type: 'boolean',
+      })
+      .option('discover', {
+        describe:
+          "also list models from each provider's own /models endpoint (cached for an hour)",
+        type: 'boolean',
+      })
+      .option('refresh', {
+        describe:
+          'refetch the models.dev catalogue and provider model listings, ignoring caches (implies --discover)',
+        type: 'boolean',
+      })
+      .option('free', {
+        describe: 'only list models that cost nothing to use',
+        type: 'boolean',
       });
   },
   handler: async (args) => {
+    if (args.refresh) await ModelsDev.refresh();
+    const discover = Boolean(args.discover || args.refresh);
+
     await Instance.provide({
       directory: process.cwd(),
       async fn() {
-        const providers = await Provider.list();
-
-        function printModels(providerID: string, verbose?: boolean) {
-          const provider = providers[providerID];
-          for (const [modelID, model] of Object.entries(provider.info.models)) {
-            process.stdout.write(`${providerID}/${modelID}`);
+        async function printModels(providerID: string) {
+          const provider = await Provider.getProvider(providerID);
+          if (!provider) return false;
+          const models: Record<string, ModelsDev.Model> = {
+            ...provider.info.models,
+          };
+          const unpriced = new Set<string>();
+          const keyless = ExtraProviders.isKeyless(provider.info.id);
+          if (discover) {
+            const result = await Provider.discoverModels(providerID, {
+              force: Boolean(args.refresh),
+            });
+            if (result.status === 'error') {
+              UI.error(
+                `${providerID}: model discovery failed: ${result.error}`
+              );
+            }
+            const s = await Provider.state();
+            for (const found of result.models) {
+              if (models[found.id]) continue;
+              const metadata = ModelDiscovery.catalogueMetadata(
+                s.database,
+                found.model ?? found.id,
+                provider.info.id
+              );
+              // A listing without prices says nothing about the cost, except
+              // on keyless providers (gpt4free, local servers), which are free.
+              if (!keyless && !found.free && !found.cost && !metadata?.cost) {
+                unpriced.add(found.id);
+              }
+              models[found.id] = ModelDiscovery.toModelInfo(found, {
+                metadata,
+              });
+            }
+          }
+          for (const [modelID, model] of Object.entries(models)) {
+            if (args.free && (unpriced.has(modelID) || !isFree(model)))
+              continue;
+            process.stdout.write(`${provider.info.id}/${modelID}`);
             process.stdout.write(EOL);
-            if (verbose) {
+            if (args.verbose) {
               process.stdout.write(JSON.stringify(model, null, 2));
               process.stdout.write(EOL);
             }
           }
+          return true;
         }
 
         if (args.provider) {
-          const provider = providers[args.provider];
-          if (!provider) {
+          if (!(await printModels(args.provider))) {
             UI.error(`Provider not found: ${args.provider}`);
-            return;
           }
-
-          printModels(args.provider, args.verbose);
           return;
         }
 
+        const providers = await Provider.list();
         for (const providerID of Object.keys(providers)) {
-          printModels(providerID, args.verbose);
+          await printModels(providerID);
         }
       },
     });

package/src/cli/model-config.js

@@ -5,6 +5,7 @@ import {
   getCompactionSafetyMarginFromProcessArgv,
 } from './argv.ts';
 import { Log } from '../util/log.ts';
+import { ExtraProviders } from '../provider/extra-providers.ts';
 import {
   DEFAULT_PROVIDER_ID,
   DEFAULT_MODEL_ID,
@@ -124,7 +125,8 @@ export async function parseModelConfig(
   if (modelArg.includes('/')) {
     // Explicit provider/model format - respect user's choice
     const modelParts = modelArg.split('/');
-    providerID = modelParts[0];
+    // Accept alternative spellings such as `g4f/...` for `gpt4free/...` (#334)
+    providerID = ExtraProviders.canonicalID(modelParts[0]);
     modelID = modelParts.slice(1).join('/');
 
     // Validate that providerID and modelID are not empty
@@ -152,9 +154,10 @@ export async function parseModelConfig(
     const isDefaultModel = !cliModelArg && modelArg === defaultModel;
     try {
       const { Provider } = await import('../provider/provider.ts');
-      const s = await Provider.state();
-      const provider = s.providers[providerID];
-      if (provider && !provider.info.models[modelID]) {
+      // getProvider also enables keyless providers (gpt4free, local servers)
+      // on explicit request; routers among them accept unlisted IDs (#334).
+      const provider = await Provider.getProvider(providerID);
+      if (provider && !(await Provider.hasModel(providerID, modelID))) {
         const liveInfo = await Provider.refreshLiveModelInfo(
           providerID,
           modelID

package/src/index.js

@@ -26,6 +26,7 @@ import {
 } from './json-standard/index.ts';
 import { McpCommand } from './cli/cmd/mcp.ts';
 import { AuthCommand } from './cli/cmd/auth.ts';
+import { ModelsCommand } from './cli/cmd/models.ts';
 import { FormatError } from './cli/error.ts';
 import { UI } from './cli/ui.ts';
 import { errorText } from './util/error-text.ts';
@@ -654,6 +655,8 @@ async function main() {
       .command(McpCommand)
       // Auth subcommand
       .command(AuthCommand)
+      // Models subcommand (list, --discover, --refresh, --free)
+      .command(ModelsCommand)
       // Default command for agent mode (when no subcommand specified)
       .command({
         command: '$0',

package/src/provider/env-template.ts

@@ -0,0 +1,115 @@
+import type { ModelsDev } from './models';
+
+/**
+ * Environment handling for models.dev provider entries.
+ *
+ * models.dev (the catalogue OpenCode uses) describes some providers with
+ * templated base URLs such as
+ * `https://api.cloudflare.com/client/v4/accounts/${CLOUDFLARE_ACCOUNT_ID}/ai/v1`
+ * and lists the template variables next to the real credentials in
+ * `provider.env`. The variables configure *where* to send requests; only the
+ * remaining variables carry a credential.
+ *
+ * @see https://github.com/link-assistant/agent/issues/334
+ */
+export namespace EnvTemplate {
+  const PATTERN = /\$\{([A-Za-z0-9_]+)\}/g;
+
+  /**
+   * Variable names that configure an endpoint, account, region or project.
+   * They must never be sent as an API key.
+   */
+  const NON_CREDENTIAL =
+    /(_ID|_NAME|_REGION|_PROJECT|_LOCATION|_HOST|_URL|_ACCOUNT|_ENDPOINT|_CREDENTIALS|_RESOURCE_GROUP|_VERSION|_ORG|_ORGANIZATION)$/;
+
+  /** Part of a SigV4 key pair, not a bearer credential. */
+  const PAIRED_SECRETS = new Set(['AWS_SECRET_ACCESS_KEY']);
+
+  export function variables(template?: string): string[] {
+    if (!template) return [];
+    return Array.from(template.matchAll(PATTERN), (match) => match[1]);
+  }
+
+  export function isCredentialEnv(name: string): boolean {
+    return !NON_CREDENTIAL.test(name) && !PAIRED_SECRETS.has(name);
+  }
+
+  /**
+   * The env vars of a provider that hold an API key, in catalogue order.
+   */
+  export function credentialEnv(provider: ModelsDev.Provider): string[] {
+    const templated = new Set(variables(provider.api));
+    for (const model of Object.values(provider.models ?? {})) {
+      for (const name of variables(model.provider?.api)) templated.add(name);
+    }
+    return (provider.env ?? []).filter(
+      (name) => !templated.has(name) && isCredentialEnv(name)
+    );
+  }
+
+  /**
+   * Values for template variables that OpenCode derives instead of reading
+   * verbatim (normalized hosts, Vertex endpoint, default AWS region).
+   */
+  export function derived(
+    env: Record<string, string | undefined> = process.env
+  ): Record<string, string | undefined> {
+    const location =
+      env['GOOGLE_VERTEX_LOCATION'] ??
+      env['GOOGLE_CLOUD_LOCATION'] ??
+      env['VERTEX_LOCATION'] ??
+      'global';
+    return {
+      AWS_REGION: env['AWS_REGION'] ?? env['AWS_DEFAULT_REGION'] ?? 'us-east-1',
+      DATABRICKS_HOST: stripHost(env['DATABRICKS_HOST']),
+      SNOWFLAKE_ACCOUNT: stripHost(env['SNOWFLAKE_ACCOUNT'])?.replace(
+        /\.snowflakecomputing\.com$/,
+        ''
+      ),
+      NEON_AI_GATEWAY_BASE_URL: env['NEON_AI_GATEWAY_BASE_URL']?.replace(
+        /\/+$/,
+        ''
+      ),
+      GOOGLE_VERTEX_PROJECT:
+        env['GOOGLE_VERTEX_PROJECT'] ??
+        env['GOOGLE_CLOUD_PROJECT'] ??
+        env['GCP_PROJECT'] ??
+        env['GCLOUD_PROJECT'],
+      GOOGLE_VERTEX_LOCATION: location,
+      GOOGLE_VERTEX_ENDPOINT:
+        location === 'global'
+          ? 'aiplatform.googleapis.com'
+          : `${location}-aiplatform.googleapis.com`,
+    };
+  }
+
+  function stripHost(value?: string) {
+    if (!value) return undefined;
+    return value.replace(/^[a-z]+:\/\//i, '').replace(/\/+$/, '');
+  }
+
+  /**
+   * Substitute `${VAR}` placeholders. Returns `undefined` when any variable is
+   * missing, so callers never send requests to a half-filled URL.
+   */
+  export function resolve(
+    template: string | undefined,
+    env: Record<string, string | undefined> = process.env,
+    values: Record<string, string | undefined> = {}
+  ): string | undefined {
+    if (!template) return undefined;
+    if (!template.includes('${')) return template;
+    const lookup = { ...derived(env), ...values };
+    let missing = false;
+    const result = template.replace(PATTERN, (_, name: string) => {
+      const value = lookup[name] ?? env[name];
+      if (!value) missing = true;
+      return value ?? '';
+    });
+    return missing ? undefined : result;
+  }
+
+  export function isTemplate(value?: string): boolean {
+    return Boolean(value?.includes('${'));
+  }
+}

package/src/provider/extra-providers.ts

@@ -0,0 +1,347 @@
+import type { ModelsDev } from './models';
+
+/**
+ * Providers that models.dev (the catalogue OpenCode uses) does not list:
+ * gpt4free (https://github.com/xtekky/gpt4free) and its hosted gateway,
+ * Pollinations, other OpenAI-compatible endpoints from gpt4free's provider
+ * list, and local inference servers.
+ *
+ * A definition only fills a gap: if models.dev ever adds the same provider ID,
+ * the models.dev entry wins. Seed models are a starting point, the real list
+ * comes from the provider's `/models` endpoint (see `ModelDiscovery`).
+ *
+ * @see https://github.com/link-assistant/agent/issues/334
+ */
+export namespace ExtraProviders {
+  export interface Definition {
+    id: string;
+    name: string;
+    /** Default OpenAI-compatible base URL. */
+    api: string;
+    /** Env vars that override the base URL, first match wins. */
+    baseURLEnv?: string[];
+    /** Optional or required API key env vars. */
+    env: string[];
+    doc: string;
+    /**
+     * Usable without credentials (local servers, anonymous free tiers).
+     * Such providers stay hidden until explicitly requested with
+     * `--model <provider>/<model>` or configured, so they never take over
+     * default or short-name resolution.
+     */
+    keyless: boolean;
+    /** Router or local server: accept model IDs not present in any list. */
+    passthrough: boolean;
+    models: Record<string, ModelsDev.Model>;
+  }
+
+  function seed(
+    id: string,
+    name: string,
+    options: {
+      context?: number;
+      output?: number;
+      reasoning?: boolean;
+      attachment?: boolean;
+      free?: boolean;
+    } = {}
+  ): ModelsDev.Model {
+    const context = options.context ?? 128000;
+    return {
+      id,
+      name,
+      release_date: '',
+      attachment: options.attachment ?? false,
+      reasoning: options.reasoning ?? false,
+      temperature: true,
+      tool_call: true,
+      cost: { input: 0, output: 0, cache_read: 0, cache_write: 0 },
+      limit: { context, output: options.output ?? Math.min(16384, context) },
+      modalities: {
+        input: options.attachment ? ['text', 'image'] : ['text'],
+        output: ['text'],
+      },
+      options: {},
+    };
+  }
+
+  const LOCAL = { context: 32768, output: 8192 };
+
+  export const DEFINITIONS: Definition[] = [
+    {
+      id: 'gpt4free',
+      name: 'GPT4Free (local Interference API)',
+      api: 'http://localhost:1337/v1',
+      baseURLEnv: ['G4F_BASE_URL', 'GPT4FREE_BASE_URL'],
+      env: ['G4F_API_KEY'],
+      doc: 'https://github.com/xtekky/gpt4free',
+      keyless: true,
+      passthrough: true,
+      models: { auto: seed('auto', 'GPT4Free Auto (provider rotation)') },
+    },
+    {
+      id: 'g4f-space',
+      name: 'GPT4Free hosted gateway (g4f.space)',
+      api: 'https://g4f.space/v1',
+      baseURLEnv: ['G4F_SPACE_BASE_URL'],
+      env: ['G4F_SPACE_API_KEY'],
+      doc: 'https://g4f.dev/docs',
+      keyless: true,
+      passthrough: true,
+      models: { auto: seed('auto', 'GPT4Free Auto (random public server)') },
+    },
+    {
+      id: 'pollinations',
+      name: 'Pollinations',
+      api: 'https://gen.pollinations.ai/v1',
+      baseURLEnv: ['POLLINATIONS_BASE_URL'],
+      env: ['POLLINATIONS_API_KEY'],
+      doc: 'https://pollinations.ai',
+      keyless: true,
+      passthrough: true,
+      models: {
+        openai: seed('openai', 'GPT-5.4 Nano (Pollinations alias)', {
+          context: 400000,
+          reasoning: true,
+          attachment: true,
+        }),
+        'openai-fast': seed('openai-fast', 'GPT-5 Nano (Pollinations alias)', {
+          context: 400000,
+          reasoning: true,
+          attachment: true,
+        }),
+        deepseek: seed('deepseek', 'DeepSeek V4 Flash (Pollinations alias)', {
+          context: 1048576,
+          reasoning: true,
+        }),
+        kimi: seed('kimi', 'Kimi K2.6 (Pollinations alias)', {
+          context: 262000,
+          reasoning: true,
+        }),
+        minimax: seed('minimax', 'MiniMax M3 (Pollinations alias)', {
+          context: 524288,
+          reasoning: true,
+        }),
+        nemotron: seed('nemotron', 'Nemotron 3 Ultra (Pollinations alias)', {
+          context: 262144,
+          reasoning: true,
+        }),
+      },
+    },
+    {
+      id: 'airforce',
+      name: 'Airforce',
+      api: 'https://api.airforce/v1',
+      env: ['AIRFORCE_API_KEY'],
+      doc: 'https://api.airforce',
+      keyless: false,
+      passthrough: true,
+      models: {},
+    },
+    {
+      id: 'aibadgr',
+      name: 'AI Badgr',
+      api: 'https://aibadgr.com/api/v1',
+      env: ['AIBADGR_API_KEY'],
+      doc: 'https://aibadgr.com',
+      keyless: false,
+      passthrough: false,
+      models: {},
+    },
+    {
+      id: 'api-route',
+      name: 'APIRoute',
+      api: 'https://global.api-route.com/v1',
+      env: ['APIROUTE_API_KEY', 'API_ROUTE_API_KEY'],
+      doc: 'https://www.api-route.com',
+      keyless: false,
+      passthrough: true,
+      models: {},
+    },
+    {
+      id: 'cheaperinference',
+      name: 'CheaperInference',
+      api: 'https://api.cheaperinference.com/v1',
+      env: ['CHEAPERINFERENCE_API_KEY'],
+      doc: 'https://cheaperinference.com',
+      keyless: false,
+      passthrough: false,
+      models: {},
+    },
+    {
+      id: 'theb',
+      name: 'TheB.AI',
+      api: 'https://api.theb.ai/v1',
+      env: ['THEB_API_KEY'],
+      doc: 'https://theb.ai',
+      keyless: false,
+      passthrough: false,
+      models: {},
+    },
+    {
+      id: 'ollama',
+      name: 'Ollama (local)',
+      api: 'http://127.0.0.1:11434/v1',
+      baseURLEnv: ['OLLAMA_BASE_URL', 'OLLAMA_HOST'],
+      env: [],
+      doc: 'https://ollama.com',
+      keyless: true,
+      passthrough: true,
+      models: {},
+    },
+    {
+      id: 'vllm',
+      name: 'vLLM (local)',
+      api: 'http://127.0.0.1:8000/v1',
+      baseURLEnv: ['VLLM_BASE_URL'],
+      env: ['VLLM_API_KEY'],
+      doc: 'https://docs.vllm.ai',
+      keyless: true,
+      passthrough: true,
+      models: {},
+    },
+    {
+      id: 'llamacpp',
+      name: 'llama.cpp server (local)',
+      api: 'http://127.0.0.1:8080/v1',
+      baseURLEnv: ['LLAMACPP_BASE_URL'],
+      env: ['LLAMACPP_API_KEY'],
+      doc: 'https://github.com/ggml-org/llama.cpp',
+      keyless: true,
+      passthrough: true,
+      models: {},
+    },
+    {
+      id: 'omniroute',
+      name: 'OmniRoute (local)',
+      api: 'http://localhost:20128/v1',
+      baseURLEnv: ['OMNIROUTE_BASE_URL'],
+      env: ['OMNIROUTE_API_KEY'],
+      doc: 'https://github.com/xtekky/gpt4free',
+      keyless: true,
+      passthrough: true,
+      models: {},
+    },
+  ];
+
+  /** Alternative spellings accepted in `--model`. */
+  export const ALIASES: Record<string, string> = {
+    g4f: 'gpt4free',
+    'gpt-4-free': 'gpt4free',
+    'llama.cpp': 'llamacpp',
+  };
+
+  /** Catalogue entries we did not add but treat as local/keyless. */
+  const EXTRA_KEYLESS = new Set(['lmstudio']);
+  const EXTRA_PASSTHROUGH = new Set(['lmstudio']);
+
+  /**
+   * models.dev packages that do not load with the bundled AI SDK major
+   * version, mapped to their OpenAI-compatible endpoint.
+   */
+  export const NPM_FALLBACKS: Record<string, { npm: string; api: string }> = {
+    'venice-ai-sdk-provider': {
+      npm: '@ai-sdk/openai-compatible',
+      api: 'https://api.venice.ai/api/v1',
+    },
+    '@aihubmix/ai-sdk-provider': {
+      npm: '@ai-sdk/openai-compatible',
+      api: 'https://aihubmix.com/v1',
+    },
+  };
+
+  const byID = new Map(DEFINITIONS.map((item) => [item.id, item]));
+
+  export function canonicalID(providerID: string): string {
+    return ALIASES[providerID] ?? providerID;
+  }
+
+  export function get(providerID: string): Definition | undefined {
+    return byID.get(canonicalID(providerID));
+  }
+
+  export function isKeyless(providerID: string): boolean {
+    const id = canonicalID(providerID);
+    return Boolean(byID.get(id)?.keyless) || EXTRA_KEYLESS.has(id);
+  }
+
+  export function allowsUnknownModels(providerID: string): boolean {
+    const id = canonicalID(providerID);
+    return Boolean(byID.get(id)?.passthrough) || EXTRA_PASSTHROUGH.has(id);
+  }
+
+  function normalizeBaseURL(id: string, value: string): string {
+    let url = value.trim().replace(/\/+$/, '');
+    if (!/^[a-z]+:\/\//i.test(url)) url = `http://${url}`;
+    // OLLAMA_HOST and similar point at the server root, not the API path.
+    if (id === 'ollama' && !/\/v1$/.test(url)) url = `${url}/v1`;
+    return url;
+  }
+
+  /**
+   * Base URL for a definition. `G4F_PROVIDER` pins gpt4free to one of its
+   * providers through the `/api/{provider}` route of the Interference API.
+   */
+  export function baseURL(
+    definition: Definition,
+    env: Record<string, string | undefined> = process.env
+  ): string {
+    const fromEnv = definition.baseURLEnv
+      ?.map((name) => env[name])
+      .find((value) => value && value.trim());
+    let url = fromEnv
+      ? normalizeBaseURL(definition.id, fromEnv)
+      : definition.api;
+    const pinned = env['G4F_PROVIDER']?.trim();
+    if (
+      pinned &&
+      (definition.id === 'gpt4free' || definition.id === 'g4f-space')
+    ) {
+      url = `${url.replace(/\/v1$/, '')}/api/${encodeURIComponent(pinned)}`;
+    }
+    return url;
+  }
+
+  export function toProvider(
+    definition: Definition,
+    env: Record<string, string | undefined> = process.env
+  ): ModelsDev.Provider {
+    return {
+      id: definition.id,
+      name: definition.name,
+      api: baseURL(definition, env),
+      npm: '@ai-sdk/openai-compatible',
+      env: definition.env,
+      doc: definition.doc,
+      models: structuredClone(definition.models),
+    };
+  }
+
+  /**
+   * Add the missing providers and patch catalogue entries the bundled SDKs
+   * cannot load. Mutates and returns `database`.
+   */
+  export function augment(
+    database: Record<string, ModelsDev.Provider>,
+    env: Record<string, string | undefined> = process.env
+  ): Record<string, ModelsDev.Provider> {
+    for (const definition of DEFINITIONS) {
+      if (database[definition.id]) continue;
+      database[definition.id] = toProvider(definition, env);
+    }
+
+    for (const provider of Object.values(database)) {
+      const fallback = provider.npm ? NPM_FALLBACKS[provider.npm] : undefined;
+      if (!fallback) continue;
+      provider.npm = fallback.npm;
+      provider.api = provider.api ?? fallback.api;
+    }
+
+    const lmstudio = database['lmstudio'];
+    const lmstudioURL = env['LMSTUDIO_BASE_URL']?.trim();
+    if (lmstudio && lmstudioURL) {
+      lmstudio.api = normalizeBaseURL('lmstudio', lmstudioURL);
+    }
+    return database;
+  }
+}

package/src/provider/kilo.ts

@@ -46,4 +46,23 @@ export namespace Kilo {
       65536
     ),
   };
+
+  /**
+   * Text models models.dev lists for Kilo. Their IDs are the same on the
+   * OpenRouter-compatible route this provider uses, so the curated aliases
+   * above only add short names for the free Nemotron models (#334).
+   */
+  export function catalogueModels(
+    provider: ModelsDev.Provider | undefined
+  ): Record<string, ModelsDev.Model> {
+    const result: Record<string, ModelsDev.Model> = {};
+    for (const [key, model] of Object.entries(provider?.models ?? {})) {
+      const output = model.modalities?.output ?? ['text'];
+      if (!output.includes('text')) continue;
+      // The catalogue points at the gateway route; ours is fixed.
+      const { provider: _route, ...rest } = model;
+      result[key] = structuredClone(rest);
+    }
+    return result;
+  }
 }