@link-assistant/agent 0.22.10 → 0.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.22.10",
+  "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",

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.
@@ -200,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' });
@@ -244,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;
@@ -255,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
@@ -290,8 +359,8 @@ export async function runContinuousServerMode(
             parts,
             model: { providerID, modelID },
             compactionModel,
-            system: systemMessage,
-            appendSystem: appendSystemMessage,
+            system: currentSystemMessage,
+            appendSystem: currentAppendSystemMessage,
             temperature,
           }),
         }
@@ -377,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)
@@ -454,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;
@@ -483,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;
@@ -494,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
@@ -525,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;
@@ -610,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/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

package/src/cli/output.ts

@@ -232,7 +232,7 @@ export function outputInput(
   input: {
     raw: string;
     parsed?: unknown;
-    format?: 'json' | 'text';
+    format?: 'json' | 'text' | 'stream-json';
     [key: string]: unknown;
   },
   compact?: boolean

package/src/cli/run-options.js

@@ -29,6 +29,19 @@ export function buildRunOptions(yargs, defaultOptions = {}) {
       default: 'opencode',
       choices: ['opencode', 'claude'],
     })
+    .option('output-format', {
+      type: 'string',
+      description:
+        'Claude-compatible output format alias: "json" (OpenCode JSON) or "stream-json" (Claude NDJSON)',
+      choices: ['json', 'stream-json'],
+    })
+    .option('input-format', {
+      type: 'string',
+      description:
+        'Input format: "text" (default) or Claude-compatible "stream-json" JSONL frames',
+      default: 'text',
+      choices: ['text', 'stream-json'],
+    })
     .option('system-message', {
       type: 'string',
       description: 'Full override of the system message',
@@ -135,6 +148,13 @@ export function buildRunOptions(yargs, defaultOptions = {}) {
             argv['no-fork'] = true;
             argv.noFork = true;
           }
+          if (argv.outputFormat === 'stream-json') {
+            argv['json-standard'] = 'claude';
+            argv.jsonStandard = 'claude';
+          } else if (argv.outputFormat === 'json') {
+            argv['json-standard'] = 'opencode';
+            argv.jsonStandard = 'opencode';
+          }
         }, true)
       : parser;
 

package/src/index.js

@@ -36,6 +36,7 @@ import {
   runContinuousDirectMode,
   resolveResumeSession,
 } from './cli/continuous-mode.js';
+import { parseStreamJsonInput } from './cli/input-queue.js';
 import { createBusEventSubscription } from './cli/event-handler.js';
 import {
   outputStatus,
@@ -259,6 +260,19 @@ async function readSystemMessages(argv) {
   return { systemMessage, appendSystemMessage };
 }
 
+function getInputFormat(argv) {
+  return argv['input-format'] || argv.inputFormat || 'text';
+}
+
+function getAcceptedInputFormats(inputFormat, isInteractive) {
+  if (inputFormat === 'stream-json') {
+    return ['Claude stream-json user frames'];
+  }
+  return isInteractive
+    ? ['JSON object with "message" field', 'Plain text']
+    : ['JSON object with "message" field'];
+}
+
 async function runAgentMode(argv, request) {
   // Log version and command info in verbose mode using lazy logging
   Log.Default.info(() => ({
@@ -663,8 +677,15 @@ async function main() {
           // Check if stdin is a TTY (interactive terminal)
           if (process.stdin.isTTY) {
             // Enter interactive terminal mode with continuous listening
-            const isInteractive = argv.interactive !== false;
-            const autoMerge = argv['auto-merge-queued-messages'] !== false;
+            const inputFormat = getInputFormat(argv);
+            const isInteractive =
+              inputFormat === 'stream-json'
+                ? false
+                : argv.interactive !== false;
+            const autoMerge =
+              inputFormat === 'stream-json'
+                ? false
+                : argv['auto-merge-queued-messages'] !== false;
             const alwaysAcceptStdin = argv['always-accept-stdin'] !== false;
 
             // Exit if --no-always-accept-stdin is set (single message mode not supported in TTY)
@@ -688,10 +709,12 @@ async function main() {
                 message:
                   'Agent CLI in interactive terminal mode. Type your message and press Enter.',
                 hint: 'Press CTRL+C to exit. Use --help for options.',
-                acceptedFormats: isInteractive
-                  ? ['JSON object with "message" field', 'Plain text']
-                  : ['JSON object with "message" field'],
+                acceptedFormats: getAcceptedInputFormats(
+                  inputFormat,
+                  isInteractive
+                ),
                 options: {
+                  inputFormat,
                   interactive: isInteractive,
                   autoMergeQueuedMessages: autoMerge,
                   alwaysAcceptStdin,
@@ -707,8 +730,13 @@ async function main() {
           }
 
           // stdin is piped - enter stdin listening mode
-          const isInteractive = argv.interactive !== false;
-          const autoMerge = argv['auto-merge-queued-messages'] !== false;
+          const inputFormat = getInputFormat(argv);
+          const isInteractive =
+            inputFormat === 'stream-json' ? false : argv.interactive !== false;
+          const autoMerge =
+            inputFormat === 'stream-json'
+              ? false
+              : argv['auto-merge-queued-messages'] !== false;
           const alwaysAcceptStdin = argv['always-accept-stdin'] !== false;
 
           outputStatus(
@@ -719,10 +747,12 @@ async function main() {
                 ? 'Agent CLI in continuous listening mode. Accepts JSON and plain text input.'
                 : 'Agent CLI in single-message mode. Accepts JSON and plain text input.',
               hint: 'Press CTRL+C to exit. Use --help for options.',
-              acceptedFormats: isInteractive
-                ? ['JSON object with "message" field', 'Plain text']
-                : ['JSON object with "message" field'],
+              acceptedFormats: getAcceptedInputFormats(
+                inputFormat,
+                isInteractive
+              ),
               options: {
+                inputFormat,
                 interactive: isInteractive,
                 autoMergeQueuedMessages: autoMerge,
                 alwaysAcceptStdin,
@@ -757,27 +787,52 @@ async function main() {
 
           // Try to parse as JSON, if it fails treat it as plain text message
           let request;
-          try {
-            request = JSON.parse(trimmedInput);
-          } catch (_e) {
-            // Not JSON
-            if (!isInteractive) {
-              // In non-interactive mode, only accept JSON
+          if (inputFormat === 'stream-json') {
+            try {
+              const firstFrame = trimmedInput
+                .split(/\r?\n/)
+                .find((line) => line.trim());
+              request = parseStreamJsonInput(firstFrame || '');
+              if (request.kind !== 'message') {
+                throw new Error(
+                  `Expected stream-json user frame, received ${request.kind}`
+                );
+              }
+            } catch (error) {
               outputError(
                 {
                   errorType: 'ValidationError',
                   message:
-                    'Invalid JSON input. In non-interactive mode (--no-interactive), only JSON input is accepted.',
-                  hint: 'Use --interactive to accept plain text, or provide valid JSON: {"message": "your text"}',
+                    error instanceof Error ? error.message : String(error),
+                  hint: 'Provide one Claude stream-json user frame per line.',
                 },
                 compactJson
               );
               process.exit(1);
             }
-            // In interactive mode, treat as plain text message
-            request = {
-              message: trimmedInput,
-            };
+          } else {
+            try {
+              request = JSON.parse(trimmedInput);
+            } catch (_e) {
+              // Not JSON
+              if (!isInteractive) {
+                // In non-interactive mode, only accept JSON
+                outputError(
+                  {
+                    errorType: 'ValidationError',
+                    message:
+                      'Invalid JSON input. In non-interactive mode (--no-interactive), only JSON input is accepted.',
+                    hint: 'Use --interactive to accept plain text, or provide valid JSON: {"message": "your text"}',
+                  },
+                  compactJson
+                );
+                process.exit(1);
+              }
+              // In interactive mode, treat as plain text message
+              request = {
+                message: trimmedInput,
+              };
+            }
           }
 
           // Output input confirmation in JSON format
@@ -785,7 +840,12 @@ async function main() {
             {
               raw: trimmedInput,
               parsed: request,
-              format: isInteractive ? 'text' : 'json',
+              format:
+                inputFormat === 'stream-json'
+                  ? 'stream-json'
+                  : isInteractive
+                    ? 'text'
+                    : 'json',
             },
             compactJson
           );