@link-assistant/agent 0.16.10 → 0.16.12

package/package.json

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

@@ -1201,15 +1201,23 @@ 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
+      // Wrap fetch with verbose HTTP logging for debugging provider issues.
+      // IMPORTANT: The verbose check is done at call time (not SDK creation time)
+      // because the SDK is cached and Flag.OPENCODE_VERBOSE may change after creation.
+      // When verbose is disabled, the wrapper is a no-op passthrough with negligible overhead.
       // See: https://github.com/link-assistant/agent/issues/200
-      if (Flag.OPENCODE_VERBOSE) {
+      // See: https://github.com/link-assistant/agent/issues/206
+      {
         const innerFetch = options['fetch'];
         options['fetch'] = async (
           input: RequestInfo | URL,
           init?: RequestInit
         ): Promise<Response> => {
+          // Check verbose flag at call time — not at SDK creation time
+          if (!Flag.OPENCODE_VERBOSE) {
+            return innerFetch(input, init);
+          }
+
           const url =
             typeof input === 'string'
               ? input
@@ -1289,6 +1297,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;