byterover-cli 1.8.0 → 2.1.0

package/dist/agent/infra/llm/providers/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Provider Module Types
+ *
+ * Defines the ProviderModule interface — the core abstraction for LLM providers.
+ * Each provider is a self-contained module (data + factory) following opencode's pattern.
+ */
+import type { IContentGenerator } from '../../../core/interfaces/i-content-generator.js';
+/**
+ * Provider authentication type.
+ */
+export type ProviderAuthType = 'api-key' | 'internal';
+/**
+ * Internal provider type determines formatter/tokenizer selection.
+ * - 'claude': Uses ClaudeMessageFormatter + ClaudeTokenizer
+ * - 'gemini': Uses GeminiMessageFormatter + GeminiTokenizer
+ * - 'openai': Uses OpenRouterMessageFormatter + OpenRouterTokenizer
+ */
+export type ProviderType = 'claude' | 'gemini' | 'openai';
+/**
+ * Configuration passed to provider generator factories.
+ * Each provider uses the fields relevant to it.
+ */
+export interface GeneratorFactoryConfig {
+    /** API key for key-based auth providers */
+    readonly apiKey?: string;
+    /** API base URL (for OpenAI-compatible providers) */
+    readonly baseUrl?: string;
+    /** Custom HTTP headers */
+    readonly headers?: Record<string, string>;
+    /** ByteRover internal HTTP config (kept for backward compat) */
+    readonly httpConfig?: Record<string, unknown>;
+    /** HTTP Referer header (for OpenRouter) */
+    readonly httpReferer?: string;
+    /** Maximum tokens in the response */
+    readonly maxTokens: number;
+    /** Model identifier */
+    readonly model: string;
+    /** Site name (for OpenRouter) */
+    readonly siteName?: string;
+    /** Temperature for randomness */
+    readonly temperature: number;
+    /** Request timeout in milliseconds */
+    readonly timeout?: number;
+}
+/**
+ * Self-contained provider module.
+ *
+ * Each provider exports a ProviderModule that contains all its metadata
+ * and a factory function to create its IContentGenerator.
+ * This follows opencode's pattern of providers as "data + factory".
+ */
+export interface ProviderModule {
+    /** URL where users can get an API key */
+    readonly apiKeyUrl?: string;
+    /** Provider authentication type */
+    readonly authType: ProviderAuthType;
+    /** API base URL (for OpenAI-compatible providers) */
+    readonly baseUrl?: string;
+    /** Category for grouping in UI */
+    readonly category: 'other' | 'popular';
+    /** Factory: create an IContentGenerator for this provider */
+    createGenerator(config: GeneratorFactoryConfig): IContentGenerator;
+    /** Default model to use when first connected */
+    readonly defaultModel: string;
+    /** Short description */
+    readonly description: string;
+    /** Environment variable names for API key auto-detection */
+    readonly envVars: readonly string[];
+    /** Unique provider identifier */
+    readonly id: string;
+    /** Display name */
+    readonly name: string;
+    /** Priority for display order (lower = higher priority) */
+    readonly priority: number;
+    /** Internal provider type — determines formatter/tokenizer selection */
+    readonly providerType: ProviderType;
+}

package/dist/agent/infra/llm/providers/types.js

@@ -0,0 +1,7 @@
+/**
+ * Provider Module Types
+ *
+ * Defines the ProviderModule interface — the core abstraction for LLM providers.
+ * Each provider is a self-contained module (data + factory) following opencode's pattern.
+ */
+export {};

package/dist/agent/infra/llm/providers/vercel.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Vercel Provider Module
+ *
+ * Vercel AI-powered models via @ai-sdk/vercel.
+ */
+import type { ProviderModule } from './types.js';
+export declare const vercelProvider: ProviderModule;

package/dist/agent/infra/llm/providers/vercel.js

@@ -0,0 +1,32 @@
+/**
+ * Vercel Provider Module
+ *
+ * Vercel AI-powered models via @ai-sdk/vercel.
+ */
+import { createVercel } from '@ai-sdk/vercel';
+import { AiSdkContentGenerator } from '../generators/ai-sdk-content-generator.js';
+export const vercelProvider = {
+    apiKeyUrl: 'https://v0.dev/chat/settings/keys',
+    authType: 'api-key',
+    baseUrl: 'https://api.v0.dev/v1',
+    category: 'other',
+    createGenerator(config) {
+        const provider = createVercel({
+            apiKey: config.apiKey,
+            headers: {
+                'http-referer': 'https://byterover.dev',
+                'x-title': 'byterover-cli',
+            },
+        });
+        return new AiSdkContentGenerator({
+            model: provider(config.model),
+        });
+    },
+    defaultModel: 'v0-1.5-md',
+    description: 'Vercel AI-powered models',
+    envVars: ['VERCEL_API_KEY'],
+    id: 'vercel',
+    name: 'Vercel',
+    priority: 15,
+    providerType: 'openai',
+};

package/dist/agent/infra/llm/providers/xai.d.ts

@@ -0,0 +1,7 @@
+/**
+ * xAI (Grok) Provider Module
+ *
+ * Direct access to Grok models via @ai-sdk/xai.
+ */
+import type { ProviderModule } from './types.js';
+export declare const xaiProvider: ProviderModule;

package/dist/agent/infra/llm/providers/xai.js

@@ -0,0 +1,26 @@
+/**
+ * xAI (Grok) Provider Module
+ *
+ * Direct access to Grok models via @ai-sdk/xai.
+ */
+import { createXai } from '@ai-sdk/xai';
+import { AiSdkContentGenerator } from '../generators/ai-sdk-content-generator.js';
+export const xaiProvider = {
+    apiKeyUrl: 'https://console.x.ai',
+    authType: 'api-key',
+    baseUrl: 'https://api.x.ai/v1',
+    category: 'popular',
+    createGenerator(config) {
+        const provider = createXai({ apiKey: config.apiKey });
+        return new AiSdkContentGenerator({
+            model: provider(config.model),
+        });
+    },
+    defaultModel: 'grok-3',
+    description: 'Grok models by xAI',
+    envVars: ['XAI_API_KEY'],
+    id: 'xai',
+    name: 'xAI (Grok)',
+    priority: 6,
+    providerType: 'openai',
+};

package/dist/agent/infra/llm/retry/retry-policy.d.ts

@@ -73,3 +73,16 @@ export declare function isRetryableError(error: unknown, policy: RetryPolicy): b
  * @returns Delay in milliseconds
  */
 export declare function calculateRetryDelay(attempt: number, policy: RetryPolicy): number;
+export declare const RATE_LIMIT_FALLBACK_DELAY_MS = 65000;
+/**
+ * Extract the correct retry delay from an AI provider 429 error.
+ *
+ * Tries all known provider patterns in priority order and returns the
+ * delay in milliseconds (including a +2s buffer), or undefined if none found.
+ *
+ * Caller should fall back to RATE_LIMIT_FALLBACK_DELAY_MS when this returns undefined.
+ *
+ * @param error - The caught error (expected to be AI_APICallError from Vercel AI SDK)
+ * @returns Delay in milliseconds, or undefined
+ */
+export declare function extractRateLimitDelay(error: unknown): number | undefined;

package/dist/agent/infra/llm/retry/retry-policy.js

@@ -26,6 +26,7 @@ export const DEFAULT_RETRY_POLICY = {
         'ECONNREFUSED',
         'ENOTFOUND',
         'rate_limit',
+        'rate limit',
         'overloaded',
         'capacity',
         'timeout',
@@ -155,3 +156,209 @@ export function calculateRetryDelay(attempt, policy) {
     // Ensure delay is at least 0
     return Math.max(0, Math.round(cappedDelay + jitter));
 }
+// ─── Rate Limit Delay Extraction ────────────────────────────────────────────
+//
+// When providers return HTTP 429, they embed retry timing in different ways:
+//   - Anthropic, OpenAI, Groq, xAI, Mistral: standard `retry-after` header (seconds)
+//   - OpenAI Azure: `retry-after-ms` header (milliseconds)
+//   - Anthropic backup: `anthropic-ratelimit-*-reset` header (RFC 3339 timestamp)
+//   - OpenRouter: `X-RateLimit-Reset` header (Unix timestamp in milliseconds)
+//   - OpenAI/Groq fallback: `x-ratelimit-reset-tokens` header (Go duration, e.g. "6m0s")
+//   - Gemini: NO headers — uses `retryDelay` inside `google.rpc.RetryInfo` in the body
+//
+// This fallback is used when a 429 fires but no header parsing yields a result:
+export const RATE_LIMIT_FALLBACK_DELAY_MS = 65_000;
+/**
+ * Normalize raw headers object to lowercase keys for case-insensitive lookup.
+ * Providers like OpenRouter use capitalized header names (e.g. "X-RateLimit-Reset").
+ */
+function normalizeHeaders(raw) {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const result = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (typeof value === 'string') {
+            result[key.toLowerCase()] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Parse a Go duration string (used by OpenAI and Groq) into milliseconds.
+ *
+ * Examples: "6m0s" → 360000, "2m59.56s" → 179560, "120ms" → 120, "1s" → 1000
+ *
+ * Key subtlety: must parse "ms" before "m" to avoid matching the "m" inside "ms"
+ * as minutes. Uses negative lookahead on "m" to prevent this.
+ */
+function parseGoDuration(duration) {
+    let totalMs = 0;
+    let matched = false;
+    // Minutes: "6m", "2m" — use negative lookahead so "m" in "ms" doesn't match
+    const minuteMatch = /(\d+(?:\.\d+)?)m(?!s)/.exec(duration);
+    if (minuteMatch) {
+        totalMs += Number.parseFloat(minuteMatch[1]) * 60 * 1000;
+        matched = true;
+    }
+    // Milliseconds: "120ms", "17ms" — must check before seconds since "ms" ends with "s"
+    const msMatch = /(\d+(?:\.\d+)?)ms/.exec(duration);
+    if (msMatch) {
+        totalMs += Math.ceil(Number.parseFloat(msMatch[1]));
+        matched = true;
+    }
+    else {
+        // Seconds (only when no "ms" match): "0s", "1s", "59.56s", "7.66s"
+        const secMatch = /(\d+(?:\.\d+)?)s/.exec(duration);
+        if (secMatch) {
+            totalMs += Math.ceil(Number.parseFloat(secMatch[1]) * 1000);
+            matched = true;
+        }
+    }
+    return matched ? totalMs : undefined;
+}
+/**
+ * Extract Gemini's retry delay from the `google.rpc.RetryInfo` details in the body.
+ *
+ * Gemini 429 body shape:
+ * { error: { details: [{ "@type": "...RetryInfo", "retryDelay": "53s" }] } }
+ *
+ * The `retryDelay` is a duration string like "53s" or "1.5s".
+ */
+function extractGeminiRetryDelay(body) {
+    if (!body || typeof body !== 'object')
+        return undefined;
+    const b = body;
+    const error = b.error;
+    const details = error?.details;
+    if (!Array.isArray(details))
+        return undefined;
+    for (const detail of details) {
+        const type = detail['@type'];
+        if (typeof type === 'string' && type.includes('RetryInfo')) {
+            const { retryDelay } = detail;
+            if (typeof retryDelay === 'string') {
+                const match = /^(\d+(?:\.\d+)?)s$/.exec(retryDelay);
+                if (match) {
+                    return Math.ceil(Number.parseFloat(match[1]) * 1000) + 2000;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Try to parse Gemini retry delay from a raw JSON string body.
+ */
+function parseGeminiBodyString(body) {
+    if (typeof body !== 'string')
+        return undefined;
+    try {
+        return extractGeminiRetryDelay(JSON.parse(body));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Extract the correct retry delay from an AI provider 429 error.
+ *
+ * Tries all known provider patterns in priority order and returns the
+ * delay in milliseconds (including a +2s buffer), or undefined if none found.
+ *
+ * Caller should fall back to RATE_LIMIT_FALLBACK_DELAY_MS when this returns undefined.
+ *
+ * @param error - The caught error (expected to be AI_APICallError from Vercel AI SDK)
+ * @returns Delay in milliseconds, or undefined
+ */
+/**
+ * Extract retry delay from normalized response headers.
+ * Handles paths 1–5 (all header-based providers).
+ */
+function extractDelayFromHeaders(headers) {
+    // ── Path 1: Standard retry-after header ──────────────────────────────────
+    // Anthropic, OpenAI, Groq, xAI, Mistral all use this (integer seconds).
+    const retryAfter = headers['retry-after'];
+    if (retryAfter !== undefined) {
+        const seconds = Number.parseInt(retryAfter, 10);
+        if (!Number.isNaN(seconds) && seconds >= 0) {
+            return (seconds + 2) * 1000; // +2s buffer
+        }
+        // Fallback: some CDN proxies return an HTTP-date string instead of seconds
+        const dateMs = new Date(retryAfter).getTime();
+        if (!Number.isNaN(dateMs)) {
+            const delay = dateMs - Date.now();
+            if (delay > 0)
+                return delay + 2000;
+        }
+    }
+    // ── Path 2: retry-after-ms (Azure OpenAI, millisecond precision) ─────────
+    const retryAfterMs = headers['retry-after-ms'];
+    if (retryAfterMs !== undefined) {
+        const ms = Number.parseFloat(retryAfterMs);
+        if (!Number.isNaN(ms) && ms > 0) {
+            return Math.ceil(ms) + 2000;
+        }
+    }
+    // ── Path 3: Anthropic reset timestamp backup ──────────────────────────────
+    // anthropic-ratelimit-input-tokens-reset (RFC 3339). retry-after should
+    // always be present for Anthropic, but this handles edge cases.
+    const anthropicReset = headers['anthropic-ratelimit-input-tokens-reset'] ??
+        headers['anthropic-ratelimit-tokens-reset'];
+    if (anthropicReset !== undefined) {
+        const resetMs = new Date(anthropicReset).getTime() - Date.now();
+        if (resetMs > 0)
+            return resetMs + 2000;
+    }
+    // ── Path 4: OpenRouter X-RateLimit-Reset (Unix timestamp in milliseconds) ─
+    // OpenRouter is unique: it uses a Unix ms timestamp, not a duration string.
+    // Heuristic: any numeric value > 1e12 is a Unix ms timestamp (year ≥ 2001).
+    const openrouterReset = headers['x-ratelimit-reset'];
+    if (openrouterReset !== undefined) {
+        const value = Number.parseInt(openrouterReset, 10);
+        if (!Number.isNaN(value) && value > 1_000_000_000_000) {
+            const delay = value - Date.now();
+            if (delay > 0)
+                return delay + 2000;
+        }
+    }
+    // ── Path 5: OpenAI/Groq Go-duration reset headers (fallback) ─────────────
+    // x-ratelimit-reset-tokens / x-ratelimit-reset-requests: "6m0s", "17ms"
+    // Only reached if retry-after is absent (shouldn't happen for these providers,
+    // but acts as a safety net).
+    const goReset = headers['x-ratelimit-reset-tokens'] ??
+        headers['x-ratelimit-reset-requests'];
+    if (goReset !== undefined) {
+        const durationMs = parseGoDuration(goReset);
+        if (durationMs !== undefined && durationMs > 0) {
+            return durationMs + 2000;
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract the correct retry delay from an AI provider 429 error.
+ *
+ * Tries all known provider patterns in priority order and returns the
+ * delay in milliseconds (including a +2s buffer), or undefined if none found.
+ *
+ * Caller should fall back to RATE_LIMIT_FALLBACK_DELAY_MS when this returns undefined.
+ *
+ * @param error - The caught error (expected to be AI_APICallError from Vercel AI SDK)
+ * @returns Delay in milliseconds, or undefined
+ */
+export function extractRateLimitDelay(error) {
+    if (!error || typeof error !== 'object')
+        return undefined;
+    const e = error;
+    // Paths 1–5: header-based providers
+    const headers = normalizeHeaders(e.responseHeaders);
+    if (headers) {
+        const headerDelay = extractDelayFromHeaders(headers);
+        if (headerDelay !== undefined)
+            return headerDelay;
+    }
+    // ── Path 6: Gemini retryDelay in response body (no headers on Gemini) ──────
+    // Gemini embeds timing in google.rpc.RetryInfo inside the JSON body.
+    // Try e.data first (AI SDK may pre-parse the body), then e.responseBody (raw string).
+    return extractGeminiRetryDelay(e.data) ?? parseGeminiBodyString(e.responseBody);
+}

package/dist/agent/infra/llm/tokenizers/openrouter-tokenizer.js

@@ -20,7 +20,7 @@ export class OpenRouterTokenizer {
     constructor(model) {
         // Look up model-specific ratio from registry, fallback to default
         this.charsPerToken = model
-            ? (getCharsPerToken('openrouter', model) ?? DEFAULT_CHARS_PER_TOKEN)
+            ? (getCharsPerToken('openai', model) ?? DEFAULT_CHARS_PER_TOKEN)
             : DEFAULT_CHARS_PER_TOKEN;
     }
     /**

package/dist/agent/infra/llm/tool-output-processor.d.ts

@@ -77,13 +77,18 @@ export declare const DEFAULT_TRUNCATION_CONFIG: Required<TruncationConfig>;
  * Tool output processor with truncation and file saving capabilities
  */
 export declare class ToolOutputProcessor {
+    /** Fallback per-command overrides when no maxInputTokens is provided */
+    private static readonly DEFAULT_COMMAND_OVERRIDES;
+    private readonly commandOverrides;
     private readonly config;
     /**
      * Create a new tool output processor
      *
-     * @param config - Truncation configuration
+     * @param maxInputTokens - Model context window size. When provided, truncation thresholds
+     *   are derived as a percentage of the context window so they scale across model sizes.
+     * @param config - Optional explicit overrides (take priority over computed defaults)
      */
-    constructor(config?: TruncationConfig);
+    constructor(maxInputTokens?: number, config?: TruncationConfig);
     /**
      * Process tool output with truncation and file saving
      *
@@ -94,9 +99,10 @@ export declare class ToolOutputProcessor {
      *
      * @param toolName - Name of the tool that produced the output
      * @param output - Raw tool output (any type, will be stringified)
+     * @param commandType - Optional command type for per-command truncation overrides
      * @returns Processed output with metadata
      */
-    processOutput(toolName: string, output: unknown): Promise<ProcessedOutput>;
+    processOutput(toolName: string, output: unknown, commandType?: string): Promise<ProcessedOutput>;
     /**
      * Process structured tool output that may contain attachments.
      *
@@ -107,9 +113,10 @@ export declare class ToolOutputProcessor {
      *
      * @param toolName - Name of the tool that produced the output
      * @param output - Raw tool output (structured or plain)
+     * @param commandType - Optional command type for per-command truncation overrides
      * @returns Processed output with attachments and title
      */
-    processStructuredOutput(toolName: string, output: unknown): Promise<ProcessedOutput>;
+    processStructuredOutput(toolName: string, output: unknown, commandType?: string): Promise<ProcessedOutput>;
     /**
      * Extract attachments from structured output.
      */
@@ -144,6 +151,10 @@ export declare class ToolOutputProcessor {
      * Check if output is a structured output with potential attachments.
      */
     private isStructuredOutput;
+    /**
+     * Resolve effective truncation config, applying per-command overrides if applicable.
+     */
+    private resolveConfig;
     /**
      * Save content to a temporary file
      *
@@ -172,6 +183,7 @@ export declare class ToolOutputProcessor {
      * [Last N lines]
      *
      * @param content - Content to truncate
+     * @param config - Truncation config to use (may include per-command overrides)
      * @returns Truncated content
      */
     private truncateContent;

package/dist/agent/infra/llm/tool-output-processor.js

@@ -21,21 +21,53 @@ export const DEFAULT_TRUNCATION_CONFIG = {
     tailLines: 250,
     threshold: 50_000,
 };
+/**
+ * Percentages used to derive per-command truncation thresholds from the model's context window.
+ * Expressed as a fraction of maxInputTokens. Multiply by charsPerToken (default 4) for char threshold.
+ * Calibrated so values equal the original hardcoded limits on a 200K-token context model:
+ *   default  = 6.25%  → 50,000 chars at 200K  (50K chars / (200K tokens × 4 chars/token) = 6.25%)
+ *   curate   = 1.25%  → 10,000 chars at 200K
+ *   query    = 2.50%  → 20,000 chars at 200K
+ */
+const THRESHOLD_PERCENT_DEFAULT = 0.0625;
+const THRESHOLD_PERCENT_CURATE = 0.0125;
+const THRESHOLD_PERCENT_QUERY = 0.025;
+const DEFAULT_CHARS_PER_TOKEN = 4;
 /**
  * Tool output processor with truncation and file saving capabilities
  */
 export class ToolOutputProcessor {
+    /** Fallback per-command overrides when no maxInputTokens is provided */
+    static DEFAULT_COMMAND_OVERRIDES = {
+        curate: { headLines: 50, tailLines: 20, threshold: 10_000 },
+        query: { headLines: 100, tailLines: 50, threshold: 20_000 },
+    };
+    commandOverrides;
     config;
     /**
      * Create a new tool output processor
      *
-     * @param config - Truncation configuration
+     * @param maxInputTokens - Model context window size. When provided, truncation thresholds
+     *   are derived as a percentage of the context window so they scale across model sizes.
+     * @param config - Optional explicit overrides (take priority over computed defaults)
      */
-    constructor(config) {
-        this.config = {
-            ...DEFAULT_TRUNCATION_CONFIG,
-            ...config,
-        };
+    constructor(maxInputTokens, config) {
+        if (maxInputTokens) {
+            const baseThreshold = Math.floor(maxInputTokens * THRESHOLD_PERCENT_DEFAULT * DEFAULT_CHARS_PER_TOKEN);
+            this.config = {
+                ...DEFAULT_TRUNCATION_CONFIG,
+                threshold: baseThreshold,
+                ...config,
+            };
+            this.commandOverrides = {
+                curate: { headLines: 50, tailLines: 20, threshold: Math.floor(maxInputTokens * THRESHOLD_PERCENT_CURATE * DEFAULT_CHARS_PER_TOKEN) },
+                query: { headLines: 100, tailLines: 50, threshold: Math.floor(maxInputTokens * THRESHOLD_PERCENT_QUERY * DEFAULT_CHARS_PER_TOKEN) },
+            };
+        }
+        else {
+            this.config = { ...DEFAULT_TRUNCATION_CONFIG, ...config };
+            this.commandOverrides = { ...ToolOutputProcessor.DEFAULT_COMMAND_OVERRIDES };
+        }
     }
     // ==================== PUBLIC METHODS ====================
     /**
@@ -48,14 +80,16 @@ export class ToolOutputProcessor {
      *
      * @param toolName - Name of the tool that produced the output
      * @param output - Raw tool output (any type, will be stringified)
+     * @param commandType - Optional command type for per-command truncation overrides
      * @returns Processed output with metadata
      */
-    async processOutput(toolName, output) {
+    async processOutput(toolName, output, commandType) {
+        const config = this.resolveConfig(commandType);
         // Convert output to string
         const contentString = this.stringify(output);
         const originalLength = contentString.length;
         // Check if truncation is needed
-        if (!this.config.enabled || originalLength <= this.config.threshold) {
+        if (!config.enabled || originalLength <= config.threshold) {
             return {
                 content: contentString,
             };
@@ -63,7 +97,7 @@ export class ToolOutputProcessor {
         // Save full output to temp file
         const savedFilePath = await this.saveToTempFile(toolName, contentString);
         // Truncate content
-        const truncatedContent = this.truncateContent(contentString);
+        const truncatedContent = this.truncateContent(contentString, config);
         return {
             content: truncatedContent,
             metadata: {
@@ -83,16 +117,17 @@ export class ToolOutputProcessor {
      *
      * @param toolName - Name of the tool that produced the output
      * @param output - Raw tool output (structured or plain)
+     * @param commandType - Optional command type for per-command truncation overrides
      * @returns Processed output with attachments and title
      */
-    async processStructuredOutput(toolName, output) {
+    async processStructuredOutput(toolName, output, commandType) {
         // Try to detect structured output
         if (this.isStructuredOutput(output)) {
             const structured = output;
             const attachments = this.extractAttachments(structured);
             const textContent = this.extractTextContent(structured);
             // Process the text content with truncation
-            const processed = await this.processOutput(toolName, textContent);
+            const processed = await this.processOutput(toolName, textContent, commandType);
             return {
                 ...processed,
                 attachments: attachments.length > 0 ? attachments : undefined,
@@ -105,14 +140,14 @@ export class ToolOutputProcessor {
             const attachments = this.extractMcpAttachments(contentArray);
             const textContent = this.extractMcpTextContent(contentArray);
             // Process the text content with truncation
-            const processed = await this.processOutput(toolName, textContent);
+            const processed = await this.processOutput(toolName, textContent, commandType);
             return {
                 ...processed,
                 attachments: attachments.length > 0 ? attachments : undefined,
             };
         }
         // Fall back to regular processing
-        return this.processOutput(toolName, output);
+        return this.processOutput(toolName, output, commandType);
     }
     // ==================== PRIVATE METHODS (alphabetical order) ====================
     /**
@@ -264,6 +299,15 @@ export class ToolOutputProcessor {
         // Must have at least one of: content, attachments, or title
         return 'content' in obj || 'attachments' in obj || 'title' in obj;
     }
+    /**
+     * Resolve effective truncation config, applying per-command overrides if applicable.
+     */
+    resolveConfig(commandType) {
+        if (commandType && commandType in this.commandOverrides) {
+            return { ...this.config, ...this.commandOverrides[commandType] };
+        }
+        return this.config;
+    }
     /**
      * Save content to a temporary file
      *
@@ -342,14 +386,15 @@ export class ToolOutputProcessor {
      * [Last N lines]
      *
      * @param content - Content to truncate
+     * @param config - Truncation config to use (may include per-command overrides)
      * @returns Truncated content
      */
-    truncateContent(content) {
+    truncateContent(content, config = this.config) {
         const lines = content.split('\n');
         const totalLines = lines.length;
         // Calculate how many lines to keep
-        const headLines = Math.min(this.config.headLines, totalLines);
-        const tailLines = Math.min(this.config.tailLines, totalLines);
+        const headLines = Math.min(config.headLines, totalLines);
+        const tailLines = Math.min(config.tailLines, totalLines);
         // If content is small enough to fit, return as-is
         if (headLines + tailLines >= totalLines) {
             return content;