@link-assistant/agent 0.22.9 → 0.23.0

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/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

@@ -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',
@@ -23,6 +29,19 @@ export function buildRunOptions(yargs) {
       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',
@@ -120,7 +139,26 @@ 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;
+          }
+          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;
+
+  return normalizedParser
     .option('generate-title', {
       type: 'boolean',
       description:
@@ -153,7 +191,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 +199,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

@@ -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(() => ({
@@ -488,7 +502,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 }];
 
@@ -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
           );