@link-assistant/agent 0.16.9 → 0.16.11

package/package.json

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

@@ -54,6 +54,37 @@ try {
 // Track if any errors occurred during execution
 let hasError = false;
 
+// Intercept stderr writes to ensure ALL output is JSON (#200)
+// Bun runtime may print errors in plain text format (e.g., stack traces with source code)
+// This interceptor wraps any non-JSON stderr output in a JSON envelope
+const originalStderrWrite = process.stderr.write.bind(process.stderr);
+process.stderr.write = function (chunk, encoding, callback) {
+  const str = typeof chunk === 'string' ? chunk : chunk.toString();
+  const trimmed = str.trim();
+  if (!trimmed) {
+    return originalStderrWrite(chunk, encoding, callback);
+  }
+
+  // Check if it's already valid JSON
+  if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+    try {
+      JSON.parse(trimmed);
+      // Already JSON, pass through
+      return originalStderrWrite(chunk, encoding, callback);
+    } catch (_e) {
+      // Not valid JSON, wrap it
+    }
+  }
+
+  // Wrap non-JSON stderr output in JSON envelope
+  const wrapped = `${JSON.stringify({
+    type: 'error',
+    errorType: 'RuntimeError',
+    message: trimmed,
+  })}\n`;
+  return originalStderrWrite(wrapped, encoding, callback);
+};
+
 // Install global error handlers to ensure non-zero exit codes
 // All output is JSON to ensure machine-parsability (#200)
 process.on('uncaughtException', (error) => {

package/src/provider/provider.ts

@@ -1289,6 +1289,85 @@ export namespace Provider {
               responseHeaders: Object.fromEntries(response.headers.entries()),
             }));
 
+            // Log response body for debugging provider failures
+            // For streaming responses (SSE/event-stream), tee() the stream so the AI SDK
+            // still receives the full stream while we asynchronously log a preview.
+            // For non-streaming responses, buffer the body and reconstruct the Response.
+            // See: https://github.com/link-assistant/agent/issues/204
+            const responseBodyMaxChars = 4000;
+            const contentType = response.headers.get('content-type') ?? '';
+            const isStreaming =
+              contentType.includes('event-stream') ||
+              contentType.includes('octet-stream');
+
+            if (response.body) {
+              if (isStreaming) {
+                // Tee the stream: one copy for AI SDK, one for logging
+                const [sdkStream, logStream] = response.body.tee();
+
+                // Consume log stream asynchronously (does not block SDK)
+                (async () => {
+                  try {
+                    const reader = logStream.getReader();
+                    const decoder = new TextDecoder();
+                    let bodyPreview = '';
+                    let truncated = false;
+                    while (true) {
+                      const { done, value } = await reader.read();
+                      if (done) break;
+                      if (!truncated) {
+                        const chunk = decoder.decode(value, { stream: true });
+                        bodyPreview += chunk;
+                        if (bodyPreview.length > responseBodyMaxChars) {
+                          bodyPreview = bodyPreview.slice(
+                            0,
+                            responseBodyMaxChars
+                          );
+                          truncated = true;
+                        }
+                      }
+                    }
+                    log.info(() => ({
+                      message: 'HTTP response body (stream)',
+                      providerID: provider.id,
+                      url,
+                      bodyPreview: truncated
+                        ? bodyPreview + `... [truncated]`
+                        : bodyPreview,
+                    }));
+                  } catch {
+                    // Ignore logging errors — do not affect the SDK stream
+                  }
+                })();
+
+                // Return response with the SDK's copy of the stream
+                return new Response(sdkStream, {
+                  status: response.status,
+                  statusText: response.statusText,
+                  headers: response.headers,
+                });
+              } else {
+                // Non-streaming: buffer body, log it, reconstruct Response
+                const bodyText = await response.text();
+                const bodyPreview =
+                  bodyText.length > responseBodyMaxChars
+                    ? bodyText.slice(0, responseBodyMaxChars) +
+                      `... [truncated, total ${bodyText.length} chars]`
+                    : bodyText;
+                log.info(() => ({
+                  message: 'HTTP response body',
+                  providerID: provider.id,
+                  url,
+                  bodyPreview,
+                }));
+                return new Response(bodyText, {
+                  status: response.status,
+                  statusText: response.statusText,
+                  headers: response.headers,
+                });
+              }
+            }
+
             return response;
           } catch (error) {
             const durationMs = Date.now() - startMs;
@@ -1416,21 +1495,70 @@ export namespace Provider {
       providerID === 'link-assistant' || providerID === 'link-assistant/cache';
 
     // For synthetic providers, we don't need model info from the database
-    const info = isSyntheticProvider ? null : provider.info.models[modelID];
+    let info = isSyntheticProvider ? null : provider.info.models[modelID];
     if (!isSyntheticProvider && !info) {
+      // Model not in provider's known list - try refreshing the cache first (#200)
+      // This handles stale bundled data or expired cache (1-hour TTL)
+      log.info(() => ({
+        message: 'model not in catalog - refreshing models cache',
+        providerID,
+        modelID,
+      }));
+      try {
+        await ModelsDev.refresh();
+        const freshDB = await ModelsDev.get();
+        const freshProvider = freshDB[providerID];
+        if (freshProvider?.models[modelID]) {
+          // Model found after refresh - update provider info and use it
+          provider.info.models[modelID] = freshProvider.models[modelID];
+          info = freshProvider.models[modelID];
+          log.info(() => ({
+            message: 'model found after cache refresh',
+            providerID,
+            modelID,
+          }));
+        }
+      } catch (refreshError) {
+        log.warn(() => ({
+          message: 'cache refresh failed',
+          error:
+            refreshError instanceof Error
+              ? refreshError.message
+              : String(refreshError),
+        }));
+      }
+    }
+
+    if (!isSyntheticProvider && !info) {
+      // Still not found after refresh - create fallback info and try anyway
+      // Provider may support unlisted models
       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',
+      log.warn(() => ({
+        message:
+          'model not in provider catalog after refresh - attempting anyway (may be unlisted)',
         providerID,
         modelID,
         availableModels: availableInProvider,
         totalModels: Object.keys(provider.info.models).length,
       }));
-      throw new ModelNotFoundError({ providerID, modelID, suggestion });
+
+      // Create a minimal fallback model info so SDK loading can proceed
+      // Use sensible defaults - the provider will reject if the model truly doesn't exist
+      info = {
+        id: modelID,
+        name: modelID,
+        release_date: '',
+        attachment: false,
+        reasoning: false,
+        temperature: true,
+        tool_call: true,
+        cost: { input: 0, output: 0 },
+        limit: { context: 128000, output: 16384 },
+        options: {},
+      } as ModelsDev.Model;
     }
 
     try {