@link-assistant/agent 0.26.15 → 0.27.1

package/src/project/project.ts

@@ -45,7 +45,12 @@ export namespace Project {
     }
     let worktree = path.dirname(git);
     const timer = log.time('git.rev-parse');
-    let id = await Bun.file(path.join(git, 'opencode'))
+    // In a git worktree or submodule `.git` is a file, so the id cache lives in
+    // the common git directory instead (as upstream does). Writing to
+    // `.git/opencode` there used to reject with ENOTDIR; the rejection was not
+    // handled and the CLI exited with an UnhandledRejection (issue #335).
+    const cacheDir = await gitCacheDir(git, worktree);
+    let id = await Bun.file(path.join(cacheDir, 'opencode'))
       .text()
       .then((x) => x.trim())
       .catch(() => {});
@@ -63,7 +68,16 @@ export namespace Project {
             .toSorted()
         );
       id = roots[0];
-      if (id) Bun.file(path.join(git, 'opencode')).write(id);
+      // The cache is best effort: a read-only or unusual `.git` must not fail
+      // project detection.
+      if (id)
+        await Bun.write(path.join(cacheDir, 'opencode'), id).catch((error) =>
+          log.info(() => ({
+            message: 'project id cache not written',
+            path: path.join(cacheDir, 'opencode'),
+            error: String(error),
+          }))
+        );
     }
     timer.stop();
     if (!id) {
@@ -95,6 +109,25 @@ export namespace Project {
     return project;
   }
 
+  /**
+   * Directory that holds the project id cache: `.git` itself when it is a
+   * directory, otherwise the common git directory reported by git (worktrees
+   * and submodules have a `.git` file pointing elsewhere).
+   */
+  async function gitCacheDir(git: string, worktree: string): Promise<string> {
+    const stat = await fs.stat(git).catch(() => undefined);
+    if (stat?.isDirectory()) return git;
+    const common =
+      await $`git rev-parse --path-format=absolute --git-common-dir`
+        .quiet()
+        .nothrow()
+        .cwd(worktree)
+        .text()
+        .then((x) => x.trim())
+        .catch(() => '');
+    return common || git;
+  }
+
   export async function setInitialized(projectID: string) {
     await Storage.update<Info>(['project', projectID], (draft) => {
       draft.time.initialized = Date.now();

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/free-tier-error.ts

@@ -13,4 +13,4 @@ export function isFreeTierError(
 }
 
 export const FREE_TIER_ERROR_MESSAGE =
-  "OpenCode Zen's free tier is limited to OpenCode clients. Use kilo/nemotron-3-super-free (authenticate with agent auth login or KILO_API_KEY), or select a paid model.";
+  "OpenCode Zen's free tier is limited to OpenCode clients. Use kilo/nemotron-3-ultra-free (authenticate with agent auth login or KILO_API_KEY), or select a paid model.";

package/src/provider/kilo-deprecation.ts

@@ -0,0 +1,30 @@
+import { Log } from '../util/log';
+import { Kilo } from './kilo';
+
+const log = Log.create({ service: 'kilo' });
+
+// Aliases already warned about. A stored session or config that names an
+// alias reaches getModel()/parseModel() many times in one process, so warn
+// once per alias; the set is bounded by `Kilo.DEPRECATED_ALIASES`.
+const warned = new Set<string>();
+
+/**
+ * Map a deprecated Kilo alias (`Kilo.DEPRECATED_ALIASES`) to its replacement
+ * and warn about it (once per alias and process); any other model ID is
+ * returned unchanged (#335).
+ *
+ * Kept out of `kilo.ts` so that module has no runtime dependencies.
+ */
+export function resolveKiloDeprecatedAlias(modelID: string): string {
+  const replacement = Kilo.deprecatedAliasTarget(modelID);
+  if (!replacement) return modelID;
+  if (warned.has(modelID)) return replacement;
+  warned.add(modelID);
+  log.warn(() => ({
+    message: `kilo/${modelID} is deprecated and no longer served by Kilo; using kilo/${replacement} instead`,
+    deprecatedModel: `kilo/${modelID}`,
+    replacement: `kilo/${replacement}`,
+    hint: `Pass --model kilo/${replacement} to silence this warning`,
+  }));
+  return replacement;
+}

package/src/provider/kilo.ts

@@ -25,14 +25,7 @@ export namespace Kilo {
     };
   }
 
-  // Super's output cap is deliberately conservative for existing integrations.
   export const FREE_MODELS: Record<string, ModelsDev.Model> = {
-    'nemotron-3-super-free': freeModel(
-      'nvidia/nemotron-3-super-120b-a12b:free',
-      'Nemotron 3 Super (Free)',
-      262144,
-      32768
-    ),
     'nemotron-3-ultra-free': freeModel(
       'nvidia/nemotron-3-ultra-550b-a55b:free',
       'Nemotron 3 Ultra (Free)',
@@ -46,4 +39,48 @@ export namespace Kilo {
       65536
     ),
   };
+
+  /**
+   * Withdrawn built-in aliases that keep working temporarily. Each one maps to
+   * the served alias in `FREE_MODELS` that replaces it, and every resolution
+   * logs a warning naming the replacement. These are not catalog entries, so
+   * the drift check (`scripts/check-model-drift.mjs`) does not look them up.
+   *
+   * Kilo stopped serving `nvidia/nemotron-3-super-120b-a12b:free`; only the
+   * paid Super model remains on the gateway (#335).
+   */
+  export const DEPRECATED_ALIASES: Readonly<Record<string, string>> = {
+    'nemotron-3-super-free': 'nemotron-3-ultra-free',
+  };
+
+  /**
+   * Replacement for a deprecated alias, or `undefined`. Logs nothing; use
+   * `resolveKiloDeprecatedAlias` from `./kilo-deprecation` to also warn.
+   * This module stays free of runtime dependencies because
+   * `scripts/check-default-models.mjs` imports it without installed packages.
+   */
+  export function deprecatedAliasTarget(modelID: string): string | undefined {
+    return Object.hasOwn(DEPRECATED_ALIASES, modelID)
+      ? DEPRECATED_ALIASES[modelID]
+      : undefined;
+  }
+
+  /**
+   * 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;
+  }
 }