@link-assistant/agent 0.16.18 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.16.18",
+  "version": "0.18.0",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",

package/src/cli/argv.ts

@@ -4,30 +4,68 @@
  */
 
 /**
- * Extract model argument directly from process.argv
- * This is a safeguard against yargs caching issues (#192)
- * @returns The model argument from CLI or null if not found
+ * Extract a named argument directly from process.argv.
+ * Supports --name=value, --name value, and optional short aliases (-x=value, -x value).
+ * @returns The argument value from CLI or null if not found
  */
-export function getModelFromProcessArgv(): string | null {
+function getArgFromProcessArgv(
+  longFlag: string,
+  shortFlag?: string
+): string | null {
   const args = process.argv;
+  const longPrefix = `--${longFlag}=`;
+  const shortPrefix = shortFlag ? `-${shortFlag}=` : null;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    // Handle --model=value format
-    if (arg.startsWith('--model=')) {
-      return arg.substring('--model='.length);
+    // Handle --flag=value format
+    if (arg.startsWith(longPrefix)) {
+      return arg.substring(longPrefix.length);
     }
-    // Handle --model value format
-    if (arg === '--model' && i + 1 < args.length) {
+    // Handle --flag value format
+    if (arg === `--${longFlag}` && i + 1 < args.length) {
       return args[i + 1];
     }
-    // Handle -m=value format
-    if (arg.startsWith('-m=')) {
-      return arg.substring('-m='.length);
-    }
-    // Handle -m value format (but not if it looks like another flag)
-    if (arg === '-m' && i + 1 < args.length && !args[i + 1].startsWith('-')) {
-      return args[i + 1];
+    if (shortPrefix) {
+      // Handle -x=value format
+      if (arg.startsWith(shortPrefix)) {
+        return arg.substring(shortPrefix.length);
+      }
+      // Handle -x value format (but not if it looks like another flag)
+      if (
+        arg === `-${shortFlag}` &&
+        i + 1 < args.length &&
+        !args[i + 1].startsWith('-')
+      ) {
+        return args[i + 1];
+      }
     }
   }
   return null;
 }
+
+/**
+ * Extract model argument directly from process.argv
+ * This is a safeguard against yargs caching issues (#192)
+ * @returns The model argument from CLI or null if not found
+ */
+export function getModelFromProcessArgv(): string | null {
+  return getArgFromProcessArgv('model', 'm');
+}
+
+/**
+ * Extract --compaction-model argument directly from process.argv
+ * @returns The compaction model argument from CLI or null if not found
+ * @see https://github.com/link-assistant/agent/issues/219
+ */
+export function getCompactionModelFromProcessArgv(): string | null {
+  return getArgFromProcessArgv('compaction-model');
+}
+
+/**
+ * Extract --compaction-safety-margin argument directly from process.argv
+ * @returns The compaction safety margin (%) from CLI or null if not found
+ * @see https://github.com/link-assistant/agent/issues/219
+ */
+export function getCompactionSafetyMarginFromProcessArgv(): string | null {
+  return getArgFromProcessArgv('compaction-safety-margin');
+}

package/src/cli/continuous-mode.js

@@ -193,7 +193,8 @@ export async function runContinuousServerMode(
   modelID,
   systemMessage,
   appendSystemMessage,
-  jsonStandard
+  jsonStandard,
+  compactionModel
 ) {
   // Check both CLI flag and environment variable for compact JSON mode
   const compactJson = argv['compact-json'] === true || Flag.COMPACT_JSON();
@@ -286,6 +287,7 @@ export async function runContinuousServerMode(
           body: JSON.stringify({
             parts,
             model: { providerID, modelID },
+            compactionModel,
             system: systemMessage,
             appendSystem: appendSystemMessage,
           }),
@@ -443,7 +445,8 @@ export async function runContinuousDirectMode(
   modelID,
   systemMessage,
   appendSystemMessage,
-  jsonStandard
+  jsonStandard,
+  compactionModel
 ) {
   // Check both CLI flag and environment variable for compact JSON mode
   const compactJson = argv['compact-json'] === true || Flag.COMPACT_JSON();
@@ -517,6 +520,7 @@ export async function runContinuousDirectMode(
         sessionID,
         parts,
         model: { providerID, modelID },
+        compactionModel,
         system: systemMessage,
         appendSystem: appendSystemMessage,
       }).catch((error) => {

package/src/cli/defaults.ts

@@ -13,3 +13,21 @@ 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 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).
+ * @see https://github.com/link-assistant/agent/issues/219
+ */
+export const DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT = 15;

package/src/cli/model-config.js

@@ -1,6 +1,15 @@
-import { getModelFromProcessArgv } from './argv.ts';
+import {
+  getModelFromProcessArgv,
+  getCompactionModelFromProcessArgv,
+  getCompactionSafetyMarginFromProcessArgv,
+} from './argv.ts';
 import { Log } from '../util/log.ts';
-import { DEFAULT_PROVIDER_ID, DEFAULT_MODEL_ID } from './defaults.ts';
+import {
+  DEFAULT_PROVIDER_ID,
+  DEFAULT_MODEL_ID,
+  DEFAULT_COMPACTION_MODEL,
+  DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT,
+} from './defaults.ts';
 
 /**
  * Parse model config from argv. Supports "provider/model" or short "model" format.
@@ -101,6 +110,13 @@ export async function parseModelConfig(argv, outputError, outputStatus) {
     }));
   }
 
+  // Parse compaction model (#219)
+  const compactionModelResult = await parseCompactionModelConfig(
+    argv,
+    providerID,
+    modelID
+  );
+
   // Handle --use-existing-claude-oauth option
   // This reads OAuth credentials from ~/.claude/.credentials.json (Claude Code CLI)
   // For new authentication, use: agent auth login (select Anthropic > Claude Pro/Max)
@@ -144,5 +160,73 @@ export async function parseModelConfig(argv, outputError, outputStatus) {
     }
   }
 
-  return { providerID, modelID };
+  return { providerID, modelID, compactionModel: compactionModelResult };
+}
+
+/**
+ * Parse compaction model config from argv.
+ * Resolves --compaction-model and --compaction-safety-margin CLI arguments.
+ * The special value "same" means use the base model for compaction.
+ * @see https://github.com/link-assistant/agent/issues/219
+ */
+async function parseCompactionModelConfig(argv, baseProviderID, baseModelID) {
+  // Get compaction model from CLI (safeguard against yargs caching)
+  const cliCompactionModelArg = getCompactionModelFromProcessArgv();
+  const compactionModelArg =
+    cliCompactionModelArg ??
+    argv['compaction-model'] ??
+    DEFAULT_COMPACTION_MODEL;
+
+  // Get safety margin from CLI
+  const cliSafetyMarginArg = getCompactionSafetyMarginFromProcessArgv();
+  const compactionSafetyMarginPercent = cliSafetyMarginArg
+    ? parseInt(cliSafetyMarginArg, 10)
+    : (argv['compaction-safety-margin'] ??
+      DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT);
+
+  // Special "same" alias — use the base model for compaction
+  const useSameModel = compactionModelArg.toLowerCase() === 'same';
+
+  let compactionProviderID;
+  let compactionModelID;
+
+  if (useSameModel) {
+    compactionProviderID = baseProviderID;
+    compactionModelID = baseModelID;
+    Log.Default.info(() => ({
+      message:
+        'compaction model set to "same" — using base model for compaction',
+      compactionProviderID,
+      compactionModelID,
+    }));
+  } else if (compactionModelArg.includes('/')) {
+    const parts = compactionModelArg.split('/');
+    compactionProviderID = parts[0];
+    compactionModelID = parts.slice(1).join('/');
+    Log.Default.info(() => ({
+      message: 'using explicit compaction model',
+      compactionProviderID,
+      compactionModelID,
+    }));
+  } else {
+    // Short name resolution
+    const { Provider } = await import('../provider/provider.ts');
+    const resolved =
+      await Provider.parseModelWithResolution(compactionModelArg);
+    compactionProviderID = resolved.providerID;
+    compactionModelID = resolved.modelID;
+    Log.Default.info(() => ({
+      message: 'resolved short compaction model name',
+      input: compactionModelArg,
+      compactionProviderID,
+      compactionModelID,
+    }));
+  }
+
+  return {
+    providerID: compactionProviderID,
+    modelID: compactionModelID,
+    useSameModel,
+    compactionSafetyMarginPercent,
+  };
 }

package/src/cli/run-options.js

@@ -0,0 +1,163 @@
+import {
+  DEFAULT_MODEL,
+  DEFAULT_COMPACTION_MODEL,
+  DEFAULT_COMPACTION_SAFETY_MARGIN_PERCENT,
+} 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
+    .option('model', {
+      type: 'string',
+      description: 'Model to use in format providerID/modelID',
+      default: DEFAULT_MODEL,
+    })
+    .option('json-standard', {
+      type: 'string',
+      description:
+        'JSON output format standard: "opencode" (default) or "claude" (experimental)',
+      default: 'opencode',
+      choices: ['opencode', 'claude'],
+    })
+    .option('system-message', {
+      type: 'string',
+      description: 'Full override of the system message',
+    })
+    .option('system-message-file', {
+      type: 'string',
+      description: 'Full override of the system message from file',
+    })
+    .option('append-system-message', {
+      type: 'string',
+      description: 'Append to the default system message',
+    })
+    .option('append-system-message-file', {
+      type: 'string',
+      description: 'Append to the default system message from file',
+    })
+    .option('server', {
+      type: 'boolean',
+      description: 'Run in server mode (default)',
+      default: true,
+    })
+    .option('verbose', {
+      type: 'boolean',
+      description:
+        'Enable verbose mode to debug API requests (shows system prompt, token counts, etc.)',
+      default: false,
+    })
+    .option('dry-run', {
+      type: 'boolean',
+      description:
+        'Simulate operations without making actual API calls or package installations (useful for testing)',
+      default: false,
+    })
+    .option('use-existing-claude-oauth', {
+      type: 'boolean',
+      description:
+        'Use existing Claude OAuth credentials from ~/.claude/.credentials.json (from Claude Code CLI)',
+      default: false,
+    })
+    .option('prompt', {
+      alias: 'p',
+      type: 'string',
+      description: 'Prompt message to send directly (bypasses stdin reading)',
+    })
+    .option('disable-stdin', {
+      type: 'boolean',
+      description:
+        'Disable stdin streaming mode (requires --prompt or shows help)',
+      default: false,
+    })
+    .option('stdin-stream-timeout', {
+      type: 'number',
+      description:
+        'Optional timeout in milliseconds for stdin reading (default: no timeout)',
+    })
+    .option('auto-merge-queued-messages', {
+      type: 'boolean',
+      description:
+        'Enable auto-merging of rapidly arriving input lines into single messages (default: true)',
+      default: true,
+    })
+    .option('interactive', {
+      type: 'boolean',
+      description:
+        'Enable interactive mode to accept manual input as plain text strings (default: true). Use --no-interactive to only accept JSON input.',
+      default: true,
+    })
+    .option('always-accept-stdin', {
+      type: 'boolean',
+      description:
+        'Keep accepting stdin input even after the agent finishes work (default: true). Use --no-always-accept-stdin for single-message mode.',
+      default: true,
+    })
+    .option('compact-json', {
+      type: 'boolean',
+      description:
+        'Output compact JSON (single line) instead of pretty-printed JSON (default: false). Useful for program-to-program communication.',
+      default: false,
+    })
+    .option('resume', {
+      alias: 'r',
+      type: 'string',
+      description:
+        'Resume a specific session by ID. By default, forks the session with a new UUID. Use --no-fork to continue in the same session.',
+    })
+    .option('continue', {
+      alias: 'c',
+      type: 'boolean',
+      description:
+        'Continue the most recent session. By default, forks the session with a new UUID. Use --no-fork to continue in the same session.',
+      default: false,
+    })
+    .option('no-fork', {
+      type: 'boolean',
+      description:
+        'When used with --resume or --continue, continue in the same session without forking to a new UUID.',
+      default: false,
+    })
+    .option('generate-title', {
+      type: 'boolean',
+      description:
+        'Generate session titles using AI (default: false). Disabling saves tokens and prevents rate limit issues.',
+      default: false,
+    })
+    .option('retry-timeout', {
+      type: 'number',
+      description:
+        'Maximum total retry time in seconds for rate limit errors (default: 604800 = 7 days)',
+    })
+    .option('retry-on-rate-limits', {
+      type: 'boolean',
+      description:
+        'Retry AI completions API requests when rate limited (HTTP 429). Use --no-retry-on-rate-limits in integration tests to fail fast instead of waiting.',
+      default: true,
+    })
+    .option('output-response-model', {
+      type: 'boolean',
+      description: 'Include model info in step_finish output',
+      default: true,
+    })
+    .option('summarize-session', {
+      type: 'boolean',
+      description:
+        'Generate AI session summaries (default: true). Use --no-summarize-session to disable.',
+      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).',
+      default: DEFAULT_COMPACTION_MODEL,
+    })
+    .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,
+    });
+}

package/src/flag/flag.ts

@@ -103,13 +103,19 @@ export namespace Flag {
   }
 
   // Session summarization configuration
-  // When disabled, session summaries will not be generated
-  // This saves tokens and prevents rate limit issues with free tier models
-  // See: https://github.com/link-assistant/agent/issues/179
-  export let SUMMARIZE_SESSION = truthyCompat(
-    'LINK_ASSISTANT_AGENT_SUMMARIZE_SESSION',
-    'AGENT_SUMMARIZE_SESSION'
-  );
+  // Enabled by default - generates AI-powered session summaries using the same model
+  // Can be disabled with --no-summarize-session or AGENT_SUMMARIZE_SESSION=false
+  // See: https://github.com/link-assistant/agent/issues/217
+  export let SUMMARIZE_SESSION = (() => {
+    const value = (
+      getEnv(
+        'LINK_ASSISTANT_AGENT_SUMMARIZE_SESSION',
+        'AGENT_SUMMARIZE_SESSION'
+      ) ?? ''
+    ).toLowerCase();
+    if (value === 'false' || value === '0') return false;
+    return true; // Default to true
+  })();
 
   // Allow setting summarize-session mode programmatically (e.g., from CLI --summarize-session flag)
   export function setSummarizeSession(value: boolean) {