@link-assistant/agent 0.16.7 → 0.16.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.16.7",
+  "version": "0.16.9",
   "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/output.ts

@@ -62,16 +62,62 @@ export function isCompactJson(): boolean {
 }
 
 /**
- * Format a message as JSON string
+ * Safe JSON replacer that handles cyclic references and non-serializable values.
+ * Returns a replacer function that tracks seen objects to detect cycles.
+ *
+ * @see https://github.com/link-assistant/agent/issues/200
+ */
+function createSafeReplacer(): (key: string, value: unknown) => unknown {
+  const seen = new WeakSet();
+  return (_key: string, value: unknown) => {
+    if (typeof value === 'object' && value !== null) {
+      if (seen.has(value)) {
+        return '[Circular]';
+      }
+      seen.add(value);
+    }
+    // Convert Error objects to plain objects
+    if (value instanceof Error) {
+      return {
+        name: value.name,
+        message: value.message,
+        stack: value.stack,
+        ...(value.cause ? { cause: value.cause } : {}),
+      };
+    }
+    // Handle BigInt (not JSON-serializable by default)
+    if (typeof value === 'bigint') {
+      return value.toString();
+    }
+    return value;
+  };
+}
+
+/**
+ * Format a message as JSON string.
+ * Handles cyclic references and non-serializable values safely.
+ *
  * @param message - The message object to format
  * @param compact - Override the global compact setting
+ * @see https://github.com/link-assistant/agent/issues/200
  */
 export function formatJson(message: OutputMessage, compact?: boolean): string {
-  // Check local, global, and Flag settings for compact mode
   const useCompact = compact ?? isCompactJson();
-  return useCompact
-    ? JSON.stringify(message)
-    : JSON.stringify(message, null, 2);
+  try {
+    return useCompact
+      ? JSON.stringify(message, createSafeReplacer())
+      : JSON.stringify(message, createSafeReplacer(), 2);
+  } catch (_e) {
+    // Last resort fallback - should never happen with safe replacer
+    const fallback: OutputMessage = {
+      type: message.type ?? 'error',
+      message: 'Failed to serialize output',
+      serializationError: _e instanceof Error ? _e.message : String(_e),
+    };
+    return useCompact
+      ? JSON.stringify(fallback)
+      : JSON.stringify(fallback, null, 2);
+  }
 }
 
 /**

package/src/index.js

@@ -55,28 +55,56 @@ try {
 let hasError = false;
 
 // Install global error handlers to ensure non-zero exit codes
+// All output is JSON to ensure machine-parsability (#200)
 process.on('uncaughtException', (error) => {
   hasError = true;
-  outputError({
-    errorType: error.name || 'UncaughtException',
-    message: error.message,
-    stack: error.stack,
-  });
+  try {
+    outputError({
+      errorType: error?.name || 'UncaughtException',
+      message: error?.message || String(error),
+      stack: error?.stack,
+      ...(error?.cause ? { cause: String(error.cause) } : {}),
+    });
+  } catch (_serializationError) {
+    // Last resort: write minimal JSON directly to stderr
+    process.stderr.write(
+      `${JSON.stringify({
+        type: 'error',
+        errorType: 'UncaughtException',
+        message: String(error),
+      })}\n`
+    );
+  }
   process.exit(1);
 });
 
 process.on('unhandledRejection', (reason, _promise) => {
   hasError = true;
-  const errorOutput = {
-    errorType: 'UnhandledRejection',
-    message: reason?.message || String(reason),
-    stack: reason?.stack,
-  };
-  // If the error has a data property with a suggestion (e.g., ProviderModelNotFoundError), add it as a hint
-  if (reason?.data?.suggestion) {
-    errorOutput.hint = reason.data.suggestion;
+  try {
+    const errorOutput = {
+      errorType: 'UnhandledRejection',
+      message: reason?.message || String(reason),
+      stack: reason?.stack,
+    };
+    // If the error has a data property with a suggestion (e.g., ProviderModelNotFoundError), add it as a hint
+    if (reason?.data?.suggestion) {
+      errorOutput.hint = reason.data.suggestion;
+    }
+    // Include error data for debugging (#200)
+    if (reason?.data) {
+      errorOutput.data = reason.data;
+    }
+    outputError(errorOutput);
+  } catch (_serializationError) {
+    // Last resort: write minimal JSON directly to stderr
+    process.stderr.write(
+      `${JSON.stringify({
+        type: 'error',
+        errorType: 'UnhandledRejection',
+        message: String(reason),
+      })}\n`
+    );
   }
-  outputError(errorOutput);
   process.exit(1);
 });
 

package/src/provider/models.ts

@@ -83,7 +83,7 @@ export namespace ModelsDev {
    *
    * This prevents ProviderModelNotFoundError when:
    * - User runs agent for the first time (no cache)
-   * - User has outdated cache missing new models like kimi-k2.5-free
+   * - User has outdated cache missing new models like glm-5-free
    *
    * @see https://github.com/link-assistant/agent/issues/175
    */

package/src/provider/provider.ts

@@ -1201,6 +1201,113 @@ export namespace Provider {
         sessionID: provider.id,
       });
 
+      // Wrap fetch with verbose HTTP logging when --verbose is enabled
+      // This logs raw HTTP request/response details for debugging provider issues
+      // See: https://github.com/link-assistant/agent/issues/200
+      if (Flag.OPENCODE_VERBOSE) {
+        const innerFetch = options['fetch'];
+        options['fetch'] = async (
+          input: RequestInfo | URL,
+          init?: RequestInit
+        ): Promise<Response> => {
+          const url =
+            typeof input === 'string'
+              ? input
+              : input instanceof URL
+                ? input.toString()
+                : input.url;
+          const method = init?.method ?? 'GET';
+
+          // Sanitize headers - mask authorization values
+          const sanitizedHeaders: Record<string, string> = {};
+          const rawHeaders = init?.headers;
+          if (rawHeaders) {
+            const entries =
+              rawHeaders instanceof Headers
+                ? Array.from(rawHeaders.entries())
+                : Array.isArray(rawHeaders)
+                  ? rawHeaders
+                  : Object.entries(rawHeaders);
+            for (const [key, value] of entries) {
+              const lower = key.toLowerCase();
+              if (
+                lower === 'authorization' ||
+                lower === 'x-api-key' ||
+                lower === 'api-key'
+              ) {
+                sanitizedHeaders[key] =
+                  typeof value === 'string' && value.length > 8
+                    ? value.slice(0, 4) + '...' + value.slice(-4)
+                    : '[REDACTED]';
+              } else {
+                sanitizedHeaders[key] = String(value);
+              }
+            }
+          }
+
+          // Log request body preview (truncated)
+          let bodyPreview: string | undefined;
+          if (init?.body) {
+            const bodyStr =
+              typeof init.body === 'string'
+                ? init.body
+                : init.body instanceof ArrayBuffer ||
+                    init.body instanceof Uint8Array
+                  ? `[binary ${(init.body as ArrayBuffer).byteLength ?? (init.body as Uint8Array).length} bytes]`
+                  : undefined;
+            if (bodyStr && typeof bodyStr === 'string') {
+              bodyPreview =
+                bodyStr.length > 2000
+                  ? bodyStr.slice(0, 2000) +
+                    `... [truncated, total ${bodyStr.length} chars]`
+                  : bodyStr;
+            }
+          }
+
+          log.info(() => ({
+            message: 'HTTP request',
+            providerID: provider.id,
+            method,
+            url,
+            headers: sanitizedHeaders,
+            bodyPreview,
+          }));
+
+          const startMs = Date.now();
+          try {
+            const response = await innerFetch(input, init);
+            const durationMs = Date.now() - startMs;
+
+            log.info(() => ({
+              message: 'HTTP response',
+              providerID: provider.id,
+              method,
+              url,
+              status: response.status,
+              statusText: response.statusText,
+              durationMs,
+              responseHeaders: Object.fromEntries(response.headers.entries()),
+            }));
+
+            return response;
+          } catch (error) {
+            const durationMs = Date.now() - startMs;
+            log.error(() => ({
+              message: 'HTTP request failed',
+              providerID: provider.id,
+              method,
+              url,
+              durationMs,
+              error:
+                error instanceof Error
+                  ? { name: error.name, message: error.message }
+                  : String(error),
+            }));
+            throw error;
+          }
+        };
+      }
+
       // Check if we have a bundled provider first - this avoids runtime package installation
       // which can hang or timeout due to known Bun issues
       // @see https://github.com/link-assistant/agent/issues/173
@@ -1310,8 +1417,21 @@ export namespace Provider {
 
     // For synthetic providers, we don't need model info from the database
     const info = isSyntheticProvider ? null : provider.info.models[modelID];
-    if (!isSyntheticProvider && !info)
-      throw new ModelNotFoundError({ providerID, modelID });
+    if (!isSyntheticProvider && !info) {
+      const availableInProvider = Object.keys(provider.info.models).slice(
+        0,
+        10
+      );
+      const suggestion = `Model "${modelID}" not found in provider "${providerID}". Available models: ${availableInProvider.join(', ')}${Object.keys(provider.info.models).length > 10 ? ` (and ${Object.keys(provider.info.models).length - 10} more)` : ''}.`;
+      log.error(() => ({
+        message: 'model not found in provider',
+        providerID,
+        modelID,
+        availableModels: availableInProvider,
+        totalModels: Object.keys(provider.info.models).length,
+      }));
+      throw new ModelNotFoundError({ providerID, modelID, suggestion });
+    }
 
     try {
       const keyReal = `${providerID}/${modelID}`;

package/src/session/prompt.ts

@@ -362,10 +362,24 @@ export namespace SessionPrompt {
 
       let model;
       try {
+        // Log model resolution attempt for debugging (#200)
+        log.info(() => ({
+          message: 'resolving model',
+          providerID: lastUser.model.providerID,
+          modelID: lastUser.model.modelID,
+          sessionID,
+          step,
+        }));
         model = await Provider.getModel(
           lastUser.model.providerID,
           lastUser.model.modelID
         );
+        log.info(() => ({
+          message: 'model resolved successfully',
+          providerID: lastUser.model.providerID,
+          modelID: lastUser.model.modelID,
+          resolvedModelID: model.language?.modelId,
+        }));
       } catch (error) {
         // When an explicit provider is specified, do NOT silently fall back to default
         // This ensures user's explicit choice is respected
@@ -376,6 +390,8 @@ export namespace SessionPrompt {
           providerID: lastUser.model.providerID,
           modelID: lastUser.model.modelID,
           error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined,
+          hint: 'Check that the model exists in the provider. Use --verbose for more details.',
         }));
         // Re-throw the error so it can be handled by the caller
         throw error;