@link-assistant/agent 0.16.17 → 0.17.0

package/src/provider/provider.ts

@@ -1201,23 +1201,60 @@ export namespace Provider {
         sessionID: provider.id,
       });
 
-      // 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
-      // See: https://github.com/link-assistant/agent/issues/206
+      // Verbose HTTP logging is handled by the global fetch monkey-patch
+      // (installed in CLI middleware in index.js). The global patch catches ALL
+      // HTTP calls reliably, regardless of how the AI SDK passes fetch internally.
+      // This provider-level wrapper is kept as a fallback for environments where
+      // the global patch may not be installed (e.g., programmatic use).
+      // See: https://github.com/link-assistant/agent/issues/217
+      // See: https://github.com/link-assistant/agent/issues/215
       {
         const innerFetch = options['fetch'];
+        let verboseWrapperConfirmed = false;
+        let httpCallCount = 0;
+
+        log.info('provider SDK fetch chain configured', {
+          providerID: provider.id,
+          pkg,
+          globalVerboseFetchInstalled:
+            !!globalThis.__agentVerboseFetchInstalled,
+          verboseAtCreation: Flag.OPENCODE_VERBOSE,
+        });
+
         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) {
+          // Check verbose flag at call time — not at SDK creation time.
+          // When the global fetch monkey-patch is installed, it handles verbose
+          // logging for all calls. The provider wrapper is a fallback for
+          // environments without the global patch.
+          // See: https://github.com/link-assistant/agent/issues/217
+          if (
+            !Flag.OPENCODE_VERBOSE ||
+            globalThis.__agentVerboseFetchInstalled
+          ) {
             return innerFetch(input, init);
           }
 
+          httpCallCount++;
+          const callNum = httpCallCount;
+
+          // Log a one-time confirmation that the verbose wrapper is active for this provider.
+          // This diagnostic breadcrumb confirms the wrapper is in the fetch chain.
+          // Also write to stderr as a redundant channel — stdout JSON may be filtered by wrappers.
+          // See: https://github.com/link-assistant/agent/issues/215
+          if (!verboseWrapperConfirmed) {
+            verboseWrapperConfirmed = true;
+            log.info('verbose HTTP logging active', {
+              providerID: provider.id,
+            });
+            // Redundant stderr confirmation — visible even if stdout is piped/filtered
+            process.stderr.write(
+              `[verbose] HTTP logging active for provider: ${provider.id}\n`
+            );
+          }
+
           const url =
             typeof input === 'string'
               ? input
@@ -1226,50 +1263,64 @@ export namespace Provider {
                 : 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);
+          // Wrap all verbose logging in try/catch so it never breaks the actual HTTP request.
+          // If logging fails, the request must still proceed — logging is observability, not control flow.
+          // See: https://github.com/link-assistant/agent/issues/215
+          let sanitizedHeaders: Record<string, string> = {};
+          let bodyPreview: string | undefined;
+          try {
+            // Sanitize headers - mask authorization values
+            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 request body preview (truncated)
+            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 > 200000
+                    ? bodyStr.slice(0, 200000) +
+                      `... [truncated, total ${bodyStr.length} chars]`
+                    : bodyStr;
+              }
             }
+          } catch (prepError) {
+            // If header/body processing fails, log the error but continue with the request
+            log.warn('verbose logging: failed to prepare request details', {
+              providerID: provider.id,
+              error:
+                prepError instanceof Error
+                  ? prepError.message
+                  : String(prepError),
+            });
           }
 
           // Use direct (non-lazy) logging for HTTP request/response to ensure output
@@ -1277,7 +1328,9 @@ export namespace Provider {
           // 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', {
+            caller: `provider/${provider.id}`,
             providerID: provider.id,
+            callNum,
             method,
             url,
             headers: sanitizedHeaders,
@@ -1286,13 +1339,21 @@ export namespace Provider {
 
           const startMs = Date.now();
           try {
-            const response = await innerFetch(input, init);
+            // Pass Bun-specific verbose:true to get detailed connection debugging
+            // (prints request/response headers to stderr on socket errors).
+            // This is a no-op on non-Bun runtimes.
+            // See: https://bun.sh/docs/api/fetch
+            // See: https://github.com/link-assistant/agent/issues/215
+            const verboseInit = { ...init, verbose: true } as RequestInit;
+            const response = await innerFetch(input, verboseInit);
             const durationMs = Date.now() - startMs;
 
             // 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', {
+              caller: `provider/${provider.id}`,
               providerID: provider.id,
+              callNum,
               method,
               url,
               status: response.status,
@@ -1306,7 +1367,7 @@ export namespace Provider {
             // 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 responseBodyMaxChars = 200000;
             const contentType = response.headers.get('content-type') ?? '';
             const isStreaming =
               contentType.includes('event-stream') ||
@@ -1342,7 +1403,9 @@ export namespace Provider {
                     // Use direct (non-lazy) logging for stream body
                     // See: https://github.com/link-assistant/agent/issues/211
                     log.info('HTTP response body (stream)', {
+                      caller: `provider/${provider.id}`,
                       providerID: provider.id,
+                      callNum,
                       url,
                       bodyPreview: truncated
                         ? bodyPreview + `... [truncated]`
@@ -1370,7 +1433,9 @@ export namespace Provider {
                 // Use direct (non-lazy) logging for non-streaming body
                 // See: https://github.com/link-assistant/agent/issues/211
                 log.info('HTTP response body', {
+                  caller: `provider/${provider.id}`,
                   providerID: provider.id,
+                  callNum,
                   url,
                   bodyPreview,
                 });
@@ -1386,15 +1451,29 @@ export namespace Provider {
           } catch (error) {
             const durationMs = Date.now() - startMs;
             // Use direct (non-lazy) logging for error path
+            // Include stack trace and error cause for better debugging of socket errors
             // See: https://github.com/link-assistant/agent/issues/211
+            // See: https://github.com/link-assistant/agent/issues/215
             log.error('HTTP request failed', {
+              caller: `provider/${provider.id}`,
               providerID: provider.id,
+              callNum,
               method,
               url,
               durationMs,
               error:
                 error instanceof Error
-                  ? { name: error.name, message: error.message }
+                  ? {
+                      name: error.name,
+                      message: error.message,
+                      stack: error.stack,
+                      cause:
+                        error.cause instanceof Error
+                          ? error.cause.message
+                          : error.cause
+                            ? String(error.cause)
+                            : undefined,
+                    }
                   : String(error),
             });
             throw error;

package/src/session/compaction.ts

@@ -28,6 +28,14 @@ export namespace SessionCompaction {
     ),
   };
 
+  /**
+   * Safety margin ratio for compaction trigger.
+   * We trigger compaction at 85% of usable context to avoid hitting hard limits.
+   * This means we stop 15% before (context - output) tokens.
+   * @see https://github.com/link-assistant/agent/issues/217
+   */
+  export const OVERFLOW_SAFETY_MARGIN = 0.85;
+
   export function isOverflow(input: {
     tokens: MessageV2.Assistant['tokens'];
     model: ModelsDev.Model;
@@ -41,7 +49,56 @@ export namespace SessionCompaction {
       Math.min(input.model.limit.output, SessionPrompt.OUTPUT_TOKEN_MAX) ||
       SessionPrompt.OUTPUT_TOKEN_MAX;
     const usable = context - output;
-    return count > usable;
+    const safeLimit = Math.floor(usable * OVERFLOW_SAFETY_MARGIN);
+    const overflow = count > safeLimit;
+    log.info(() => ({
+      message: 'overflow check',
+      modelID: input.model.id,
+      contextLimit: context,
+      outputLimit: output,
+      usableContext: usable,
+      safeLimit,
+      safetyMargin: OVERFLOW_SAFETY_MARGIN,
+      currentTokens: count,
+      tokensBreakdown: {
+        input: input.tokens.input,
+        cacheRead: input.tokens.cache.read,
+        output: input.tokens.output,
+      },
+      overflow,
+      headroom: safeLimit - count,
+    }));
+    return overflow;
+  }
+
+  /**
+   * Compute context diagnostics for a given model and token usage.
+   * Used in step-finish parts to show context usage in JSON output.
+   * @see https://github.com/link-assistant/agent/issues/217
+   */
+  export function contextDiagnostics(input: {
+    tokens: { input: number; output: number; cache: { read: number } };
+    model: ModelsDev.Model;
+  }): MessageV2.ContextDiagnostics | undefined {
+    const contextLimit = input.model.limit.context;
+    if (contextLimit === 0) return undefined;
+    const outputLimit =
+      Math.min(input.model.limit.output, SessionPrompt.OUTPUT_TOKEN_MAX) ||
+      SessionPrompt.OUTPUT_TOKEN_MAX;
+    const usableContext = contextLimit - outputLimit;
+    const safeLimit = Math.floor(usableContext * OVERFLOW_SAFETY_MARGIN);
+    const currentTokens =
+      input.tokens.input + input.tokens.cache.read + input.tokens.output;
+    return {
+      contextLimit,
+      outputLimit,
+      usableContext,
+      safeLimit,
+      safetyMargin: OVERFLOW_SAFETY_MARGIN,
+      currentTokens,
+      headroom: safeLimit - currentTokens,
+      overflow: currentTokens > safeLimit,
+    };
   }
 
   export const PRUNE_MINIMUM = 20_000;
@@ -100,10 +157,27 @@ export namespace SessionCompaction {
     };
     abort: AbortSignal;
   }) {
+    log.info(() => ({
+      message: 'compaction process starting',
+      providerID: input.model.providerID,
+      modelID: input.model.modelID,
+      messageCount: input.messages.length,
+      sessionID: input.sessionID,
+    }));
     const model = await Provider.getModel(
       input.model.providerID,
       input.model.modelID
     );
+    if (Flag.OPENCODE_VERBOSE) {
+      log.info(() => ({
+        message: 'compaction model loaded',
+        providerID: model.providerID,
+        modelID: model.modelID,
+        npm: model.npm,
+        contextLimit: model.info.limit.context,
+        outputLimit: model.info.limit.output,
+      }));
+    }
     const system = [...SystemPrompt.summarize(model.providerID)];
     const msg = (await Session.updateMessage({
       id: Identifier.ascending('message'),
@@ -156,6 +230,19 @@ export namespace SessionCompaction {
     );
     // Defensive check: ensure modelMessages is iterable (AI SDK 6.0.1 compatibility fix)
     const safeModelMessages = Array.isArray(modelMessages) ? modelMessages : [];
+
+    if (Flag.OPENCODE_VERBOSE) {
+      log.info(() => ({
+        message: 'compaction streamText call',
+        providerID: model.providerID,
+        modelID: model.modelID,
+        systemPromptCount: system.length,
+        modelMessageCount: safeModelMessages.length,
+        filteredMessageCount: input.messages.length - safeModelMessages.length,
+        toolCall: model.info.tool_call,
+      }));
+    }
+
     const result = await processor.process(() =>
       streamText({
         onError(error) {

package/src/session/message-v2.ts

@@ -240,6 +240,27 @@ export namespace MessageV2 {
     });
   export type ModelInfo = z.infer<typeof ModelInfo>;
 
+  /**
+   * Context diagnostic info for step-finish parts.
+   * Shows model context limits and current usage to help debug compaction decisions.
+   * @see https://github.com/link-assistant/agent/issues/217
+   */
+  export const ContextDiagnostics = z
+    .object({
+      contextLimit: z.number(),
+      outputLimit: z.number(),
+      usableContext: z.number(),
+      safeLimit: z.number(),
+      safetyMargin: z.number(),
+      currentTokens: z.number(),
+      headroom: z.number(),
+      overflow: z.boolean(),
+    })
+    .meta({
+      ref: 'ContextDiagnostics',
+    });
+  export type ContextDiagnostics = z.infer<typeof ContextDiagnostics>;
+
   export const StepFinishPart = PartBase.extend({
     type: z.literal('step-finish'),
     reason: z.string(),
@@ -257,6 +278,9 @@ export namespace MessageV2 {
     // Model info included when --output-response-model is enabled
     // @see https://github.com/link-assistant/agent/issues/179
     model: ModelInfo.optional(),
+    // Context diagnostics for debugging compaction decisions
+    // @see https://github.com/link-assistant/agent/issues/217
+    context: ContextDiagnostics.optional(),
   }).meta({
     ref: 'StepFinishPart',
   });

package/src/session/processor.ts

@@ -17,6 +17,7 @@ import { Bus } from '../bus';
 import { SessionRetry } from './retry';
 import { SessionStatus } from './status';
 import { Flag } from '../flag/flag';
+import { SessionCompaction } from './compaction';
 
 export namespace SessionProcessor {
   const DOOM_LOOP_THRESHOLD = 3;
@@ -366,6 +367,22 @@ export namespace SessionProcessor {
                         }
                       : undefined;
 
+                  // Compute context diagnostics for JSON output
+                  // @see https://github.com/link-assistant/agent/issues/217
+                  const contextDiag = SessionCompaction.contextDiagnostics({
+                    tokens: usage.tokens,
+                    model: input.model,
+                  });
+
+                  if (Flag.OPENCODE_VERBOSE && contextDiag) {
+                    log.info(() => ({
+                      message: 'step-finish context diagnostics',
+                      providerID: input.providerID,
+                      modelID: input.model.id,
+                      ...contextDiag,
+                    }));
+                  }
+
                   await Session.updatePart({
                     id: Identifier.ascending('part'),
                     reason: finishReason,
@@ -376,6 +393,7 @@ export namespace SessionProcessor {
                     tokens: usage.tokens,
                     cost: usage.cost,
                     model: modelInfo,
+                    context: contextDiag,
                   });
                   await Session.updateMessage(input.assistantMessage);
                   if (snapshot) {

package/src/session/summary.ts

@@ -14,6 +14,7 @@ import { Instance } from '../project/instance';
 import { Storage } from '../storage/storage';
 import { Bus } from '../bus';
 import { Flag } from '../flag/flag';
+import { Token } from '../util/token';
 
 export namespace SessionSummary {
   const log = Log.create({ service: 'session.summary' });
@@ -80,34 +81,89 @@ export namespace SessionSummary {
     };
     await Session.updateMessage(userMsg);
 
-    // Skip AI-powered summarization if disabled (default)
-    // See: https://github.com/link-assistant/agent/issues/179
+    // Skip AI-powered summarization if disabled
+    // See: https://github.com/link-assistant/agent/issues/217
     if (!Flag.SUMMARIZE_SESSION) {
       log.info(() => ({
         message: 'session summarization disabled',
-        hint: 'Enable with --summarize-session flag or AGENT_SUMMARIZE_SESSION=true',
+        hint: 'Enable with --summarize-session flag (enabled by default) or AGENT_SUMMARIZE_SESSION=true',
       }));
       return;
     }
 
     const assistantMsg = messages.find((m) => m.info.role === 'assistant')!
       .info as MessageV2.Assistant;
-    const small = await Provider.getSmallModel(assistantMsg.providerID);
-    if (!small) return;
+
+    // Use the same model as the main session (--model) instead of a small model
+    // This ensures consistent behavior and uses the model the user explicitly requested
+    // See: https://github.com/link-assistant/agent/issues/217
+    log.info(() => ({
+      message: 'loading model for summarization',
+      providerID: assistantMsg.providerID,
+      modelID: assistantMsg.modelID,
+      hint: 'Using same model as --model (not a small model)',
+    }));
+    const model = await Provider.getModel(
+      assistantMsg.providerID,
+      assistantMsg.modelID
+    ).catch(() => null);
+    if (!model) {
+      log.info(() => ({
+        message: 'could not load session model for summarization, skipping',
+        providerID: assistantMsg.providerID,
+        modelID: assistantMsg.modelID,
+      }));
+      return;
+    }
+
+    if (Flag.OPENCODE_VERBOSE) {
+      log.info(() => ({
+        message: 'summarization model loaded',
+        providerID: model.providerID,
+        modelID: model.modelID,
+        npm: model.npm,
+        contextLimit: model.info.limit.context,
+        outputLimit: model.info.limit.output,
+        reasoning: model.info.reasoning,
+        toolCall: model.info.tool_call,
+      }));
+    }
 
     const textPart = msgWithParts.parts.find(
       (p) => p.type === 'text' && !p.synthetic
     ) as MessageV2.TextPart;
     if (textPart && !userMsg.summary?.title) {
+      const titleMaxTokens = model.info.reasoning ? 1500 : 20;
+      const systemPrompts = SystemPrompt.title(model.providerID);
+      const userContent = `
+              The following is the text to summarize:
+              <text>
+              ${textPart?.text ?? ''}
+              </text>
+            `;
+
+      if (Flag.OPENCODE_VERBOSE) {
+        log.info(() => ({
+          message: 'generating title via API',
+          providerID: model.providerID,
+          modelID: model.modelID,
+          maxOutputTokens: titleMaxTokens,
+          systemPromptCount: systemPrompts.length,
+          userContentLength: userContent.length,
+          userContentTokenEstimate: Token.estimate(userContent),
+          userContentPreview: userContent.substring(0, 500),
+        }));
+      }
+
       const result = await generateText({
-        maxOutputTokens: small.info.reasoning ? 1500 : 20,
+        maxOutputTokens: titleMaxTokens,
         providerOptions: ProviderTransform.providerOptions(
-          small.npm,
-          small.providerID,
+          model.npm,
+          model.providerID,
           {}
         ),
         messages: [
-          ...SystemPrompt.title(small.providerID).map(
+          ...systemPrompts.map(
             (x): ModelMessage => ({
               role: 'system',
               content: x,
@@ -115,17 +171,22 @@ export namespace SessionSummary {
           ),
           {
             role: 'user' as const,
-            content: `
-              The following is the text to summarize:
-              <text>
-              ${textPart?.text ?? ''}
-              </text>
-            `,
+            content: userContent,
           },
         ],
-        headers: small.info.headers,
-        model: small.language,
+        headers: model.info.headers,
+        model: model.language,
       });
+
+      if (Flag.OPENCODE_VERBOSE) {
+        log.info(() => ({
+          message: 'title API response received',
+          providerID: model.providerID,
+          modelID: model.modelID,
+          titleLength: result.text.length,
+          usage: result.usage,
+        }));
+      }
       log.info(() => ({ message: 'title', title: result.text }));
       userMsg.summary.title = result.text;
       await Session.updateMessage(userMsg);
@@ -146,8 +207,24 @@ export namespace SessionSummary {
       if (!summary || diffs.length > 0) {
         // Pre-convert messages to ModelMessage format (async in AI SDK 6.0+)
         const modelMessages = await MessageV2.toModelMessage(messages);
+        const conversationContent = JSON.stringify(modelMessages);
+
+        if (Flag.OPENCODE_VERBOSE) {
+          log.info(() => ({
+            message: 'generating body summary via API',
+            providerID: model.providerID,
+            modelID: model.modelID,
+            maxOutputTokens: 100,
+            conversationLength: conversationContent.length,
+            conversationTokenEstimate: Token.estimate(conversationContent),
+            messageCount: modelMessages.length,
+            diffsCount: diffs.length,
+            hasPriorSummary: !!summary,
+          }));
+        }
+
         const result = await generateText({
-          model: small.language,
+          model: model.language,
           maxOutputTokens: 100,
           messages: [
             {
@@ -155,14 +232,36 @@ export namespace SessionSummary {
               content: `
             Summarize the following conversation into 2 sentences MAX explaining what the assistant did and why. Do not explain the user's input. Do not speak in the third person about the assistant.
             <conversation>
-            ${JSON.stringify(modelMessages)}
+            ${conversationContent}
             </conversation>
             `,
             },
           ],
-          headers: small.info.headers,
-        }).catch(() => {});
-        if (result) summary = result.text;
+          headers: model.info.headers,
+        }).catch((err) => {
+          if (Flag.OPENCODE_VERBOSE) {
+            log.warn(() => ({
+              message: 'body summary API call failed',
+              providerID: model.providerID,
+              modelID: model.modelID,
+              error: err instanceof Error ? err.message : String(err),
+              stack: err instanceof Error ? err.stack : undefined,
+            }));
+          }
+          return undefined;
+        });
+        if (result) {
+          if (Flag.OPENCODE_VERBOSE) {
+            log.info(() => ({
+              message: 'body summary API response received',
+              providerID: model.providerID,
+              modelID: model.modelID,
+              summaryLength: result.text.length,
+              usage: result.usage,
+            }));
+          }
+          summary = result.text;
+        }
       }
       userMsg.summary.body = summary;
       log.info(() => ({ message: 'body', body: summary }));