byterover-cli 1.7.2 → 2.0.0

package/dist/agent/infra/llm/providers/openai-compatible.js

@@ -0,0 +1,30 @@
+/**
+ * OpenAI Compatible Provider Module
+ *
+ * Generic catch-all for any OpenAI-compatible endpoint.
+ * Supports local LLMs (Ollama, LM Studio, llama.cpp, vLLM, LocalAI)
+ * and any other service exposing an OpenAI-compatible API.
+ */
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { AiSdkContentGenerator } from '../generators/ai-sdk-content-generator.js';
+export const openaiCompatibleProvider = {
+    authType: 'api-key',
+    category: 'other',
+    createGenerator(config) {
+        const provider = createOpenAICompatible({
+            apiKey: config.apiKey || '',
+            baseURL: config.baseUrl || 'http://localhost:11434/v1',
+            name: 'openai-compatible',
+        });
+        return new AiSdkContentGenerator({
+            model: provider.chatModel(config.model),
+        });
+    },
+    defaultModel: 'llama3',
+    description: 'Connect any OpenAI-compatible endpoint (Ollama, LM Studio, etc.)',
+    envVars: ['OPENAI_COMPATIBLE_API_KEY'],
+    id: 'openai-compatible',
+    name: 'OpenAI Compatible',
+    priority: 20,
+    providerType: 'openai',
+};

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

@@ -0,0 +1,7 @@
+/**
+ * OpenAI Provider Module
+ *
+ * Direct access to GPT models via @ai-sdk/openai.
+ */
+import type { ProviderModule } from './types.js';
+export declare const openaiProvider: ProviderModule;

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

@@ -0,0 +1,26 @@
+/**
+ * OpenAI Provider Module
+ *
+ * Direct access to GPT models via @ai-sdk/openai.
+ */
+import { createOpenAI } from '@ai-sdk/openai';
+import { AiSdkContentGenerator } from '../generators/ai-sdk-content-generator.js';
+export const openaiProvider = {
+    apiKeyUrl: 'https://platform.openai.com/api-keys',
+    authType: 'api-key',
+    baseUrl: 'https://api.openai.com/v1',
+    category: 'popular',
+    createGenerator(config) {
+        const provider = createOpenAI({ apiKey: config.apiKey });
+        return new AiSdkContentGenerator({
+            model: provider.responses(config.model),
+        });
+    },
+    defaultModel: 'gpt-4.1',
+    description: 'GPT models by OpenAI',
+    envVars: ['OPENAI_API_KEY'],
+    id: 'openai',
+    name: 'OpenAI',
+    priority: 3,
+    providerType: 'openai',
+};

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

@@ -0,0 +1,7 @@
+/**
+ * OpenRouter Provider Module
+ *
+ * Access 200+ models via the OpenRouter aggregator using @openrouter/ai-sdk-provider.
+ */
+import type { ProviderModule } from './types.js';
+export declare const openrouterProvider: ProviderModule;

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

@@ -0,0 +1,26 @@
+/**
+ * OpenRouter Provider Module
+ *
+ * Access 200+ models via the OpenRouter aggregator using @openrouter/ai-sdk-provider.
+ */
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { AiSdkContentGenerator } from '../generators/ai-sdk-content-generator.js';
+export const openrouterProvider = {
+    apiKeyUrl: 'https://openrouter.ai/keys',
+    authType: 'api-key',
+    baseUrl: 'https://openrouter.ai/api/v1',
+    category: 'popular',
+    createGenerator(config) {
+        const provider = createOpenRouter({ apiKey: config.apiKey });
+        return new AiSdkContentGenerator({
+            model: provider.chat(config.model),
+        });
+    },
+    defaultModel: 'anthropic/claude-sonnet-4.5',
+    description: 'Access 200+ models via aggregator',
+    envVars: ['OPENROUTER_API_KEY'],
+    id: 'openrouter',
+    name: 'OpenRouter',
+    priority: 1,
+    providerType: 'openai',
+};

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

@@ -0,0 +1,7 @@
+/**
+ * Perplexity Provider Module
+ *
+ * Web search-augmented inference via @ai-sdk/perplexity.
+ */
+import type { ProviderModule } from './types.js';
+export declare const perplexityProvider: ProviderModule;

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

@@ -0,0 +1,26 @@
+/**
+ * Perplexity Provider Module
+ *
+ * Web search-augmented inference via @ai-sdk/perplexity.
+ */
+import { createPerplexity } from '@ai-sdk/perplexity';
+import { AiSdkContentGenerator } from '../generators/ai-sdk-content-generator.js';
+export const perplexityProvider = {
+    apiKeyUrl: 'https://www.perplexity.ai/settings/api',
+    authType: 'api-key',
+    baseUrl: 'https://api.perplexity.ai',
+    category: 'other',
+    createGenerator(config) {
+        const provider = createPerplexity({ apiKey: config.apiKey });
+        return new AiSdkContentGenerator({
+            model: provider(config.model),
+        });
+    },
+    defaultModel: 'sonar-pro',
+    description: 'Web search-augmented inference',
+    envVars: ['PERPLEXITY_API_KEY'],
+    id: 'perplexity',
+    name: 'Perplexity',
+    priority: 13,
+    providerType: 'openai',
+};

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

@@ -0,0 +1,7 @@
+/**
+ * Together AI Provider Module
+ *
+ * Open-source model inference via @ai-sdk/togetherai.
+ */
+import type { ProviderModule } from './types.js';
+export declare const togetheraiProvider: ProviderModule;

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

@@ -0,0 +1,26 @@
+/**
+ * Together AI Provider Module
+ *
+ * Open-source model inference via @ai-sdk/togetherai.
+ */
+import { createTogetherAI } from '@ai-sdk/togetherai';
+import { AiSdkContentGenerator } from '../generators/ai-sdk-content-generator.js';
+export const togetheraiProvider = {
+    apiKeyUrl: 'https://api.together.ai/settings/api-keys',
+    authType: 'api-key',
+    baseUrl: 'https://api.together.xyz/v1',
+    category: 'other',
+    createGenerator(config) {
+        const provider = createTogetherAI({ apiKey: config.apiKey });
+        return new AiSdkContentGenerator({
+            model: provider(config.model),
+        });
+    },
+    defaultModel: 'meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8',
+    description: 'Open-source model inference',
+    envVars: ['TOGETHER_API_KEY', 'TOGETHERAI_API_KEY'],
+    id: 'togetherai',
+    name: 'Together AI',
+    priority: 12,
+    providerType: 'openai',
+};

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

@@ -0,0 +1,81 @@
+/**
+ * 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' | 'service-account';
+/**
+ * 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;
+    /** GCP location for Vertex AI */
+    readonly location?: string;
+    /** Maximum tokens in the response */
+    readonly maxTokens: number;
+    /** Model identifier */
+    readonly model: string;
+    /** GCP project ID for Vertex AI */
+    readonly project?: 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;