@link-assistant/agent 0.24.0 → 0.24.2

package/README.md

@@ -286,6 +286,10 @@ Options:
                                  Default: opencode/minimax-m2.5-free
   --json-standard                JSON output format standard
                                  Choices: "opencode" (default), "claude" (experimental)
+  --output-format                Alias for JSON output format
+                                 Choices: "json" (OpenCode), "stream-json" (Claude NDJSON)
+  --input-format                 Input format
+                                 Choices: "text" (default), "stream-json" (Claude JSONL)
   --use-existing-claude-oauth    Use existing Claude OAuth credentials
                                  from ~/.claude/.credentials.json
   --system-message               Full override of the system message
@@ -390,6 +394,21 @@ echo "your message here" | agent
 }
 ```
 
+**Live `stream-json`:**
+
+For bidirectional drivers, use:
+
+```bash
+agent --input-format stream-json --output-format stream-json
+```
+
+The live contract supports `user_prompt`, `system`, `interrupt`, and
+`permission_response` frames on stdin. It emits replay acknowledgements for
+consumed user frames and an explicit idle/turn-boundary event
+(`session_idle` in OpenCode output, `idle` in Claude output). See
+[docs/stdin-mode.md](../docs/stdin-mode.md#live-stream-json-contract) for the
+session resume and steering semantics.
+
 ## Supported Tools
 
 All 13 tools are **enabled by default** with **no configuration required**. See [TOOLS.md](../TOOLS.md) for complete documentation.

package/package.json

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

@@ -10,6 +10,7 @@ import { Session } from '../session/index.ts';
 import { SessionPrompt } from '../session/prompt.ts';
 import { createEventHandler, serializeOutput } from '../json-standard/index.ts';
 import { createContinuousStdinReader } from './input-queue.js';
+import { outputBusEvent } from './event-handler.js';
 import { Permission } from '../permission/index.ts';
 import { Log } from '../util/log.ts';
 import { config } from '../config/config.ts';
@@ -400,62 +401,14 @@ export async function runContinuousServerMode(
 
     // Subscribe to all bus events and output in selected format
     unsub = Bus.subscribeAll((event) => {
-      if (event.type === 'message.part.updated') {
-        const part = event.properties.part;
-        if (part.sessionID !== sessionID) {
-          return;
-        }
-
-        if (part.type === 'step-start') {
-          eventHandler.output({
-            type: 'step_start',
-            timestamp: Date.now(),
-            sessionID,
-            part,
-          });
-        }
-
-        if (part.type === 'step-finish') {
-          eventHandler.output({
-            type: 'step_finish',
-            timestamp: Date.now(),
-            sessionID,
-            part,
-          });
-        }
-
-        if (part.type === 'text' && part.time?.end) {
-          eventHandler.output({
-            type: 'text',
-            timestamp: Date.now(),
-            sessionID,
-            part,
-          });
-        }
-
-        if (part.type === 'tool') {
-          eventHandler.output({
-            type: 'tool_use',
-            timestamp: Date.now(),
-            sessionID,
-            part,
-          });
-        }
-      }
-
-      if (event.type === 'session.error') {
-        const props = event.properties;
-        if (props.sessionID !== sessionID || !props.error) {
-          return;
-        }
-        hasError = true;
-        eventHandler.output({
-          type: 'error',
-          timestamp: Date.now(),
-          sessionID,
-          error: props.error,
-        });
-      }
+      outputBusEvent({
+        event,
+        sessionID,
+        eventHandler,
+        onError: () => {
+          hasError = true;
+        },
+      });
     });
 
     // Create continuous stdin reader
@@ -661,62 +614,14 @@ export async function runContinuousDirectMode(
 
     // Subscribe to all bus events and output in selected format
     unsub = Bus.subscribeAll((event) => {
-      if (event.type === 'message.part.updated') {
-        const part = event.properties.part;
-        if (part.sessionID !== sessionID) {
-          return;
-        }
-
-        if (part.type === 'step-start') {
-          eventHandler.output({
-            type: 'step_start',
-            timestamp: Date.now(),
-            sessionID,
-            part,
-          });
-        }
-
-        if (part.type === 'step-finish') {
-          eventHandler.output({
-            type: 'step_finish',
-            timestamp: Date.now(),
-            sessionID,
-            part,
-          });
-        }
-
-        if (part.type === 'text' && part.time?.end) {
-          eventHandler.output({
-            type: 'text',
-            timestamp: Date.now(),
-            sessionID,
-            part,
-          });
-        }
-
-        if (part.type === 'tool') {
-          eventHandler.output({
-            type: 'tool_use',
-            timestamp: Date.now(),
-            sessionID,
-            part,
-          });
-        }
-      }
-
-      if (event.type === 'session.error') {
-        const props = event.properties;
-        if (props.sessionID !== sessionID || !props.error) {
-          return;
-        }
-        hasError = true;
-        eventHandler.output({
-          type: 'error',
-          timestamp: Date.now(),
-          sessionID,
-          error: props.error,
-        });
-      }
+      outputBusEvent({
+        event,
+        sessionID,
+        eventHandler,
+        onError: () => {
+          hasError = true;
+        },
+      });
     });
 
     // Create continuous stdin reader

package/src/cli/event-handler.js

@@ -26,105 +26,126 @@ export function createBusEventSubscription({
   });
 
   const unsub = Bus.subscribeAll((event) => {
-    // Output events in selected JSON format
-    if (event.type === 'message.part.updated') {
-      const part = event.properties.part;
-      if (part.sessionID !== sessionID) {
-        return;
-      }
-
-      // Output different event types
-      if (part.type === 'step-start') {
-        eventHandler.output({
-          type: 'step_start',
-          timestamp: Date.now(),
-          sessionID,
-          part,
-        });
-      }
-
-      if (part.type === 'step-finish') {
-        eventHandler.output({
-          type: 'step_finish',
-          timestamp: Date.now(),
-          sessionID,
-          part,
-        });
-      }
+    outputBusEvent({
+      event,
+      sessionID,
+      eventHandler,
+      onError,
+      onIdle: idleResolve,
+    });
+  });
 
-      if (part.type === 'text' && part.time?.end) {
-        eventHandler.output({
-          type: 'text',
-          timestamp: Date.now(),
-          sessionID,
-          part,
-        });
-      }
+  return { unsub, idlePromise };
+}
 
-      if (part.type === 'tool') {
-        eventHandler.output({
-          type: 'tool_use',
-          timestamp: Date.now(),
-          sessionID,
-          part,
-        });
+export function outputBusEvent({
+  event,
+  sessionID,
+  eventHandler,
+  onError,
+  onIdle,
+}) {
+  // Output events in selected JSON format
+  if (event.type === 'message.part.updated') {
+    const part = event.properties.part;
+    if (part.sessionID !== sessionID) {
+      return;
+    }
 
-        // If tool failed, also output an error event
-        if (part.state?.status === 'error') {
-          eventHandler.output({
-            type: 'error',
-            timestamp: Date.now(),
-            sessionID,
-            error: part.state.error || 'Tool execution failed',
-          });
-        }
-      }
+    // Output different event types
+    if (part.type === 'step-start') {
+      eventHandler.output({
+        type: 'step_start',
+        timestamp: Date.now(),
+        sessionID,
+        part,
+      });
     }
 
-    // Emit a JSON permission request when a tool needs approval (issue #271).
-    // The consumer replies with a `permission_response` frame over stdin which
-    // is routed to Permission.respond. No TUI is involved.
-    if (event.type === 'permission.updated') {
-      const permission = event.properties;
-      if (permission.sessionID !== sessionID) {
-        return;
-      }
+    if (part.type === 'step-finish') {
       eventHandler.output({
-        type: 'permission_request',
+        type: 'step_finish',
         timestamp: Date.now(),
         sessionID,
-        permissionID: permission.id,
-        callID: permission.callID,
-        tool: permission.type,
-        pattern: permission.pattern,
-        title: permission.title,
-        metadata: permission.metadata,
+        part,
       });
     }
 
-    // Handle session idle to know when to stop
-    if (
-      event.type === 'session.idle' &&
-      event.properties.sessionID === sessionID
-    ) {
-      idleResolve();
+    if (part.type === 'text' && part.time?.end) {
+      eventHandler.output({
+        type: 'text',
+        timestamp: Date.now(),
+        sessionID,
+        part,
+      });
     }
 
-    // Handle errors
-    if (event.type === 'session.error') {
-      const props = event.properties;
-      if (props.sessionID !== sessionID || !props.error) {
-        return;
-      }
-      onError();
+    if (part.type === 'tool') {
       eventHandler.output({
-        type: 'error',
+        type: 'tool_use',
         timestamp: Date.now(),
         sessionID,
-        error: props.error,
+        part,
       });
+
+      // If tool failed, also output an error event
+      if (part.state?.status === 'error') {
+        eventHandler.output({
+          type: 'error',
+          timestamp: Date.now(),
+          sessionID,
+          error: part.state.error || 'Tool execution failed',
+        });
+      }
     }
-  });
+  }
 
-  return { unsub, idlePromise };
+  // Emit a JSON permission request when a tool needs approval (issue #271).
+  // The consumer replies with a `permission_response` frame over stdin which
+  // is routed to Permission.respond. No TUI is involved.
+  if (event.type === 'permission.updated') {
+    const permission = event.properties;
+    if (permission.sessionID !== sessionID) {
+      return;
+    }
+    eventHandler.output({
+      type: 'permission_request',
+      timestamp: Date.now(),
+      sessionID,
+      permissionID: permission.id,
+      callID: permission.callID,
+      tool: permission.type,
+      pattern: permission.pattern,
+      title: permission.title,
+      metadata: permission.metadata,
+    });
+  }
+
+  // Handle session idle to know when to stop
+  if (
+    event.type === 'session.idle' &&
+    event.properties.sessionID === sessionID
+  ) {
+    eventHandler.output({
+      type: 'session_idle',
+      timestamp: Date.now(),
+      sessionID,
+    });
+    onIdle?.();
+  }
+
+  // Handle errors
+  if (event.type === 'session.error') {
+    const props = event.properties;
+    if (props.sessionID !== sessionID || !props.error) {
+      return;
+    }
+    onError();
+    eventHandler.output({
+      type: 'error',
+      timestamp: Date.now(),
+      sessionID,
+      error: props.error,
+    });
+  }
 }

package/src/cli/model-config.js

@@ -302,7 +302,10 @@ async function resolveCompactionModelEntry(
 
   // Short name resolution
   const { Provider } = await import('../provider/provider.ts');
-  const resolved = await Provider.parseModelWithResolution(modelArg);
+  const resolved = await Provider.resolveShortModelName(modelArg);
+  if (!resolved) {
+    throw new Error('ProviderModelNotFoundError');
+  }
   return {
     providerID: resolved.providerID,
     modelID: resolved.modelID,
@@ -336,10 +339,17 @@ async function parseCompactionModelConfig(
 
   // Check for --compaction-models (cascade) first — it overrides --compaction-model
   const cliCompactionModelsArg = getCompactionModelsFromProcessArgv();
+  const defaultCompactionModels = getDefaultCompactionModels(defaultOptions);
+  const compactionModelsSource =
+    cliCompactionModelsArg ||
+    (argv['compaction-models'] &&
+      argv['compaction-models'] !== defaultCompactionModels)
+      ? 'cli'
+      : 'default';
   const compactionModelsArg =
     cliCompactionModelsArg ??
     argv['compaction-models'] ??
-    getDefaultCompactionModels(defaultOptions);
+    defaultCompactionModels;
 
   // Parse the links notation sequence into an array of model names
   const modelNames = parseLinksNotationSequence(compactionModelsArg);
@@ -360,8 +370,11 @@ async function parseCompactionModelConfig(
           useSameModel: resolved.useSameModel,
         });
       } catch (err) {
-        // If a model can't be resolved, log and skip it
-        Log.Default.warn(() => ({
+        const logSkip =
+          compactionModelsSource === 'default'
+            ? Log.Default.debug
+            : Log.Default.warn;
+        logSkip(() => ({
           message: 'skipping unresolvable compaction model in cascade',
           model: name,
           error: err?.message,
@@ -374,7 +387,7 @@ async function parseCompactionModelConfig(
       models: compactionModels.map((m) =>
         m.useSameModel ? 'same' : `${m.providerID}/${m.modelID}`
       ),
-      source: cliCompactionModelsArg ? 'cli' : 'default',
+      source: compactionModelsSource,
     }));
 
     // Use the first model as the primary compaction model (for backward compatibility)

package/src/json-standard/index.ts

@@ -18,7 +18,13 @@ export type JsonStandard = 'opencode' | 'claude';
  * OpenCode JSON event types
  */
 export interface OpenCodeEvent {
-  type: 'step_start' | 'step_finish' | 'text' | 'tool_use' | 'error';
+  type:
+    | 'step_start'
+    | 'step_finish'
+    | 'text'
+    | 'tool_use'
+    | 'error'
+    | 'session_idle';
   timestamp: number;
   sessionID: string;
   part?: Record<string, unknown>;
@@ -29,7 +35,7 @@ export interface OpenCodeEvent {
  * Claude JSON event types (stream-json format)
  */
 export interface ClaudeEvent {
-  type: 'init' | 'message' | 'tool_use' | 'tool_result' | 'result';
+  type: 'init' | 'message' | 'tool_use' | 'tool_result' | 'result' | 'idle';
   timestamp?: string;
   session_id?: string;
   role?: 'assistant' | 'user';
@@ -126,6 +132,13 @@ export function convertOpenCodeToClaude(
         duration_ms: event.timestamp - startTime,
       };
 
+    case 'session_idle':
+      return {
+        type: 'idle',
+        timestamp,
+        session_id,
+      };
+
     case 'error':
       return {
         type: 'result',