@link-assistant/agent 0.25.5 → 0.25.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.25.5",
+  "version": "0.25.6",
   "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/cmd/run.ts

@@ -264,7 +264,11 @@ export const RunCommand = cmd({
               err = String(props.error.data.message);
             }
             errorMsg = errorMsg ? errorMsg + EOL + err : err;
-            if (outputJsonEvent('error', { error: props.error })) continue;
+            // Always include the human-readable string alongside the
+            // machine-readable object so consumers never print
+            // "[object Object]" (#289).
+            if (outputJsonEvent('error', { message: err, error: props.error }))
+              continue;
             UI.error(err);
           }
 

package/src/cli/continuous-mode.js

@@ -11,6 +11,7 @@ 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 { errorText } from '../util/error-text.ts';
 import { Permission } from '../permission/index.ts';
 import { Log } from '../util/log.ts';
 import { config } from '../config/config.ts';
@@ -385,6 +386,7 @@ export async function runContinuousServerMode(
           type: 'error',
           timestamp: Date.now(),
           sessionID,
+          message: errorText(error),
           error: error instanceof Error ? error.message : String(error),
         });
       });
@@ -598,6 +600,7 @@ export async function runContinuousDirectMode(
           type: 'error',
           timestamp: Date.now(),
           sessionID,
+          message: errorText(error),
           error: error instanceof Error ? error.message : String(error),
         });
       });

package/src/cli/event-handler.js

@@ -4,6 +4,7 @@
  */
 
 import { Bus } from '../bus/index.ts';
+import { errorText } from '../util/error-text.ts';
 
 /**
  * Create a subscription for session bus events that outputs events in the selected JSON format.
@@ -90,11 +91,13 @@ export function outputBusEvent({
 
       // If tool failed, also output an error event
       if (part.state?.status === 'error') {
+        const stateError = part.state.error;
         eventHandler.output({
           type: 'error',
           timestamp: Date.now(),
           sessionID,
-          error: part.state.error || 'Tool execution failed',
+          message: errorText(stateError, 'Tool execution failed'),
+          error: stateError || 'Tool execution failed',
         });
       }
     }
@@ -145,6 +148,7 @@ export function outputBusEvent({
       type: 'error',
       timestamp: Date.now(),
       sessionID,
+      message: errorText(props.error),
       error: props.error,
     });
   }

package/src/index.js

@@ -27,6 +27,7 @@ import { McpCommand } from './cli/cmd/mcp.ts';
 import { AuthCommand } from './cli/cmd/auth.ts';
 import { FormatError } from './cli/error.ts';
 import { UI } from './cli/ui.ts';
+import { errorText } from './util/error-text.ts';
 import {
   createVerboseFetch,
   registerPendingStreamLogExitHandler,
@@ -520,6 +521,7 @@ async function runServerMode(
         type: 'error',
         timestamp: Date.now(),
         sessionID,
+        message: errorText(error),
         error: error instanceof Error ? error.message : String(error),
       });
     });
@@ -605,6 +607,7 @@ async function runDirectMode(
         type: 'error',
         timestamp: Date.now(),
         sessionID,
+        message: errorText(error),
         error: error instanceof Error ? error.message : String(error),
       });
     });

package/src/util/error-text.ts

@@ -0,0 +1,82 @@
+/**
+ * Human-readable rendering of arbitrary error values (issue #289).
+ *
+ * JSON `error` events used to carry only the machine-readable
+ * `NamedError.toObject()` shape (`{name, data: {message}}`), so consumers doing
+ * `` `${record.error}` `` published `[object Object]` and the real cause was
+ * lost. Every emitted `error` event now also carries a `message` string
+ * produced by `stringifyErrorValue`.
+ *
+ * The renderer is circular-safe and depth-limited, and never invents a
+ * placeholder: when nothing readable can be derived it returns an empty
+ * string so the caller can pick its own fallback.
+ */
+
+const MAX_DEPTH = 5;
+
+function fromParts(name: string | undefined, message: string | undefined) {
+  if (name && message) return `${name}: ${message}`;
+  return message || name || '';
+}
+
+function render(value: unknown, depth: number, seen: Set<object>): string {
+  if (value === null || value === undefined) return '';
+  if (typeof value === 'string') return value.trim();
+  if (typeof value === 'number' || typeof value === 'boolean')
+    return String(value);
+  if (typeof value !== 'object') return '';
+
+  const object = value as Record<string, unknown>;
+  if (seen.has(object)) return '';
+  if (depth >= MAX_DEPTH) return '';
+  seen.add(object);
+
+  if (Array.isArray(object)) {
+    const rendered = object
+      .map((item) => render(item, depth + 1, seen))
+      .filter((item) => item.length > 0);
+    return rendered.join('; ');
+  }
+
+  if (object instanceof Error) {
+    return fromParts(object.name, object.message) || String(object);
+  }
+
+  // NamedError.toObject(): { name, data: { message, ... } }
+  const name = typeof object.name === 'string' ? object.name : undefined;
+  const data = object.data;
+  if (data && typeof data === 'object') {
+    const dataMessage = render(
+      (data as Record<string, unknown>).message,
+      depth + 1,
+      seen
+    );
+    if (dataMessage) return fromParts(name, dataMessage);
+  }
+
+  const message = render(object.message, depth + 1, seen);
+  if (message) return fromParts(name, message);
+
+  // Envelope shapes: { error: … }, { cause: … }
+  const nested =
+    render(object.error, depth + 1, seen) ||
+    render(object.cause, depth + 1, seen);
+  if (nested) return name ? fromParts(name, nested) : nested;
+
+  return name || '';
+}
+
+/**
+ * Render any error-ish value as a human-readable string.
+ * Returns an empty string when nothing readable can be derived.
+ */
+export function stringifyErrorValue(value: unknown): string {
+  return render(value, 0, new Set<object>());
+}
+
+/**
+ * Same as {@link stringifyErrorValue} but guarantees a non-empty string.
+ */
+export function errorText(value: unknown, fallback = 'Unknown error'): string {
+  return stringifyErrorValue(value) || fallback;
+}