@link-assistant/agent 0.22.9 → 0.23.0

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.9",
+  "version": "0.23.0",
   "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

@@ -8,7 +8,7 @@ import { Instance } from '../project/instance.ts';
 import { Bus } from '../bus/index.ts';
 import { Session } from '../session/index.ts';
 import { SessionPrompt } from '../session/prompt.ts';
-import { createEventHandler } from '../json-standard/index.ts';
+import { createEventHandler, serializeOutput } from '../json-standard/index.ts';
 import { createContinuousStdinReader } from './input-queue.js';
 import { Log } from '../util/log.ts';
 import { config } from '../config/config.ts';
@@ -40,6 +40,64 @@ export function getHasError() {
 // Logger for resume operations
 const log = Log.create({ service: 'resume' });
 
+function getInputFormat(argv) {
+  return argv['input-format'] || argv.inputFormat || 'text';
+}
+
+function outputConsumedInput({
+  message,
+  jsonStandard,
+  sessionID,
+  compactJson,
+}) {
+  const raw = message.raw || message.message || message.system || '';
+  if (
+    jsonStandard === 'claude' &&
+    message.kind === 'message' &&
+    message.format === 'stream-json'
+  ) {
+    process.stdout.write(
+      serializeOutput(
+        {
+          type: 'message',
+          timestamp: new Date().toISOString(),
+          session_id: sessionID,
+          role: 'user',
+          content: [{ type: 'text', text: message.message ?? '' }],
+        },
+        'claude'
+      )
+    );
+    return;
+  }
+
+  if (jsonStandard === 'claude') {
+    return;
+  }
+
+  outputInput(
+    {
+      raw,
+      parsed: message.parsed || message,
+      format: message.format || 'text',
+      kind: message.kind || 'message',
+    },
+    compactJson
+  );
+}
+
+function outputInputParseError(error, line, compactJson) {
+  hasError = true;
+  outputError(
+    {
+      errorType: 'ValidationError',
+      message: error instanceof Error ? error.message : String(error),
+      raw: line,
+    },
+    compactJson
+  );
+}
+
 /**
  * Resolve the session to use based on --resume, --continue, and --no-fork options.
  * Returns the session ID to use, handling forking as needed.
@@ -51,7 +109,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) {
@@ -199,8 +258,12 @@ export async function runContinuousServerMode(
 ) {
   // Check both CLI flag and environment variable for compact JSON mode
   const compactJson = argv['compact-json'] === true || config.compactJson;
+  const inputFormat = getInputFormat(argv);
   const isInteractive = argv.interactive !== false;
-  const autoMerge = argv['auto-merge-queued-messages'] !== false;
+  const autoMerge =
+    inputFormat === 'stream-json'
+      ? false
+      : argv['auto-merge-queued-messages'] !== false;
 
   // Start server like OpenCode does
   const server = Server.listen({ port: 0, hostname: '127.0.0.1' });
@@ -243,9 +306,23 @@ export async function runContinuousServerMode(
     // Track if we're currently processing a message
     let isProcessing = false;
     const pendingMessages = [];
+    let currentSystemMessage = systemMessage;
+    const currentAppendSystemMessage = appendSystemMessage;
 
     // Process messages from the queue
     const processMessage = async (message) => {
+      if (message.kind === 'interrupt') {
+        SessionPrompt.cancel(sessionID);
+        outputConsumedInput({ message, jsonStandard, sessionID, compactJson });
+        return;
+      }
+
+      if (message.kind === 'system') {
+        currentSystemMessage = message.system;
+        outputConsumedInput({ message, jsonStandard, sessionID, compactJson });
+        return;
+      }
+
       if (isProcessing) {
         pendingMessages.push(message);
         return;
@@ -254,16 +331,9 @@ export async function runContinuousServerMode(
       isProcessing = true;
 
       // Output input confirmation in JSON format
-      outputInput(
-        {
-          raw: message.raw || message.message,
-          parsed: message,
-          format: message.format || 'text',
-        },
-        compactJson
-      );
+      outputConsumedInput({ message, jsonStandard, sessionID, compactJson });
 
-      const messageText = message.message || 'hi';
+      const messageText = message.message ?? 'hi';
       const parts = [{ type: 'text', text: messageText }];
 
       // Create a promise to wait for this message to complete
@@ -289,8 +359,8 @@ export async function runContinuousServerMode(
             parts,
             model: { providerID, modelID },
             compactionModel,
-            system: systemMessage,
-            appendSystem: appendSystemMessage,
+            system: currentSystemMessage,
+            appendSystem: currentAppendSystemMessage,
             temperature,
           }),
         }
@@ -376,11 +446,15 @@ export async function runContinuousServerMode(
 
     // Create continuous stdin reader
     stdinReader = createContinuousStdinReader({
-      interactive: isInteractive,
+      interactive: inputFormat === 'stream-json' ? false : isInteractive,
       autoMerge,
+      inputFormat,
       onMessage: (message) => {
         processMessage(message);
       },
+      onError: (error, line) => {
+        outputInputParseError(error, line, compactJson);
+      },
     });
 
     // Wait for stdin to end (EOF or close)
@@ -453,8 +527,12 @@ export async function runContinuousDirectMode(
 ) {
   // Check both CLI flag and environment variable for compact JSON mode
   const compactJson = argv['compact-json'] === true || config.compactJson;
+  const inputFormat = getInputFormat(argv);
   const isInteractive = argv.interactive !== false;
-  const autoMerge = argv['auto-merge-queued-messages'] !== false;
+  const autoMerge =
+    inputFormat === 'stream-json'
+      ? false
+      : argv['auto-merge-queued-messages'] !== false;
 
   let unsub = null;
   let stdinReader = null;
@@ -482,9 +560,23 @@ export async function runContinuousDirectMode(
     // Track if we're currently processing a message
     let isProcessing = false;
     const pendingMessages = [];
+    let currentSystemMessage = systemMessage;
+    const currentAppendSystemMessage = appendSystemMessage;
 
     // Process messages from the queue
     const processMessage = async (message) => {
+      if (message.kind === 'interrupt') {
+        SessionPrompt.cancel(sessionID);
+        outputConsumedInput({ message, jsonStandard, sessionID, compactJson });
+        return;
+      }
+
+      if (message.kind === 'system') {
+        currentSystemMessage = message.system;
+        outputConsumedInput({ message, jsonStandard, sessionID, compactJson });
+        return;
+      }
+
       if (isProcessing) {
         pendingMessages.push(message);
         return;
@@ -493,16 +585,9 @@ export async function runContinuousDirectMode(
       isProcessing = true;
 
       // Output input confirmation in JSON format
-      outputInput(
-        {
-          raw: message.raw || message.message,
-          parsed: message,
-          format: message.format || 'text',
-        },
-        compactJson
-      );
+      outputConsumedInput({ message, jsonStandard, sessionID, compactJson });
 
-      const messageText = message.message || 'hi';
+      const messageText = message.message ?? 'hi';
       const parts = [{ type: 'text', text: messageText }];
 
       // Create a promise to wait for this message to complete
@@ -524,8 +609,8 @@ export async function runContinuousDirectMode(
         parts,
         model: { providerID, modelID },
         compactionModel,
-        system: systemMessage,
-        appendSystem: appendSystemMessage,
+        system: currentSystemMessage,
+        appendSystem: currentAppendSystemMessage,
         temperature,
       }).catch((error) => {
         hasError = true;
@@ -609,11 +694,15 @@ export async function runContinuousDirectMode(
 
     // Create continuous stdin reader
     stdinReader = createContinuousStdinReader({
-      interactive: isInteractive,
+      interactive: inputFormat === 'stream-json' ? false : isInteractive,
       autoMerge,
+      inputFormat,
       onMessage: (message) => {
         processMessage(message);
       },
+      onError: (error, line) => {
+        outputInputParseError(error, line, compactJson);
+      },
     });
 
     // Wait for stdin to end (EOF or close)

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/input-queue.js

@@ -5,11 +5,13 @@
 export class InputQueue {
   constructor(options = {}) {
     this.queue = [];
+    this.inputFormat = options.inputFormat || 'text';
     this.autoMerge = options.autoMerge !== false; // enabled by default
     this.mergeDelayMs = options.mergeDelayMs || 50; // delay to wait for more lines
     this.pendingLines = [];
     this.mergeTimer = null;
     this.onMessage = options.onMessage || (() => {});
+    this.onError = options.onError || (() => {});
     this.interactive = options.interactive !== false; // enabled by default
   }
 
@@ -24,6 +26,10 @@ export class InputQueue {
       return null;
     }
 
+    if (this.inputFormat === 'stream-json') {
+      return parseStreamJsonInput(trimmed);
+    }
+
     try {
       const parsed = JSON.parse(trimmed);
       // If it has a message field, use it directly
@@ -43,6 +49,11 @@ export class InputQueue {
    * @param {string} line - Input line
    */
   addLine(line) {
+    if (this.inputFormat === 'stream-json') {
+      this.queueLine(line);
+      return;
+    }
+
     if (!this.interactive && !line.trim().startsWith('{')) {
       // In non-interactive mode, only accept JSON
       return;
@@ -54,11 +65,7 @@ export class InputQueue {
       this.scheduleMerge();
     } else {
       // No merging, queue immediately
-      const parsed = this.parseInput(line);
-      if (parsed) {
-        this.queue.push(parsed);
-        this.notifyMessage(parsed);
-      }
+      this.queueLine(line);
     }
   }
 
@@ -130,6 +137,33 @@ export class InputQueue {
     }
   }
 
+  /**
+   * Notify listener of an input parse error
+   * @param {Error} error - Parse error
+   * @param {string} line - Raw input line
+   */
+  notifyError(error, line) {
+    if (this.onError) {
+      this.onError(error, line);
+    }
+  }
+
+  /**
+   * Parse and enqueue one complete input line
+   * @param {string} line - Raw input line
+   */
+  queueLine(line) {
+    try {
+      const parsed = this.parseInput(line);
+      if (parsed) {
+        this.queue.push(parsed);
+        this.notifyMessage(parsed);
+      }
+    } catch (error) {
+      this.notifyError(error, line);
+    }
+  }
+
   /**
    * Get queue size
    * @returns {number}
@@ -139,6 +173,136 @@ export class InputQueue {
   }
 }
 
+function extractContentText(content) {
+  if (typeof content === 'string') {
+    return content;
+  }
+
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const part of content) {
+      if (typeof part === 'string') {
+        parts.push(part);
+      } else if (part && typeof part === 'object') {
+        if (typeof part.text === 'string') {
+          parts.push(part.text);
+        } else if (typeof part.content === 'string') {
+          parts.push(part.content);
+        }
+      }
+    }
+    return parts.length > 0 ? parts.join('\n') : null;
+  }
+
+  if (content && typeof content === 'object') {
+    if (typeof content.text === 'string') {
+      return content.text;
+    }
+    if ('content' in content) {
+      return extractContentText(content.content);
+    }
+  }
+
+  return null;
+}
+
+function extractFrameText(frame) {
+  if (typeof frame.message === 'string') {
+    return frame.message;
+  }
+
+  if (frame.message && typeof frame.message === 'object') {
+    const messageText = extractContentText(frame.message.content);
+    if (messageText !== null) {
+      return messageText;
+    }
+    if (typeof frame.message.text === 'string') {
+      return frame.message.text;
+    }
+  }
+
+  const contentText = extractContentText(frame.content);
+  if (contentText !== null) {
+    return contentText;
+  }
+
+  if (typeof frame.text === 'string') {
+    return frame.text;
+  }
+
+  return null;
+}
+
+/**
+ * Parse one Claude-compatible stream-json input frame.
+ * @param {string} input - One JSONL frame
+ * @returns {object} Normalized queue message
+ */
+export function parseStreamJsonInput(input) {
+  let frame;
+  try {
+    frame = JSON.parse(input);
+  } catch (error) {
+    throw new Error(
+      `Invalid stream-json input frame: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+
+  if (!frame || typeof frame !== 'object' || Array.isArray(frame)) {
+    throw new Error('Invalid stream-json input frame: expected JSON object');
+  }
+
+  const type = frame.type;
+
+  if (type === 'interrupt') {
+    return {
+      kind: 'interrupt',
+      raw: input,
+      parsed: frame,
+      format: 'stream-json',
+      inputType: type,
+    };
+  }
+
+  if (type === 'system') {
+    const system = extractFrameText(frame);
+    if (system === null) {
+      throw new Error(
+        'Invalid stream-json system frame: expected content text'
+      );
+    }
+    return {
+      kind: 'system',
+      system,
+      raw: input,
+      parsed: frame,
+      format: 'stream-json',
+      inputType: type,
+    };
+  }
+
+  if (type === 'user' || type === 'user_prompt' || type === undefined) {
+    const message = extractFrameText(frame);
+    if (message === null) {
+      throw new Error(
+        'Invalid stream-json user frame: expected message content text'
+      );
+    }
+    return {
+      kind: 'message',
+      message,
+      raw: input,
+      parsed: frame,
+      format: 'stream-json',
+      inputType: type || 'message',
+    };
+  }
+
+  throw new Error(`Unsupported stream-json input frame type: ${String(type)}`);
+}
+
 /**
  * Create a continuous stdin reader that queues input lines
  * @param {object} options - Options for the reader