@link-assistant/agent 0.16.18 → 0.17.0

package/package.json

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

@@ -103,13 +103,19 @@ export namespace Flag {
   }
 
   // Session summarization configuration
-  // When disabled, session summaries will not be generated
-  // This saves tokens and prevents rate limit issues with free tier models
-  // See: https://github.com/link-assistant/agent/issues/179
-  export let SUMMARIZE_SESSION = truthyCompat(
-    'LINK_ASSISTANT_AGENT_SUMMARIZE_SESSION',
-    'AGENT_SUMMARIZE_SESSION'
-  );
+  // Enabled by default - generates AI-powered session summaries using the same model
+  // Can be disabled with --no-summarize-session or AGENT_SUMMARIZE_SESSION=false
+  // See: https://github.com/link-assistant/agent/issues/217
+  export let SUMMARIZE_SESSION = (() => {
+    const value = (
+      getEnv(
+        'LINK_ASSISTANT_AGENT_SUMMARIZE_SESSION',
+        'AGENT_SUMMARIZE_SESSION'
+      ) ?? ''
+    ).toLowerCase();
+    if (value === 'false' || value === '0') return false;
+    return true; // Default to true
+  })();
 
   // Allow setting summarize-session mode programmatically (e.g., from CLI --summarize-session flag)
   export function setSummarizeSession(value: boolean) {

package/src/index.js

@@ -733,8 +733,9 @@ async function main() {
             })
             .option('summarize-session', {
               type: 'boolean',
-              description: 'Generate AI session summaries',
-              default: false,
+              description:
+                'Generate AI session summaries (default: true). Use --no-summarize-session to disable.',
+              default: true,
             }),
         handler: async (argv) => {
           // Check both CLI flag and environment variable for compact JSON mode
@@ -917,7 +918,10 @@ async function main() {
         if (argv['output-response-model'] === false) {
           Flag.setOutputResponseModel(false);
         }
-        if (argv['summarize-session'] === true) {
+        // summarize-session is enabled by default, only set if explicitly disabled
+        if (argv['summarize-session'] === false) {
+          Flag.setSummarizeSession(false);
+        } else {
           Flag.setSummarizeSession(true);
         }
         // retry-on-rate-limits is enabled by default, only set if explicitly disabled
@@ -929,6 +933,15 @@ async function main() {
           level: Flag.OPENCODE_VERBOSE ? 'DEBUG' : 'INFO',
           compactJson: isCompact,
         });
+
+        // Monkey-patch globalThis.fetch for raw HTTP logging in --verbose mode.
+        // Catches ALL HTTP calls regardless of AI SDK fetch passthrough. (#217)
+        if (!globalThis.__agentVerboseFetchInstalled) {
+          globalThis.fetch = createVerboseFetch(globalThis.fetch, {
+            caller: 'global',
+          });
+          globalThis.__agentVerboseFetchInstalled = true;
+        }
       })
       .fail((msg, err, yargs) => {
         // Handle errors from command handlers

package/src/provider/provider.ts

@@ -1201,25 +1201,23 @@ 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 at SDK creation time that the fetch wrapper is installed.
-        // This runs once per provider SDK creation (not per request).
-        // If verbose is off at creation time, the per-request check still applies.
-        // See: https://github.com/link-assistant/agent/issues/215
-        log.info('verbose HTTP fetch wrapper installed', {
+        log.info('provider SDK fetch chain configured', {
           providerID: provider.id,
           pkg,
+          globalVerboseFetchInstalled:
+            !!globalThis.__agentVerboseFetchInstalled,
           verboseAtCreation: Flag.OPENCODE_VERBOSE,
         });
 
@@ -1227,8 +1225,15 @@ export namespace Provider {
           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);
           }
 
@@ -1301,8 +1306,8 @@ export namespace Provider {
                     : undefined;
               if (bodyStr && typeof bodyStr === 'string') {
                 bodyPreview =
-                  bodyStr.length > 2000
-                    ? bodyStr.slice(0, 2000) +
+                  bodyStr.length > 200000
+                    ? bodyStr.slice(0, 200000) +
                       `... [truncated, total ${bodyStr.length} chars]`
                     : bodyStr;
               }
@@ -1362,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') ||

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 }));

package/src/util/verbose-fetch.ts

@@ -64,7 +64,7 @@ export function sanitizeHeaders(
  */
 export function bodyPreview(
   body: BodyInit | null | undefined,
-  maxChars = 2000
+  maxChars = 200000
 ): string | undefined {
   if (!body) return undefined;
 
@@ -89,9 +89,9 @@ export function bodyPreview(
 export interface VerboseFetchOptions {
   /** Identifier for the caller (e.g. 'webfetch', 'auth-plugins', 'config') */
   caller: string;
-  /** Maximum chars for response body preview (default: 4000) */
+  /** Maximum chars for response body preview (default: 200000) */
   responseBodyMaxChars?: number;
-  /** Maximum chars for request body preview (default: 2000) */
+  /** Maximum chars for request body preview (default: 200000) */
   requestBodyMaxChars?: number;
 }
 
@@ -113,8 +113,8 @@ export function createVerboseFetch(
 ): typeof fetch {
   const {
     caller,
-    responseBodyMaxChars = 4000,
-    requestBodyMaxChars = 2000,
+    responseBodyMaxChars = 200000,
+    requestBodyMaxChars = 200000,
   } = options;
 
   return async (