@link-assistant/agent 0.22.8 → 0.22.10

package/README.md

@@ -195,6 +195,9 @@ echo "hi" | agent
 
 # Other free models (in order of recommendation)
 echo "hi" | agent --model opencode/minimax-m2.5-free
+echo "hi" | agent --model opencode/ling-2.6-flash-free
+echo "hi" | agent --model opencode/hy3-preview-free
+echo "hi" | agent --model opencode/nemotron-3-super-free
 echo "hi" | agent --model opencode/gpt-5-nano
 echo "hi" | agent --model opencode/big-pickle
 
@@ -602,13 +605,13 @@ bun run src/index.js
 
 ```bash
 # Run all tests
-bun test
+npm test
 
 # Run specific test file
-bun test tests/mcp.test.js
-bun test tests/websearch.tools.test.js
-bun test tests/batch.tools.test.js
-bun test tests/plaintext.input.test.js
+bun test ./tests/integration/mcp.js
+bun test ./tests/integration/websearch.tools.js
+bun test ./tests/integration/batch.tools.js
+bun test ./tests/integration/plaintext.input.js
 ```
 
 For detailed testing information including how to run tests manually and trigger CI tests, see [TESTING.md](../TESTING.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.22.8",
+  "version": "0.22.10",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",
@@ -9,8 +9,8 @@
   },
   "scripts": {
     "dev": "bun run src/index.js",
-    "test": "bun test tests/*.test.js tests/*.test.ts",
-    "test:integration": "bun test tests/integration/basic.test.js",
+    "test": "bun test ./tests/*.js ./tests/*.ts",
+    "test:integration": "bun test ./tests/integration/basic.js",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "format": "prettier --write .",

package/src/cli/argv.ts

@@ -105,7 +105,7 @@ export function getCompactionSafetyMarginFromProcessArgv(): string | null {
 /**
  * Extract --compaction-models argument directly from process.argv
  * The value is a links notation references sequence, e.g.:
- *   "(big-pickle minimax-m2.5-free nemotron-3-super-free gpt-5-nano same)"
+ *   "(big-pickle minimax-m2.5-free nemotron-3-super-free hy3-preview-free ling-2.6-flash-free gpt-5-nano same)"
  * @returns The compaction models argument from CLI or null if not found
  * @see https://github.com/link-assistant/agent/issues/232
  */

package/src/cli/continuous-mode.js

@@ -51,7 +51,8 @@ const log = Log.create({ service: 'resume' });
 export async function resolveResumeSession(argv, compactJson) {
   const resumeSessionID = argv.resume;
   const shouldContinue = argv.continue === true;
-  const noFork = argv['no-fork'] === true;
+  const noFork =
+    argv['no-fork'] === true || argv.noFork === true || argv.fork === false;
 
   // If neither --resume nor --continue is specified, return null to create new session
   if (!resumeSessionID && !shouldContinue) {

package/src/cli/defaults.ts

@@ -1,62 +1 @@
-/**
- * Default CLI configuration values.
- *
- * Centralizing defaults here ensures all code references the same value (#208).
- * When the default model changes, update this file only.
- */
-
-/** Default model used when no `--model` CLI argument is provided. */
-export const DEFAULT_MODEL = 'opencode/nemotron-3-super-free';
-
-/** Default provider ID extracted from DEFAULT_MODEL. */
-export const DEFAULT_PROVIDER_ID = DEFAULT_MODEL.split('/')[0];
-
-/** Default model ID extracted from DEFAULT_MODEL. */
-export const DEFAULT_MODEL_ID = DEFAULT_MODEL.split('/').slice(1).join('/');
-
-/**
- * Default compaction model used when no `--compaction-model` CLI argument is provided.
- * gpt-5-nano has a 400K context window, larger than most free base models (~200K),
- * which allows compacting 100% of the base model's context without a safety margin.
- * The special value "same" means use the same model as `--model`.
- * @see https://github.com/link-assistant/agent/issues/219
- */
-export const DEFAULT_COMPACTION_MODEL = 'opencode/gpt-5-nano';
-
-/**
- * Default compaction models cascade, ordered from smallest/cheapest context to largest.
- * During compaction, the system tries each model in order. If the used context exceeds
- * a model's context limit, it skips to the next larger model. If a model's rate limit
- * is reached, it also skips to the next model.
- * The special value "same" means use the same model as `--model`.
- *
- * Parsed as links notation references sequence (single anonymous link):
- *   "(big-pickle minimax-m2.5-free nemotron-3-super-free gpt-5-nano same)"
- *
- * Context limits (approximate):
- *   big-pickle:            ~200K
- *   minimax-m2.5-free:     ~200K
- *   nemotron-3-super-free: ~262K (default model)
- *   gpt-5-nano:            ~400K
- *   same:                  (base model's context)
- *
- * Note: qwen3.6-plus-free was removed — free promotion ended April 2026.
- * @see https://github.com/link-assistant/agent/issues/242
- * @see https://github.com/link-assistant/agent/issues/232
- */
-export const DEFAULT_COMPACTION_MODELS =
-  '(big-pickle minimax-m2.5-free nemotron-3-super-free gpt-5-nano same)';
-
-/**
- * Default compaction safety margin as a percentage of usable context window.
- * Applied only when the compaction model has a context window equal to or smaller
- * than the base model. When the compaction model has a larger context, the margin
- * is automatically set to 0 (allowing 100% context usage).
- *
- * Increased from 15% to 25% to reduce probability of context overflow errors,
- * especially when providers return inaccurate or zero token counts.
- * Matches OpenCode upstream's 75% threshold (25% margin).
- * @see https://github.com/link-assistant/agent/issues/219
- * @see https://github.com/link-assistant/agent/issues/249
- */
-export const DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT = 25;
+export * from '../config/defaults.ts';

package/src/cli/model-config.js

@@ -8,9 +8,11 @@ import { Log } from '../util/log.ts';
 import {
   DEFAULT_PROVIDER_ID,
   DEFAULT_MODEL_ID,
-  DEFAULT_COMPACTION_MODEL,
-  DEFAULT_COMPACTION_MODELS,
-  DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT,
+  getDefaultModel,
+  getDefaultModelParts,
+  getDefaultCompactionModel,
+  getDefaultCompactionModels,
+  getDefaultCompactionSafetyMarginPercent,
 } from './defaults.ts';
 
 /**
@@ -20,12 +22,21 @@ import {
  * @param {function} outputStatus - Function to output status messages
  * @returns {Promise<{providerID: string, modelID: string}>}
  */
-export async function parseModelConfig(argv, outputError, outputStatus) {
+export async function parseModelConfig(
+  argv,
+  outputError,
+  outputStatus,
+  defaultOptions = {}
+) {
+  const defaultModel = getDefaultModel(defaultOptions);
+  const { providerID: defaultProviderID, modelID: defaultModelID } =
+    getDefaultModelParts(defaultOptions);
+
   // Safeguard: validate argv.model against process.argv to detect yargs/cache mismatch (#192, #196, #239)
   // This is critical because yargs under Bun may fail to parse --model correctly,
   // returning the default value instead of the user's CLI argument.
   const cliModelArg = getModelFromProcessArgv();
-  let modelArg = argv.model;
+  let modelArg = argv.model ?? defaultModel;
 
   // Diagnostic logging: always log raw argv sources when debugging model resolution (#239)
   // Bun global installs may have different process.argv structure (oven-sh/bun#22157)
@@ -54,7 +65,7 @@ export async function parseModelConfig(argv, outputError, outputStatus) {
     // Always use CLI value when available, even if it matches yargs
     // This ensures we use the actual CLI argument, not a cached/default yargs value
     modelArg = cliModelArg;
-  } else if (modelArg === `${DEFAULT_PROVIDER_ID}/${DEFAULT_MODEL_ID}`) {
+  } else if (modelArg === defaultModel) {
     // cliModelArg is null AND yargs returned the default — check if process.argv
     // actually contains --model to detect silent yargs/Bun mismatch (#239)
     const rawArgvStr = process.argv.join(' ');
@@ -74,7 +85,7 @@ export async function parseModelConfig(argv, outputError, outputStatus) {
           typeof globalThis.Bun !== 'undefined' && globalThis.Bun.argv
             ? globalThis.Bun.argv
             : '(not available)',
-        defaultModel: `${DEFAULT_PROVIDER_ID}/${DEFAULT_MODEL_ID}`,
+        defaultModel,
       }));
     }
   }
@@ -111,38 +122,54 @@ export async function parseModelConfig(argv, outputError, outputStatus) {
     // fail immediately instead of silently falling back to a different model.
     // However, if the model is the default (no --model CLI flag), warn but proceed (#239).
     // The models.dev API may lag behind the provider's actual model availability.
-    const isDefaultModel = !cliModelArg;
+    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]) {
-        const availableModels = Object.keys(provider.info.models).slice(0, 10);
-        if (isDefaultModel) {
-          // Default model not in models.dev catalog — warn but proceed (#239)
-          // The provider may still accept it; models.dev can lag behind actual availability.
-          Log.Default.warn(() => ({
+        const liveInfo = await Provider.refreshLiveModelInfo(
+          providerID,
+          modelID
+        );
+        if (liveInfo) {
+          Log.Default.info(() => ({
             message:
-              'default model not found in models.dev catalog — proceeding anyway',
+              'model not found in models.dev catalog but found in provider live endpoint',
             providerID,
             modelID,
-            availableModels,
           }));
         } else {
-          // User explicitly specified provider/model — fail with a clear error (#231)
-          // Silent fallback caused kimi-k2.5-free to be routed to minimax-m2.5-free
-          Log.Default.error(() => ({
-            message:
-              'model not found in provider — refusing to proceed with explicit provider/model',
-            providerID,
-            modelID,
-            availableModels,
-          }));
-          throw new Error(
-            `Model "${modelID}" not found in provider "${providerID}". ` +
-              `Available models include: ${availableModels.join(', ')}. ` +
-              `Use --model ${providerID}/<model-id> with a valid model, or omit the provider prefix for auto-resolution.`
+          const availableModels = Object.keys(provider.info.models).slice(
+            0,
+            10
           );
+          if (isDefaultModel) {
+            // Default model not in models.dev catalog — warn but proceed (#239)
+            // The provider may still accept it; models.dev can lag behind actual availability.
+            Log.Default.warn(() => ({
+              message:
+                'default model not found in models.dev catalog — proceeding anyway',
+              providerID,
+              modelID,
+              availableModels,
+            }));
+          } else {
+            // User explicitly specified provider/model — fail with a clear error (#231)
+            // Silent fallback caused kimi-k2.5-free to be routed to minimax-m2.5-free
+            Log.Default.error(() => ({
+              message:
+                'model not found in provider — refusing to proceed with explicit provider/model',
+              providerID,
+              modelID,
+              availableModels,
+            }));
+            throw new Error(
+              `Model "${modelID}" not found in provider "${providerID}". ` +
+                `Available models include: ${availableModels.join(', ')}. ` +
+                `Use --model ${providerID}/<model-id> with a valid model, or omit the provider prefix for auto-resolution.`
+            );
+          }
         }
       }
     } catch (validationError) {
@@ -177,7 +204,8 @@ export async function parseModelConfig(argv, outputError, outputStatus) {
   const compactionModelResult = await parseCompactionModelConfig(
     argv,
     providerID,
-    modelID
+    modelID,
+    defaultOptions
   );
 
   // Handle --use-existing-claude-oauth option
@@ -206,7 +234,7 @@ export async function parseModelConfig(argv, outputError, outputStatus) {
 
     // If user specified the default model (DEFAULT_MODEL), switch to claude-oauth
     // If user explicitly specified kilo or another provider, warn but respect their choice
-    if (providerID === DEFAULT_PROVIDER_ID && modelID === DEFAULT_MODEL_ID) {
+    if (providerID === defaultProviderID && modelID === defaultModelID) {
       providerID = 'claude-oauth';
       modelID = 'claude-sonnet-4-5';
     } else if (!['claude-oauth', 'anthropic'].includes(providerID)) {
@@ -290,20 +318,28 @@ async function resolveCompactionModelEntry(
  * @see https://github.com/link-assistant/agent/issues/219
  * @see https://github.com/link-assistant/agent/issues/232
  */
-async function parseCompactionModelConfig(argv, baseProviderID, baseModelID) {
+async function parseCompactionModelConfig(
+  argv,
+  baseProviderID,
+  baseModelID,
+  defaultOptions = {}
+) {
+  const defaultCompactionSafetyMarginPercent =
+    getDefaultCompactionSafetyMarginPercent(defaultOptions);
+
   // Get safety margin from CLI
   const cliSafetyMarginArg = getCompactionSafetyMarginFromProcessArgv();
   const compactionSafetyMarginPercent = cliSafetyMarginArg
     ? parseInt(cliSafetyMarginArg, 10)
     : (argv['compaction-safety-margin'] ??
-      DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT);
+      defaultCompactionSafetyMarginPercent);
 
   // Check for --compaction-models (cascade) first — it overrides --compaction-model
   const cliCompactionModelsArg = getCompactionModelsFromProcessArgv();
   const compactionModelsArg =
     cliCompactionModelsArg ??
     argv['compaction-models'] ??
-    DEFAULT_COMPACTION_MODELS;
+    getDefaultCompactionModels(defaultOptions);
 
   // Parse the links notation sequence into an array of model names
   const modelNames = parseLinksNotationSequence(compactionModelsArg);
@@ -363,7 +399,7 @@ async function parseCompactionModelConfig(argv, baseProviderID, baseModelID) {
   const compactionModelArg =
     cliCompactionModelArg ??
     argv['compaction-model'] ??
-    DEFAULT_COMPACTION_MODEL;
+    getDefaultCompactionModel(defaultOptions);
 
   const resolved = await resolveCompactionModelEntry(
     compactionModelArg,

package/src/cli/run-options.js

@@ -1,20 +1,26 @@
 import {
-  DEFAULT_MODEL,
-  DEFAULT_COMPACTION_MODEL,
-  DEFAULT_COMPACTION_MODELS,
-  DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT,
+  getDefaultModel,
+  getDefaultCompactionModel,
+  getDefaultCompactionModels,
+  getDefaultCompactionSafetyMarginPercent,
 } from './defaults.ts';
 
 /**
  * Yargs builder for the default `run` command options.
  * Extracted from index.js to keep file size under 1000 lines.
  */
-export function buildRunOptions(yargs) {
-  return yargs
+export function buildRunOptions(yargs, defaultOptions = {}) {
+  const defaultModel = getDefaultModel(defaultOptions);
+  const defaultCompactionModel = getDefaultCompactionModel(defaultOptions);
+  const defaultCompactionModels = getDefaultCompactionModels(defaultOptions);
+  const defaultCompactionSafetyMarginPercent =
+    getDefaultCompactionSafetyMarginPercent(defaultOptions);
+
+  const parser = yargs
     .option('model', {
       type: 'string',
       description: 'Model to use in format providerID/modelID',
-      default: DEFAULT_MODEL,
+      default: defaultModel,
     })
     .option('json-standard', {
       type: 'string',
@@ -120,7 +126,19 @@ export function buildRunOptions(yargs) {
       description:
         'When used with --resume or --continue, continue in the same session without forking to a new UUID.',
       default: false,
-    })
+    });
+
+  const normalizedParser =
+    typeof parser.middleware === 'function'
+      ? parser.middleware((argv) => {
+          if (argv.fork === false) {
+            argv['no-fork'] = true;
+            argv.noFork = true;
+          }
+        }, true)
+      : parser;
+
+  return normalizedParser
     .option('generate-title', {
       type: 'boolean',
       description:
@@ -153,7 +171,7 @@ export function buildRunOptions(yargs) {
       type: 'string',
       description:
         'Model to use for context compaction in format providerID/modelID. Use "same" to use the base model. Default: opencode/gpt-5-nano (free, 400K context). Overridden by --compaction-models if both are specified.',
-      default: DEFAULT_COMPACTION_MODEL,
+      default: defaultCompactionModel,
     })
     .option('compaction-models', {
       type: 'string',
@@ -161,13 +179,13 @@ export function buildRunOptions(yargs) {
         'Ordered cascade of compaction models in links notation sequence format: "(model1 model2 ... same)". ' +
         "Models are tried from smallest/cheapest context to largest. If used context exceeds a model's limit or its rate limit is reached, the next model is tried. " +
         'The special value "same" uses the base model. Overrides --compaction-model when specified.',
-      default: DEFAULT_COMPACTION_MODELS,
+      default: defaultCompactionModels,
     })
     .option('compaction-safety-margin', {
       type: 'number',
       description:
-        'Safety margin (%) of usable context window before triggering compaction. Only applies when the compaction model has equal or smaller context than the base model. Default: 15.',
-      default: DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT,
+        'Safety margin (%) of usable context window before triggering compaction. Only applies when the compaction model has equal or smaller context than the base model. Default: 25.',
+      default: defaultCompactionSafetyMarginPercent,
     })
     .option('temperature', {
       type: 'number',

package/src/config/defaults.ts

@@ -0,0 +1,170 @@
+/**
+ * Global default model configuration shared by runtime code and tests.
+ *
+ * Keep the hard-coded defaults here. Runtime helpers allow test runs and
+ * local automation to override those defaults without editing source files.
+ */
+
+type EnvLike = Record<string, string | undefined>;
+
+export interface DefaultConfigOptions {
+  env?: EnvLike;
+  defaultModel?: string | null;
+  defaultCompactionModel?: string | null;
+  defaultCompactionModels?: string | null;
+  defaultCompactionSafetyMarginPercent?: number | string | null;
+}
+
+/** Default model used when no `--model` CLI argument is provided. */
+export const DEFAULT_MODEL = 'opencode/minimax-m2.5-free';
+
+/** Env var for overriding the default model in test runs and automation. */
+export const DEFAULT_MODEL_ENV = 'LINK_ASSISTANT_AGENT_DEFAULT_MODEL';
+
+/** Default compaction model used when no `--compaction-model` CLI argument is provided. */
+export const DEFAULT_COMPACTION_MODEL = 'opencode/gpt-5-nano';
+
+/** Env var for overriding the default compaction model in test runs and automation. */
+export const DEFAULT_COMPACTION_MODEL_ENV =
+  'LINK_ASSISTANT_AGENT_DEFAULT_COMPACTION_MODEL';
+
+/**
+ * Default compaction models cascade, ordered from smallest/cheapest context to largest.
+ * During compaction, the system tries each model in order. If the used context exceeds
+ * a model's context limit, it skips to the next larger model. If a model's rate limit
+ * is reached, it also skips to the next model.
+ * The special value "same" means use the same model as `--model`.
+ *
+ * Parsed as links notation references sequence (single anonymous link):
+ *   "(big-pickle minimax-m2.5-free nemotron-3-super-free hy3-preview-free ling-2.6-flash-free gpt-5-nano same)"
+ *
+ * Context limits (approximate):
+ *   big-pickle:             ~200K
+ *   minimax-m2.5-free:      ~204K
+ *   nemotron-3-super-free:  ~204K
+ *   hy3-preview-free:       ~256K
+ *   ling-2.6-flash-free:    ~262K
+ *   gpt-5-nano:             ~400K
+ *   same:                   (base model's context)
+ *
+ * Note: qwen3.6-plus-free was removed because the free promotion ended in April 2026.
+ * Note: minimax-m2.5-free is the default model again as of issue #266.
+ * @see https://github.com/link-assistant/agent/issues/266
+ * @see https://github.com/link-assistant/agent/issues/242
+ * @see https://github.com/link-assistant/agent/issues/232
+ */
+export const DEFAULT_COMPACTION_MODELS =
+  '(big-pickle minimax-m2.5-free nemotron-3-super-free hy3-preview-free ling-2.6-flash-free gpt-5-nano same)';
+
+/** Env var for overriding the default compaction cascade in test runs and automation. */
+export const DEFAULT_COMPACTION_MODELS_ENV =
+  'LINK_ASSISTANT_AGENT_DEFAULT_COMPACTION_MODELS';
+
+/**
+ * Default compaction safety margin as a percentage of usable context window.
+ * Applied only when the compaction model has a context window equal to or smaller
+ * than the base model. When the compaction model has a larger context, the margin
+ * is automatically set to 0 (allowing 100% context usage).
+ *
+ * Increased from 15% to 25% to reduce probability of context overflow errors,
+ * especially when providers return inaccurate or zero token counts.
+ * Matches OpenCode upstream's 75% threshold (25% margin).
+ * @see https://github.com/link-assistant/agent/issues/219
+ * @see https://github.com/link-assistant/agent/issues/249
+ */
+export const DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT = 25;
+
+/** Env var for overriding the default compaction safety margin in test runs and automation. */
+export const DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT_ENV =
+  'LINK_ASSISTANT_AGENT_DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT';
+
+function clean(value: string | null | undefined): string | undefined {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+function optionString(value: string | null | undefined): string | undefined {
+  return clean(value);
+}
+
+function envString(env: EnvLike, key: string): string | undefined {
+  return clean(env[key]);
+}
+
+function optionNumber(
+  value: number | string | null | undefined
+): number | undefined {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value === 'string') {
+    const parsed = Number.parseInt(value.trim(), 10);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return undefined;
+}
+
+/** Resolve the effective default model. CLI `--model` still takes precedence later. */
+export function getDefaultModel(options: DefaultConfigOptions = {}): string {
+  const env = options.env ?? process.env;
+  return (
+    optionString(options.defaultModel) ??
+    envString(env, DEFAULT_MODEL_ENV) ??
+    DEFAULT_MODEL
+  );
+}
+
+export function getDefaultCompactionModel(
+  options: DefaultConfigOptions = {}
+): string {
+  const env = options.env ?? process.env;
+  return (
+    optionString(options.defaultCompactionModel) ??
+    envString(env, DEFAULT_COMPACTION_MODEL_ENV) ??
+    DEFAULT_COMPACTION_MODEL
+  );
+}
+
+export function getDefaultCompactionModels(
+  options: DefaultConfigOptions = {}
+): string {
+  const env = options.env ?? process.env;
+  return (
+    optionString(options.defaultCompactionModels) ??
+    envString(env, DEFAULT_COMPACTION_MODELS_ENV) ??
+    DEFAULT_COMPACTION_MODELS
+  );
+}
+
+export function getDefaultCompactionSafetyMarginPercent(
+  options: DefaultConfigOptions = {}
+): number {
+  const env = options.env ?? process.env;
+  return (
+    optionNumber(options.defaultCompactionSafetyMarginPercent) ??
+    optionNumber(env[DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT_ENV]) ??
+    DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT
+  );
+}
+
+export function parseModelParts(model: string): {
+  providerID: string;
+  modelID: string;
+} {
+  const [providerID, ...modelParts] = model.split('/');
+  return {
+    providerID,
+    modelID: modelParts.join('/'),
+  };
+}
+
+export function getDefaultModelParts(options: DefaultConfigOptions = {}): {
+  providerID: string;
+  modelID: string;
+} {
+  return parseModelParts(getDefaultModel(options));
+}
+
+/** Default provider ID extracted from DEFAULT_MODEL. */
+export const DEFAULT_PROVIDER_ID = parseModelParts(DEFAULT_MODEL).providerID;
+
+/** Default model ID extracted from DEFAULT_MODEL. */
+export const DEFAULT_MODEL_ID = parseModelParts(DEFAULT_MODEL).modelID;

package/src/index.js

@@ -488,7 +488,7 @@ async function runServerMode(
       });
     unsub = eventUnsub;
 
-    // Send message to session with specified model (default: opencode/grok-code)
+    // Send message to session with specified model
     const message = request.message || 'hi';
     const parts = [{ type: 'text', text: message }];
 

package/src/provider/opencode-zen.ts

@@ -0,0 +1,138 @@
+import { Log } from '../util/log';
+import type { ModelsDev } from './models';
+
+export namespace OpenCodeZen {
+  const log = Log.create({ service: 'opencode-zen' });
+  const MODELS_URL = 'https://opencode.ai/zen/v1/models';
+  const DEPRECATED_FREE_MODEL_IDS = new Set(['trinity-large-preview-free']);
+
+  const FREE_MODEL_OVERRIDES: Record<
+    string,
+    Partial<ModelsDev.Model> & { name: string }
+  > = {
+    'minimax-m2.5-free': {
+      name: 'MiniMax M2.5 Free',
+      reasoning: true,
+      release_date: '2026-02-12',
+      limit: { context: 204800, output: 131072 },
+      provider: { npm: '@ai-sdk/openai-compatible' },
+    },
+    'ling-2.6-flash-free': {
+      name: 'Ling 2.6 Flash Free',
+      reasoning: false,
+      release_date: '2026-04-21',
+      limit: { context: 262100, output: 32800 },
+      provider: { npm: '@ai-sdk/openai-compatible' },
+    },
+    'hy3-preview-free': {
+      name: 'Hy3 Preview Free',
+      reasoning: true,
+      release_date: '2026-04-20',
+      limit: { context: 256000, output: 64000 },
+      provider: { npm: '@ai-sdk/openai-compatible' },
+    },
+    'nemotron-3-super-free': {
+      name: 'Nemotron 3 Super Free',
+      reasoning: true,
+      release_date: '2026-03-11',
+      limit: { context: 204800, output: 128000 },
+      provider: { npm: '@ai-sdk/openai-compatible' },
+    },
+    'gpt-5-nano': {
+      name: 'GPT-5 Nano',
+      attachment: true,
+      reasoning: true,
+      temperature: false,
+      release_date: '2025-08-07',
+      limit: { context: 400000, output: 128000 },
+      provider: { npm: '@ai-sdk/openai' },
+    },
+    'big-pickle': {
+      name: 'Big Pickle',
+      reasoning: true,
+      release_date: '2025-10-17',
+      limit: { context: 200000, output: 128000 },
+      provider: { npm: '@ai-sdk/openai-compatible' },
+    },
+  };
+
+  function displayName(modelID: string) {
+    return modelID
+      .replace(/:free$/, '')
+      .replace(/-free$/, ' Free')
+      .split(/[-/]/)
+      .filter(Boolean)
+      .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+      .join(' ');
+  }
+
+  function isFreeModelID(modelID: string) {
+    if (DEPRECATED_FREE_MODEL_IDS.has(modelID)) return false;
+    return (
+      modelID.endsWith('-free') ||
+      modelID === 'gpt-5-nano' ||
+      modelID === 'big-pickle'
+    );
+  }
+
+  export async function fetchModelIDs(fetchFn: typeof fetch = fetch) {
+    const response = await fetchFn(MODELS_URL, {
+      headers: { 'User-Agent': 'agent-cli/1.0.0' },
+      signal: AbortSignal.timeout(10_000),
+    });
+    if (!response.ok) {
+      log.warn(() => ({
+        message: 'OpenCode Zen models endpoint returned non-OK response',
+        status: response.status,
+        statusText: response.statusText,
+      }));
+      return new Set<string>();
+    }
+
+    const body = (await response.json().catch(() => undefined)) as
+      | { data?: Array<{ id?: unknown }> }
+      | undefined;
+    const rows = Array.isArray(body?.data) ? body.data : [];
+    return new Set(
+      rows
+        .map((row) => (typeof row.id === 'string' ? row.id : undefined))
+        .filter((id): id is string => Boolean(id))
+    );
+  }
+
+  export async function getLiveFreeModelInfo(
+    modelID: string,
+    fetchFn: typeof fetch = fetch
+  ): Promise<ModelsDev.Model | undefined> {
+    if (!isFreeModelID(modelID)) return undefined;
+
+    const ids = await fetchModelIDs(fetchFn).catch((error) => {
+      log.warn(() => ({
+        message: 'failed to fetch OpenCode Zen live model list',
+        modelID,
+        error: error instanceof Error ? error.message : String(error),
+      }));
+      return new Set<string>();
+    });
+    if (!ids.has(modelID)) return undefined;
+
+    const overrides = FREE_MODEL_OVERRIDES[modelID];
+    return {
+      id: modelID,
+      name: overrides?.name ?? displayName(modelID),
+      release_date: overrides?.release_date ?? '',
+      attachment: overrides?.attachment ?? false,
+      reasoning: overrides?.reasoning ?? modelID.includes('reasoning'),
+      temperature: overrides?.temperature ?? true,
+      tool_call: overrides?.tool_call ?? true,
+      cost: overrides?.cost ?? { input: 0, output: 0, cache_read: 0 },
+      limit: overrides?.limit ?? { context: 128000, output: 16384 },
+      modalities: overrides?.modalities ?? {
+        input: ['text'],
+        output: ['text'],
+      },
+      options: overrides?.options ?? {},
+      provider: overrides?.provider ?? { npm: '@ai-sdk/openai-compatible' },
+    };
+  }
+}

package/src/provider/provider.ts

@@ -13,11 +13,13 @@ import { AuthPlugins } from '../auth/plugins';
 import { Instance } from '../project/instance';
 import { Global } from '../global';
 import { config, isVerbose } from '../config/config';
+import { getDefaultModel, getDefaultModelParts } from '../config/defaults';
 import { iife } from '../util/iife';
 import { createEchoModel } from './echo';
 import { createCacheModel } from './cache';
 import { RetryFetch } from './retry-fetch';
 import { SSEUsageExtractor } from '../util/sse-usage-extractor';
+import { OpenCodeZen } from './opencode-zen';
 
 // Direct imports for bundled providers - these are pre-installed to avoid runtime installation hangs
 // @see https://github.com/link-assistant/agent/issues/173
@@ -1596,6 +1598,31 @@ export namespace Provider {
     return state().then((s) => s.providers[providerID]);
   }
 
+  async function getLiveModelInfo(providerID: string, modelID: string) {
+    if (providerID !== 'opencode') return undefined;
+    return OpenCodeZen.getLiveFreeModelInfo(modelID);
+  }
+
+  export async function refreshLiveModelInfo(
+    providerID: string,
+    modelID: string
+  ) {
+    const info = await getLiveModelInfo(providerID, modelID);
+    if (!info) return undefined;
+
+    const s = await state();
+    const provider = s.providers[providerID];
+    if (provider) {
+      provider.info.models[modelID] = info;
+      log.info(() => ({
+        message: 'model found in provider live model endpoint',
+        providerID,
+        modelID,
+      }));
+    }
+    return info;
+  }
+
   export async function getModel(providerID: string, modelID: string) {
     const key = `${providerID}/${modelID}`;
     const s = await state();
@@ -1662,15 +1689,28 @@ export namespace Provider {
       }
     }
 
+    if (!isSyntheticProvider && !info) {
+      const liveInfo = await getLiveModelInfo(providerID, modelID);
+      if (liveInfo) {
+        provider.info.models[modelID] = liveInfo;
+        info = liveInfo;
+        log.info(() => ({
+          message: 'model found in provider live model endpoint',
+          providerID,
+          modelID,
+        }));
+      }
+    }
+
     if (!isSyntheticProvider && !info) {
       // Model not found even after cache refresh.
       // Check if this is the default model — if so, create synthetic info and proceed (#239).
       // The models.dev API can lag behind the provider's actual model availability.
       // For user-specified models, fail with a clear error (#231) to prevent silent substitution.
-      const { DEFAULT_PROVIDER_ID, DEFAULT_MODEL_ID } =
-        await import('../cli/defaults.ts');
+      const { providerID: defaultProviderID, modelID: defaultModelID } =
+        getDefaultModelParts();
       const isDefaultModel =
-        providerID === DEFAULT_PROVIDER_ID && modelID === DEFAULT_MODEL_ID;
+        providerID === defaultProviderID && modelID === defaultModelID;
       const availableInProvider = Object.keys(provider.info.models).slice(
         0,
         10
@@ -1793,8 +1833,10 @@ export namespace Provider {
     }
     if (providerID === 'opencode' || providerID === 'local') {
       priority = [
-        'nemotron-3-super-free',
         'minimax-m2.5-free',
+        'ling-2.6-flash-free',
+        'hy3-preview-free',
+        'nemotron-3-super-free',
         'gpt-5-nano',
         'big-pickle',
       ];
@@ -1824,11 +1866,13 @@ export namespace Provider {
   }
 
   const priority = [
+    'big-pickle',
+    'gpt-5-nano',
     'nemotron-3-super-free',
-    'glm-5-free',
+    'hy3-preview-free',
+    'ling-2.6-flash-free',
     'minimax-m2.5-free',
-    'gpt-5-nano',
-    'big-pickle',
+    'glm-5-free',
     'gpt-5',
     'claude-sonnet-4',
     'gemini-3-pro',
@@ -1861,6 +1905,15 @@ export namespace Provider {
 
     if (cfg.model) return parseModel(cfg.model);
 
+    const configuredDefaultModel = getDefaultModel();
+    if (configuredDefaultModel) {
+      log.info(() => ({
+        message: 'using configured default model',
+        model: configuredDefaultModel,
+      }));
+      return parseModel(configuredDefaultModel);
+    }
+
     // Prefer opencode provider if available
     const providers = await list().then((val) => Object.values(val));
     const opencodeProvider = providers.find((p) => p.info.id === 'opencode');
@@ -1907,8 +1960,8 @@ 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.5-air-free, minimax-m2.5-free, giga-potato-free, deepseek-r1-free (unique to Kilo)
-   *    - opencode: big-pickle, gpt-5-nano, nemotron-3-super-free (unique to OpenCode)
+   *    - kilo: glm-5-free, glm-4.5-air-free, giga-potato-free, deepseek-r1-free (unique to Kilo)
+   *    - opencode: minimax-m2.5-free, ling-2.6-flash-free, hy3-preview-free, big-pickle, gpt-5-nano, nemotron-3-super-free
    * 3. For shared models, prefer OpenCode first, then fall back to Kilo on rate limit
    *
    * @param modelID - Short model name without provider prefix
@@ -1924,7 +1977,6 @@ export namespace Provider {
     const kiloUniqueModels = [
       'glm-5-free',
       'glm-4.5-air-free',
-      'minimax-m2.5-free',
       'giga-potato-free',
       'trinity-large-preview',
       'deepseek-r1-free',
@@ -2060,8 +2112,7 @@ export namespace Provider {
    * If user specifies "kilo/deepseek-r1-free", no fallback will occur.
    */
   const SHARED_FREE_MODELS: Record<string, string[]> = {
-    // Currently no shared models between OpenCode and Kilo providers.
-    // Kilo models use different IDs than OpenCode models.
+    'minimax-m2.5-free': ['opencode', 'kilo'],
   };
 
   /**

package/src/session/message-v2.ts

@@ -849,6 +849,48 @@ export namespace MessageV2 {
     return result;
   }
 
+  function normalizeProviderErrorObject(e: unknown) {
+    if (!e || typeof e !== 'object') return;
+
+    const root = e as Record<string, unknown>;
+    const candidate =
+      root['error'] && typeof root['error'] === 'object'
+        ? (root['error'] as Record<string, unknown>)
+        : root;
+    const rawCode =
+      candidate['code'] ?? candidate['statusCode'] ?? candidate['status'];
+    const statusCode =
+      typeof rawCode === 'number'
+        ? rawCode
+        : typeof rawCode === 'string' && /^\d+$/.test(rawCode)
+          ? Number.parseInt(rawCode, 10)
+          : undefined;
+
+    if (statusCode === undefined) return;
+
+    let responseBody: string | undefined;
+    try {
+      responseBody = JSON.stringify(e);
+    } catch {
+      responseBody = undefined;
+    }
+
+    const message =
+      typeof candidate['message'] === 'string'
+        ? candidate['message']
+        : typeof root['message'] === 'string'
+          ? root['message']
+          : `Provider returned HTTP ${statusCode}`;
+
+    return {
+      message,
+      statusCode,
+      isRetryable:
+        statusCode === 429 || (statusCode >= 500 && statusCode < 600),
+      responseBody,
+    };
+  }
+
   export function fromError(e: unknown, ctx: { providerID: string }) {
     switch (true) {
       case e instanceof DOMException && e.name === 'AbortError':
@@ -884,6 +926,10 @@ export namespace MessageV2 {
           },
           { cause: e }
         ).toObject();
+      case normalizeProviderErrorObject(e) !== undefined: {
+        const providerError = normalizeProviderErrorObject(e)!;
+        return new MessageV2.APIError(providerError, { cause: e }).toObject();
+      }
       case e instanceof Error: {
         const message = e.message || e.toString();
         // Detect Bun socket connection errors (known Bun issue with 10s idle timeout)

package/src/session/processor.ts

@@ -52,6 +52,40 @@ export namespace SessionProcessor {
     }
   }
 
+  /**
+   * Detect AI SDK/provider usage-shape crashes.
+   *
+   * Some provider error streams end before a valid finish-step usage object is
+   * available. Depending on the provider adapter, that can surface as a
+   * TypeError while reading token fields instead of the original provider
+   * error. Treat it as retryable provider failure rather than a generic crash.
+   *
+   * See: https://github.com/link-assistant/agent/issues/264
+   */
+  export function isUsageDataTypeError(error: unknown): boolean {
+    const message =
+      error instanceof Error
+        ? `${error.name}: ${error.message}`
+        : typeof error === 'string'
+          ? error
+          : '';
+
+    if (!(error instanceof TypeError) && !message.startsWith('TypeError:')) {
+      return false;
+    }
+
+    return [
+      'input_tokens',
+      'output_tokens',
+      'usage.inputTokens',
+      'usage.outputTokens',
+      'inputTokens.total',
+      'outputTokens.total',
+      "reading 'inputTokens'",
+      "reading 'outputTokens'",
+    ].some((pattern) => message.includes(pattern));
+  }
+
   export type Info = Awaited<ReturnType<typeof create>>;
   export type Result = Awaited<ReturnType<Info['process']>>;
 
@@ -542,37 +576,34 @@ export namespace SessionProcessor {
           } catch (e) {
             log.error(() => ({ message: 'process', error: e }));
 
-            // Check for AI SDK usage-related TypeError (input_tokens undefined)
-            // This happens when providers return incomplete usage data
-            // See: https://github.com/link-assistant/agent/issues/152
-            if (
-              e instanceof TypeError &&
-              (e.message.includes('input_tokens') ||
-                e.message.includes('output_tokens') ||
-                e.message.includes("reading 'input_tokens'") ||
-                e.message.includes("reading 'output_tokens'"))
-            ) {
+            let error = MessageV2.fromError(e, {
+              providerID: input.providerID,
+            });
+
+            // Check for AI SDK usage-related TypeErrors. These usually come
+            // from provider adapters after malformed/incomplete usage data, so
+            // retry them with normal API-error backoff instead of surfacing a
+            // misleading UnknownError.
+            if (isUsageDataTypeError(e)) {
               log.warn(() => ({
                 message:
-                  'Provider returned invalid usage data, continuing with zero usage',
-                errorMessage: e.message,
+                  'provider returned invalid usage data; retrying as provider API error',
+                errorMessage: e instanceof Error ? e.message : String(e),
                 providerID: input.providerID,
+                issue: 'https://github.com/link-assistant/agent/issues/264',
               }));
-              // Set default token values to prevent crash
-              input.assistantMessage.tokens = {
-                input: 0,
-                output: 0,
-                reasoning: 0,
-                cache: { read: 0, write: 0 },
-              };
-              // Continue processing instead of failing
-              continue;
+              error = new MessageV2.APIError(
+                {
+                  message:
+                    e instanceof Error
+                      ? e.message
+                      : 'Provider returned invalid usage data',
+                  isRetryable: true,
+                },
+                { cause: e }
+              ).toObject();
             }
 
-            const error = MessageV2.fromError(e, {
-              providerID: input.providerID,
-            });
-
             // Check if error is retryable (APIError, SocketConnectionError, TimeoutError)
             const isRetryableAPIError =
               error?.name === 'APIError' && error.data.isRetryable;

package/src/tool/task.ts

@@ -9,7 +9,7 @@ import { Agent } from '../agent/agent';
 import { SessionPrompt } from '../session/prompt';
 import { iife } from '../util/iife';
 import { defer } from '../util/defer';
-import { DEFAULT_PROVIDER_ID, DEFAULT_MODEL_ID } from '../cli/defaults';
+import { getDefaultModelParts } from '../cli/defaults';
 
 export const TaskTool = Tool.define('task', async () => {
   const agents = await Agent.list().then((x) =>
@@ -98,10 +98,11 @@ export const TaskTool = Tool.define('task', async () => {
         });
       });
 
+      const defaultModel = getDefaultModelParts();
       const model = agent.model ??
         parentModel ?? {
-          modelID: DEFAULT_MODEL_ID,
-          providerID: DEFAULT_PROVIDER_ID,
+          modelID: defaultModel.modelID,
+          providerID: defaultModel.providerID,
         };
 
       function cancel() {