@link-assistant/agent 0.26.1 → 0.26.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.26.1",
+  "version": "0.26.3",
   "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/cli/model-config.js

@@ -12,7 +12,9 @@ import {
   getDefaultModelParts,
   getDefaultModelSource,
   getDefaultCompactionModel,
+  getDefaultCompactionModelSource,
   getDefaultCompactionModels,
+  getDefaultCompactionModelsSource,
   getDefaultCompactionSafetyMarginPercent,
 } from './defaults.ts';
 import { outputModelResolved } from './model-resolution.ts';
@@ -356,6 +358,64 @@ async function resolveCompactionModelEntry(
   };
 }
 
+/**
+ * Narrow a built-in compaction default to the provider the run was pointed at.
+ *
+ * The shipped cascade names OpenCode models, because the shipped base model is
+ * an OpenCode one. A run launched with `--model formalai/formal-ai` inherited
+ * that cascade unchanged, so compaction — and the session summary, which reuses
+ * the compaction model — called a provider the operator may hold no credentials
+ * for. Every one of those calls fails, and the failures read as the run having
+ * failed.
+ *
+ * Only the *built-in* defaults are narrowed, and only for a run pointed away
+ * from the built-in default provider. A cascade the operator named
+ * (`--compaction-model`, `--compaction-models`, or the
+ * `LINK_ASSISTANT_AGENT_DEFAULT_COMPACTION_MODEL*` env vars) is an explicit
+ * choice and is left alone, cross-provider or not; and a run on the shipped
+ * provider keeps the shipped cascade, whose extra entries are the rate-limit
+ * fallbacks it was written for.
+ *
+ * @param {{providerID: string, modelID: string, useSameModel: boolean}[]} entries
+ * @param {string} baseProviderID Provider of the model that runs the turns
+ * @param {string} baseModelID Model that runs the turns
+ * @returns {{providerID: string, modelID: string, useSameModel: boolean}[]}
+ * @see https://github.com/link-assistant/agent/issues/307
+ */
+function inheritBaseProvider(entries, baseProviderID, baseModelID) {
+  const kept = entries.filter(
+    (entry) => entry.useSameModel || entry.providerID === baseProviderID
+  );
+  const dropped = entries.filter((entry) => !kept.includes(entry));
+  if (dropped.length === 0) {
+    return entries;
+  }
+
+  const inherited =
+    kept.length > 0
+      ? kept
+      : [
+          {
+            providerID: baseProviderID,
+            modelID: baseModelID,
+            useSameModel: true,
+          },
+        ];
+
+  Log.Default.info(() => ({
+    message: 'default compaction models narrowed to the configured provider',
+    hint: 'Secondary calls (compaction, session summary) inherit --model unless a compaction model is named explicitly',
+    baseProviderID,
+    baseModelID,
+    dropped: dropped.map((entry) => `${entry.providerID}/${entry.modelID}`),
+    kept: inherited.map((entry) =>
+      entry.useSameModel ? 'same' : `${entry.providerID}/${entry.modelID}`
+    ),
+  }));
+
+  return inherited;
+}
+
 /**
  * Parse compaction model config from argv.
  * Supports both --compaction-model (single) and --compaction-models (cascade).
@@ -363,6 +423,7 @@ async function resolveCompactionModelEntry(
  * The special value "same" means use the base model for compaction.
  * @see https://github.com/link-assistant/agent/issues/219
  * @see https://github.com/link-assistant/agent/issues/232
+ * @see https://github.com/link-assistant/agent/issues/307
  */
 async function parseCompactionModelConfig(
   argv,
@@ -425,9 +486,18 @@ async function parseCompactionModelConfig(
       }
     }
 
+    // A cascade nobody asked for must not reach across providers (#307).
+    const usingBuiltInCascade =
+      compactionModelsSource === 'default' &&
+      getDefaultCompactionModelsSource(defaultOptions) === 'default' &&
+      baseProviderID !== DEFAULT_PROVIDER_ID;
+    const cascade = usingBuiltInCascade
+      ? inheritBaseProvider(compactionModels, baseProviderID, baseModelID)
+      : compactionModels;
+
     Log.Default.info(() => ({
       message: 'compaction models cascade configured',
-      models: compactionModels.map((m) =>
+      models: cascade.map((m) =>
         m.useSameModel ? 'same' : `${m.providerID}/${m.modelID}`
       ),
       source: compactionModelsSource,
@@ -435,7 +505,7 @@ async function parseCompactionModelConfig(
 
     // Use the first model as the primary compaction model (for backward compatibility)
     // The full cascade is stored in compactionModels array
-    const primary = compactionModels[0] || {
+    const primary = cascade[0] || {
       providerID: baseProviderID,
       modelID: baseModelID,
       useSameModel: true,
@@ -446,16 +516,21 @@ async function parseCompactionModelConfig(
       modelID: primary.modelID,
       useSameModel: primary.useSameModel,
       compactionSafetyMarginPercent,
-      compactionModels,
+      compactionModels: cascade,
     };
   }
 
   // Fallback to single --compaction-model
   const cliCompactionModelArg = getCompactionModelFromProcessArgv();
+  const defaultCompactionModel = getDefaultCompactionModel(defaultOptions);
+  const compactionModelSource =
+    cliCompactionModelArg ||
+    (argv['compaction-model'] &&
+      argv['compaction-model'] !== defaultCompactionModel)
+      ? 'cli'
+      : 'default';
   const compactionModelArg =
-    cliCompactionModelArg ??
-    argv['compaction-model'] ??
-    getDefaultCompactionModel(defaultOptions);
+    cliCompactionModelArg ?? argv['compaction-model'] ?? defaultCompactionModel;
 
   const resolved = await resolveCompactionModelEntry(
     compactionModelArg,
@@ -463,23 +538,33 @@ async function parseCompactionModelConfig(
     baseModelID
   );
 
+  // Same rule as the cascade: an unrequested default follows --model (#307).
+  const usingBuiltInCompactionModel =
+    compactionModelSource === 'default' &&
+    getDefaultCompactionModelSource(defaultOptions) === 'default' &&
+    baseProviderID !== DEFAULT_PROVIDER_ID;
+  const [entry] = usingBuiltInCompactionModel
+    ? inheritBaseProvider([resolved], baseProviderID, baseModelID)
+    : [resolved];
+
   Log.Default.info(() => ({
     message: 'using single compaction model',
-    compactionProviderID: resolved.providerID,
-    compactionModelID: resolved.modelID,
-    useSameModel: resolved.useSameModel,
+    compactionProviderID: entry.providerID,
+    compactionModelID: entry.modelID,
+    useSameModel: entry.useSameModel,
+    source: compactionModelSource,
   }));
 
   return {
-    providerID: resolved.providerID,
-    modelID: resolved.modelID,
-    useSameModel: resolved.useSameModel,
+    providerID: entry.providerID,
+    modelID: entry.modelID,
+    useSameModel: entry.useSameModel,
     compactionSafetyMarginPercent,
     compactionModels: [
       {
-        providerID: resolved.providerID,
-        modelID: resolved.modelID,
-        useSameModel: resolved.useSameModel,
+        providerID: entry.providerID,
+        modelID: entry.modelID,
+        useSameModel: entry.useSameModel,
       },
     ],
   };

package/src/cli/run-options.js

@@ -184,13 +184,13 @@ export function buildRunOptions(yargs, defaultOptions = {}) {
     .option('summarize-session', {
       type: 'boolean',
       description:
-        'Generate AI session summaries (default: true). Use --no-summarize-session to disable.',
+        'Generate AI session summaries (default: true). Use --no-summarize-session to disable. Automatically off for a model declared as having no context limit (`unlimited: true` or `limit.context: null` in the provider config).',
       default: true,
     })
     .option('compaction-model', {
       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.',
+        'Model to use for context compaction and session summaries, in format providerID/modelID. Use "same" to use the base model. Default: opencode/gpt-5-nano (free, 400K context), which falls back to the --model model when --model points at another provider. Overridden by --compaction-models if both are specified.',
       default: defaultCompactionModel,
     })
     .option('compaction-models', {
@@ -198,7 +198,8 @@ export function buildRunOptions(yargs, defaultOptions = {}) {
       description:
         '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.',
+        'The special value "same" uses the base model. Overrides --compaction-model when specified. ' +
+        'The default cascade is OpenCode-specific: when --model points at another provider, its entries from other providers are dropped so secondary calls inherit --model. A cascade given explicitly is used as written.',
       default: defaultCompactionModels,
     })
     .option('compaction-safety-margin', {

package/src/config/defaults.ts

@@ -142,6 +142,24 @@ export function getDefaultCompactionModel(
   );
 }
 
+/**
+ * Report where the effective default compaction model came from.
+ *
+ * Same contract as `getDefaultModelSource`: `'config'` when an operator set
+ * `defaultOptions.defaultCompactionModel` or
+ * `LINK_ASSISTANT_AGENT_DEFAULT_COMPACTION_MODEL`, `'default'` when the
+ * built-in `DEFAULT_COMPACTION_MODEL` applies. Only a built-in default may be
+ * narrowed to the configured model's provider (#307).
+ */
+export function getDefaultCompactionModelSource(
+  options: DefaultConfigOptions = {}
+): 'config' | 'default' {
+  const env = options.env ?? process.env;
+  if (optionString(options.defaultCompactionModel)) return 'config';
+  if (envString(env, DEFAULT_COMPACTION_MODEL_ENV)) return 'config';
+  return 'default';
+}
+
 export function getDefaultCompactionModels(
   options: DefaultConfigOptions = {}
 ): string {
@@ -153,6 +171,20 @@ export function getDefaultCompactionModels(
   );
 }
 
+/**
+ * Report where the effective default compaction cascade came from.
+ *
+ * @see getDefaultCompactionModelSource
+ */
+export function getDefaultCompactionModelsSource(
+  options: DefaultConfigOptions = {}
+): 'config' | 'default' {
+  const env = options.env ?? process.env;
+  if (optionString(options.defaultCompactionModels)) return 'config';
+  if (envString(env, DEFAULT_COMPACTION_MODELS_ENV)) return 'config';
+  return 'default';
+}
+
 export function getDefaultCompactionSafetyMarginPercent(
   options: DefaultConfigOptions = {}
 ): number {

package/src/config/file-config.ts

@@ -834,7 +834,22 @@ export namespace Config {
           ModelsDev.Provider.partial()
             .extend({
               models: z
-                .record(z.string(), ModelsDev.Model.partial())
+                .record(
+                  z.string(),
+                  ModelsDev.Model.partial().extend({
+                    // `context: null` states that the model has no context
+                    // window to run out of, which turns off compaction and
+                    // session summarization for it (#307). `output` is
+                    // optional here so `{ "context": null }` alone is a valid
+                    // override.
+                    limit: z
+                      .object({
+                        context: z.number().nullable().optional(),
+                        output: z.number().optional(),
+                      })
+                      .optional(),
+                  })
+                )
                 .optional(),
               options: z
                 .object({

package/src/index.js

@@ -971,4 +971,9 @@ async function main() {
   }
 }
 
-main();
+// Awaited on purpose: everything the CLI does happens inside this promise, and
+// on Windows nothing else holds the process open while startup waits on async
+// filesystem I/O — the event loop drains and Bun exits 0 mid-run, so the CLI
+// prints its startup logs, never contacts the provider and reports success.
+// See: https://github.com/link-assistant/agent/issues/306
+await main();

package/src/provider/models.ts

@@ -42,6 +42,12 @@ export namespace ModelsDev {
         context: z.number(),
         output: z.number(),
       }),
+      unlimited: z
+        .boolean()
+        .optional()
+        .describe(
+          'Model has no context limit. Compaction and session summarization are skipped for it. Also set by writing `limit.context: null` in a provider model override.'
+        ),
       modalities: z
         .object({
           input: z.array(z.enum(['text', 'audio', 'image', 'video', 'pdf'])),
@@ -59,6 +65,26 @@ export namespace ModelsDev {
     });
   export type Model = z.infer<typeof Model>;
 
+  /**
+   * Whether a model declares that it has no context window to run out of.
+   *
+   * An operator states this per model in the config, either as
+   * `"unlimited": true` or as `"limit": { "context": null }` — the two are
+   * normalized to the same flag when the config is merged into the model
+   * database.
+   *
+   * Compaction and session summarization both exist to keep a conversation
+   * inside a context window. For a model without one they have no work to do,
+   * so they are skipped instead of spending a secondary API call per turn.
+   *
+   * @see https://github.com/link-assistant/agent/issues/307
+   */
+  export function hasUnlimitedContext(
+    model: { unlimited?: boolean } | undefined | null
+  ): boolean {
+    return model?.unlimited === true;
+  }
+
   export const Provider = z
     .object({
       api: z.string().optional(),

package/src/provider/provider.ts

@@ -1138,11 +1138,21 @@ export namespace Provider {
             ...existing?.options,
             ...model.options,
           },
-          limit: model.limit ??
-            existing?.limit ?? {
-              context: 0,
-              output: 0,
-            },
+          limit: iife(() => {
+            const limit = model.limit ?? existing?.limit;
+            if (!limit) return { context: 0, output: 0 };
+            // `context: null` is the config spelling of "no context limit";
+            // the arithmetic downstream keeps reading 0 as "no window to
+            // check", and the capability itself travels in `unlimited` (#307).
+            return {
+              context: limit.context ?? 0,
+              output: limit.output ?? existing?.limit?.output ?? 0,
+            };
+          }),
+          unlimited:
+            model.unlimited ??
+            (model.limit && model.limit.context === null ? true : undefined) ??
+            existing?.unlimited,
           modalities: model.modalities ??
             existing?.modalities ?? {
               input: ['text'],

package/src/session/compaction.ts

@@ -7,7 +7,7 @@ import { MessageV2 } from './message-v2';
 import { SystemPrompt } from './system';
 import { Bus } from '../bus';
 import z from 'zod';
-import type { ModelsDev } from '../provider/models';
+import { ModelsDev } from '../provider/models';
 import { SessionPrompt } from './prompt';
 import { config, isVerbose } from '../config/config';
 import { Token } from '../util/token';
@@ -135,6 +135,8 @@ export namespace SessionCompaction {
     estimatedInputTokens?: number;
   }) {
     if (config.disableAutocompact) return false;
+    // A model without a context window can never overflow it (#307).
+    if (ModelsDev.hasUnlimitedContext(input.model)) return false;
     const baseModelContextLimit = input.model.limit.context;
     if (baseModelContextLimit === 0) return false;
     const providerCount =
@@ -193,6 +195,7 @@ export namespace SessionCompaction {
     compactionModel?: CompactionModelConfig;
     compactionModelContextLimit?: number;
   }): MessageV2.ContextDiagnostics | undefined {
+    if (ModelsDev.hasUnlimitedContext(input.model)) return undefined;
     const contextLimit = input.model.limit.context;
     if (contextLimit === 0) return undefined;
     const outputLimit =

package/src/session/processor.ts

@@ -508,9 +508,20 @@ export namespace SessionProcessor {
                     }
                     snapshot = undefined;
                   }
-                  SessionSummary.summarize({
+                  // Fire-and-forget on purpose, and guarded: a summarization
+                  // failure must not become an unhandled rejection that exits
+                  // the process while this stream is still being processed.
+                  // See: https://github.com/link-assistant/agent/issues/304
+                  void SessionSummary.summarize({
                     sessionID: input.sessionID,
                     messageID: input.assistantMessage.parentID,
+                  }).catch((error) => {
+                    log.warn(() => ({
+                      message: 'session summarization failed',
+                      sessionID: input.sessionID,
+                      error:
+                        error instanceof Error ? error.message : String(error),
+                    }));
                   });
                   break;
 

package/src/session/prompt.ts

@@ -833,9 +833,19 @@ export namespace SessionPrompt {
       };
 
       if (step === 1) {
-        SessionSummary.summarize({
+        // Fire-and-forget on purpose: the summary runs alongside the turn. The
+        // `void` marks that, and the `.catch` keeps a summarization failure
+        // from becoming an unhandled rejection that would exit the process and
+        // abort this turn. See: https://github.com/link-assistant/agent/issues/304
+        void SessionSummary.summarize({
           sessionID: sessionID,
           messageID: lastUser.id,
+        }).catch((error) => {
+          log.warn(() => ({
+            message: 'session summarization failed',
+            sessionID,
+            error: error instanceof Error ? error.message : String(error),
+          }));
         });
       }
 

package/src/session/summary.ts

@@ -14,6 +14,7 @@ import { Instance } from '../project/instance';
 import { Storage } from '../storage/storage';
 import { Bus } from '../bus';
 import { config, isVerbose } from '../config/config';
+import { ModelsDev } from '../provider/models';
 import { Token } from '../util/token';
 
 export namespace SessionSummary {
@@ -25,11 +26,29 @@ export namespace SessionSummary {
       messageID: z.string(),
     }),
     async (input) => {
-      const all = await Session.messages({ sessionID: input.sessionID });
-      await Promise.all([
-        summarizeSession({ sessionID: input.sessionID, messages: all }),
-        summarizeMessage({ messageID: input.messageID, messages: all }),
-      ]);
+      // Summarization is a side quest: its whole product is a session title, a
+      // body and a diff stat, and it runs concurrently with the turn it
+      // describes. Neither caller awaits it, so a rejection escaping this
+      // function has no handler anywhere and becomes an `unhandledRejection`,
+      // which exits the process with status 1 and aborts the streaming turn.
+      // A failed title must never be a failed run.
+      // See: https://github.com/link-assistant/agent/issues/304
+      try {
+        const all = await Session.messages({ sessionID: input.sessionID });
+        await Promise.all([
+          summarizeSession({ sessionID: input.sessionID, messages: all }),
+          summarizeMessage({ messageID: input.messageID, messages: all }),
+        ]);
+      } catch (error) {
+        log.warn(() => ({
+          message: 'session summarization failed',
+          hint: 'The turn is unaffected; only the session summary is missing',
+          sessionID: input.sessionID,
+          messageID: input.messageID,
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined,
+        }));
+      }
     }
   );
 
@@ -94,6 +113,25 @@ export namespace SessionSummary {
     const assistantMsg = messages.find((m) => m.info.role === 'assistant')!
       .info as MessageV2.Assistant;
 
+    // Summarization keeps a conversation inside a context window. A model that
+    // declares it has none has nothing to summarize for, so the secondary call
+    // is skipped rather than spent — an integrator running such a model no
+    // longer has to pass --no-summarize-session.
+    // See: https://github.com/link-assistant/agent/issues/307
+    const baseModel = await Provider.getModel(
+      assistantMsg.providerID,
+      assistantMsg.modelID
+    ).catch(() => null);
+    if (baseModel && ModelsDev.hasUnlimitedContext(baseModel.info)) {
+      log.info(() => ({
+        message: 'session summarization skipped for an unlimited-context model',
+        hint: 'The model declares `unlimited: true` (or `limit.context: null`); the diff stat is still recorded',
+        providerID: assistantMsg.providerID,
+        modelID: assistantMsg.modelID,
+      }));
+      return;
+    }
+
     // Use the compaction model (--compaction-model, e.g. gpt-5-nano) for summarization
     // to avoid doubling rate-limit pressure on the main model.
     // If the compaction model is unavailable, fall back to the main model.
@@ -127,10 +165,7 @@ export namespace SessionSummary {
           ? 'Compaction model unavailable, falling back to main model'
           : 'Using same model as --model (no compaction model configured)',
       }));
-      model = await Provider.getModel(
-        assistantMsg.providerID,
-        assistantMsg.modelID
-      ).catch(() => null);
+      model = baseModel;
     }
     if (!model) {
       log.info(() => ({
@@ -202,20 +237,34 @@ export namespace SessionSummary {
         ],
         headers: model.info.headers,
         model: model.language,
-      });
-
-      if (isVerbose()) {
-        log.info(() => ({
-          message: 'title API response received',
+      }).catch((err) => {
+        // A provider that resolves a model but errors on the request must cost
+        // the run its title, not its exit status.
+        // See: https://github.com/link-assistant/agent/issues/304
+        log.warn(() => ({
+          message: 'title API call failed',
           providerID: model.providerID,
           modelID: model.modelID,
-          titleLength: result.text.length,
-          usage: result.usage,
+          error: err instanceof Error ? err.message : String(err),
+          stack: err instanceof Error ? err.stack : undefined,
         }));
+        return undefined;
+      });
+
+      if (result) {
+        if (isVerbose()) {
+          log.info(() => ({
+            message: 'title API response received',
+            providerID: model.providerID,
+            modelID: model.modelID,
+            titleLength: result.text.length,
+            usage: result.usage,
+          }));
+        }
+        log.info(() => ({ message: 'title', title: result.text }));
+        userMsg.summary.title = result.text;
+        await Session.updateMessage(userMsg);
       }
-      log.info(() => ({ message: 'title', title: result.text }));
-      userMsg.summary.title = result.text;
-      await Session.updateMessage(userMsg);
     }
 
     if (