@link-assistant/agent 0.25.4 → 0.25.6

package/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

package/package.json

@@ -1,20 +1,21 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.25.4",
+  "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",
   "bin": {
-    "agent": "./src/index.js"
+    "agent": "src/index.js"
   },
   "scripts": {
     "dev": "bun run src/index.js",
-    "test": "bun test ./tests/*.js ./tests/*.ts",
+    "test": "bun test --timeout 30000 ./tests/*.js ./tests/*.ts",
     "test:integration": "bun test ./tests/integration/basic.js",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
+    "lint": "eslint . && npm run lint:scripts",
+    "lint:scripts": "cd ../scripts && eslint . --config ./eslint.config.mjs",
+    "lint:fix": "eslint . --fix && cd ../scripts && eslint . --config ./eslint.config.mjs --fix",
+    "format": "prettier --write . ../scripts",
+    "format:check": "prettier --check . ../scripts",
     "check:file-size": "node ../scripts/check-file-size.mjs",
     "check": "npm run lint && npm run format:check && npm run check:file-size",
     "prepare": "cd .. && husky || true",
@@ -28,7 +29,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/link-assistant/agent"
+    "url": "git+https://github.com/link-assistant/agent.git"
   },
   "keywords": [
     "ai",
@@ -46,10 +47,7 @@
     "src/",
     "package.json",
     "README.md",
-    "../MODELS.md",
-    "../TOOLS.md",
-    "../EXAMPLES.md",
-    "../LICENSE"
+    "LICENSE"
   ],
   "dependencies": {
     "@actions/core": "^1.11.1",

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/provider/retry-fetch.ts

@@ -183,9 +183,16 @@ export namespace RetryFetch {
         return;
       }
 
+      // The timer is deliberately NOT unref'd. Every caller awaits this
+      // promise, so an unref'd timer is the only pending work while a retry
+      // wait is in flight: the runtime is then free to stop waiting on it,
+      // which drops the retry instead of performing it. On Bun for Windows
+      // this showed up as `tests/retry-fetch.ts > retries on 429 and succeeds
+      // on second attempt` never resuming, burning the whole job timeout.
+      // See https://github.com/link-assistant/agent/issues/287.
+      // The abort path below clears the timer, so a cancelled wait still lets
+      // the process exit immediately (the concern behind #213).
       const timeout = setTimeout(resolve, ms);
-      // Prevent sleep timer from keeping event loop alive (#213)
-      if (timeout.unref) timeout.unref();
 
       if (signal) {
         const abortHandler = () => {

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;
+}