@link-assistant/agent 0.16.14 → 0.16.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.16.14",
+  "version": "0.16.16",
   "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

@@ -1272,22 +1272,26 @@ export namespace Provider {
             }
           }
 
-          log.info(() => ({
-            message: 'HTTP request',
+          // Use direct (non-lazy) logging for HTTP request/response to ensure output
+          // is not lost when piped through external process wrappers (e.g., solve.mjs).
+          // The verbose check is already done above, so lazy evaluation is not needed here.
+          // See: https://github.com/link-assistant/agent/issues/211
+          log.info('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',
+            // Use direct (non-lazy) logging to ensure HTTP response details are captured
+            // See: https://github.com/link-assistant/agent/issues/211
+            log.info('HTTP response', {
               providerID: provider.id,
               method,
               url,
@@ -1295,7 +1299,7 @@ export namespace Provider {
               statusText: response.statusText,
               durationMs,
               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
@@ -1335,14 +1339,15 @@ export namespace Provider {
                         }
                       }
                     }
-                    log.info(() => ({
-                      message: 'HTTP response body (stream)',
+                    // Use direct (non-lazy) logging for stream body
+                    // See: https://github.com/link-assistant/agent/issues/211
+                    log.info('HTTP response body (stream)', {
                       providerID: provider.id,
                       url,
                       bodyPreview: truncated
                         ? bodyPreview + `... [truncated]`
                         : bodyPreview,
-                    }));
+                    });
                   } catch {
                     // Ignore logging errors — do not affect the SDK stream
                   }
@@ -1362,12 +1367,13 @@ export namespace Provider {
                     ? bodyText.slice(0, responseBodyMaxChars) +
                       `... [truncated, total ${bodyText.length} chars]`
                     : bodyText;
-                log.info(() => ({
-                  message: 'HTTP response body',
+                // Use direct (non-lazy) logging for non-streaming body
+                // See: https://github.com/link-assistant/agent/issues/211
+                log.info('HTTP response body', {
                   providerID: provider.id,
                   url,
                   bodyPreview,
-                }));
+                });
                 return new Response(bodyText, {
                   status: response.status,
                   statusText: response.statusText,
@@ -1379,8 +1385,9 @@ export namespace Provider {
             return response;
           } catch (error) {
             const durationMs = Date.now() - startMs;
-            log.error(() => ({
-              message: 'HTTP request failed',
+            // Use direct (non-lazy) logging for error path
+            // See: https://github.com/link-assistant/agent/issues/211
+            log.error('HTTP request failed', {
               providerID: provider.id,
               method,
               url,
@@ -1389,7 +1396,7 @@ export namespace Provider {
                 error instanceof Error
                   ? { name: error.name, message: error.message }
                   : String(error),
-            }));
+            });
             throw error;
           }
         };

package/src/session/index.ts

@@ -630,9 +630,14 @@ export namespace Session {
           }
         | undefined;
 
+      // Check if standard usage has valid data (inputTokens or outputTokens defined)
+      // Also check for zero-valued tokens (some providers set them to 0 instead of undefined)
       const standardUsageIsEmpty =
-        input.usage.inputTokens === undefined &&
-        input.usage.outputTokens === undefined;
+        (input.usage.inputTokens === undefined &&
+          input.usage.outputTokens === undefined) ||
+        (input.usage.inputTokens === 0 &&
+          input.usage.outputTokens === 0 &&
+          !input.usage.totalTokens);
 
       // If standard usage is empty but openrouter metadata has usage, use it as source
       let effectiveUsage = input.usage;
@@ -658,6 +663,41 @@ export namespace Session {
         };
       }
 
+      // If still empty, try providerMetadata.anthropic.usage as fallback
+      // Some providers (e.g., opencode using @ai-sdk/anthropic) return usage in
+      // Anthropic-specific metadata with snake_case keys (input_tokens, output_tokens)
+      // while the standard AI SDK usage object remains empty.
+      // See: https://github.com/link-assistant/agent/issues/211
+      if (standardUsageIsEmpty && !openrouterUsage) {
+        const anthropicUsage = input.metadata?.['anthropic']?.['usage'] as
+          | {
+              input_tokens?: number;
+              output_tokens?: number;
+              cache_creation_input_tokens?: number;
+              cache_read_input_tokens?: number;
+            }
+          | undefined;
+
+        if (
+          anthropicUsage &&
+          (anthropicUsage.input_tokens || anthropicUsage.output_tokens)
+        ) {
+          if (Flag.OPENCODE_VERBOSE) {
+            log.debug(() => ({
+              message:
+                'Standard usage empty, falling back to anthropic provider metadata',
+              anthropicUsage: JSON.stringify(anthropicUsage),
+            }));
+          }
+          effectiveUsage = {
+            ...input.usage,
+            inputTokens: anthropicUsage.input_tokens ?? 0,
+            outputTokens: anthropicUsage.output_tokens ?? 0,
+            cachedInputTokens: anthropicUsage.cache_read_input_tokens ?? 0,
+          };
+        }
+      }
+
       // Extract top-level cachedInputTokens
       const topLevelCachedInputTokens = safeNum(
         toNumber(effectiveUsage.cachedInputTokens, 'cachedInputTokens')