@compilr-dev/agents 0.3.10 → 0.3.12

package/dist/context/manager.js

@@ -18,6 +18,7 @@
  * ```
  */
 import { repairToolPairing } from '../messages/index.js';
+import { countTokens, countMessageTokens } from '../utils/tokenizer.js';
 /**
  * Default budget allocation
  */
@@ -122,29 +123,8 @@ export class ContextManager {
         if (this.provider.countTokens) {
             return this.provider.countTokens(messages);
         }
-        // Fallback: rough estimate based on character count
-        let charCount = 0;
-        for (const msg of messages) {
-            if (typeof msg.content === 'string') {
-                charCount += msg.content.length;
-            }
-            else {
-                for (const block of msg.content) {
-                    switch (block.type) {
-                        case 'text':
-                            charCount += block.text.length;
-                            break;
-                        case 'tool_use':
-                            charCount += JSON.stringify(block.input).length;
-                            break;
-                        case 'tool_result':
-                            charCount += block.content.length;
-                            break;
-                    }
-                }
-            }
-        }
-        return Math.ceil(charCount / 4);
+        // Fallback: count tokens using tiktoken
+        return countMessageTokens(messages);
     }
     /**
      * Update token count for messages
@@ -351,7 +331,7 @@ export class ContextManager {
             }
             // Compact this message
             if (typeof msg.content === 'string') {
-                const tokens = Math.ceil(msg.content.length / 4);
+                const tokens = countTokens(msg.content);
                 if (tokens >= this.config.compaction.minTokensToCompact) {
                     const filePath = await saveToFile(msg.content, compactedIndex++);
                     filesCreated.push(filePath);
@@ -369,7 +349,7 @@ export class ContextManager {
                 const compactedBlocks = [];
                 for (const block of msg.content) {
                     if (block.type === 'tool_result' && category === 'toolResults') {
-                        const tokens = Math.ceil(block.content.length / 4);
+                        const tokens = countTokens(block.content);
                         if (tokens >= this.config.compaction.minTokensToCompact) {
                             const filePath = await saveToFile(block.content, compactedIndex++);
                             filesCreated.push(filePath);
@@ -702,7 +682,7 @@ export class ContextManager {
      * Estimate tokens for a string content
      */
     estimateTokens(content) {
-        return Math.ceil(content.length / 4);
+        return countTokens(content);
     }
     /**
      * Check if content can be added to a category
@@ -822,13 +802,13 @@ export class ContextManager {
                 maxLines = this.config.filtering.maxErrorLines;
                 break;
             default: {
-                // For tool results, check token count estimate
-                const estimatedTokens = Math.ceil(content.length / 4);
+                // For tool results, check token count
+                const estimatedTokens = countTokens(content);
                 if (estimatedTokens <= this.config.filtering.maxToolResultTokens) {
                     return { content, filtered: false, originalLength };
                 }
-                // Truncate to roughly maxToolResultTokens
-                const maxChars = this.config.filtering.maxToolResultTokens * 4;
+                // Truncate to roughly maxToolResultTokens (~3 chars per token)
+                const maxChars = this.config.filtering.maxToolResultTokens * 3;
                 const truncated = content.slice(0, maxChars);
                 return {
                     content: truncated + '\n\n[Content truncated - see file for full output]',
@@ -877,7 +857,7 @@ export class ContextManager {
         for (const msg of oldMessages) {
             if (typeof msg.content === 'string') {
                 // Check if string content is large enough to compact
-                const tokens = Math.ceil(msg.content.length / 4);
+                const tokens = countTokens(msg.content);
                 if (tokens >= this.config.compaction.minTokensToCompact) {
                     const filePath = await saveToFile(msg.content, compactedIndex++);
                     filesCreated.push(filePath);
@@ -895,7 +875,7 @@ export class ContextManager {
                 const compactedBlocks = [];
                 for (const block of msg.content) {
                     if (block.type === 'tool_result') {
-                        const tokens = Math.ceil(block.content.length / 4);
+                        const tokens = countTokens(block.content);
                         if (tokens >= this.config.compaction.minTokensToCompact) {
                             const filePath = await saveToFile(block.content, compactedIndex++);
                             filesCreated.push(filePath);

package/dist/context/tool-result-delegator.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Tool Result Delegator
+ *
+ * Intercepts large tool results via the AfterToolHook mechanism,
+ * stores the full result for optional recall, and replaces it
+ * with a compact summary to conserve context tokens.
+ */
+import type { LLMProvider } from '../providers/types.js';
+import type { AfterToolHook } from '../hooks/types.js';
+import type { DelegationConfig, DelegationEvent } from './delegation-types.js';
+import { DelegatedResultStore } from './delegated-result-store.js';
+/**
+ * Options for creating a ToolResultDelegator.
+ */
+export interface ToolResultDelegatorOptions {
+    /** LLM provider for summarization (small/medium tier preferred) */
+    provider: LLMProvider;
+    /** Delegation configuration (merged with defaults) */
+    config?: Partial<DelegationConfig>;
+    /** Event callback for delegation lifecycle events */
+    onEvent?: (event: DelegationEvent) => void;
+}
+/**
+ * Core class that creates an AfterToolHook for auto-delegating large tool results.
+ */
+export declare class ToolResultDelegator {
+    private readonly store;
+    private readonly config;
+    private readonly provider;
+    private readonly onEvent?;
+    constructor(options: ToolResultDelegatorOptions);
+    /**
+     * Returns an AfterToolHook to register with HooksManager.
+     */
+    createHook(): AfterToolHook;
+    /**
+     * Perform the actual delegation (async path).
+     */
+    private delegateResult;
+    /**
+     * Access the store (needed by recall_full_result tool).
+     */
+    getStore(): DelegatedResultStore;
+    /**
+     * Get the resolved config for a specific tool.
+     */
+    private getToolConfig;
+    /**
+     * Extractive summarization: first/last lines + prioritized structural markers.
+     * No LLM cost, fast, preserves actual code signatures.
+     */
+    private summarizeExtractive;
+    /**
+     * LLM-based summarization using the provider.
+     * Returns null if the LLM call fails.
+     */
+    private summarizeLLM;
+}
+/**
+ * System prompt addition when delegation is enabled.
+ * Append to the agent's system prompt.
+ */
+export declare const DELEGATION_SYSTEM_PROMPT: string;

package/dist/context/tool-result-delegator.js

@@ -0,0 +1,305 @@
+/**
+ * Tool Result Delegator
+ *
+ * Intercepts large tool results via the AfterToolHook mechanism,
+ * stores the full result for optional recall, and replaces it
+ * with a compact summary to conserve context tokens.
+ */
+import { DEFAULT_DELEGATION_CONFIG } from './delegation-types.js';
+import { DelegatedResultStore } from './delegated-result-store.js';
+import { countTokens } from '../utils/tokenizer.js';
+/**
+ * System prompt for LLM-based summarization.
+ */
+const SUMMARIZATION_SYSTEM_PROMPT = 'You are a tool result summarizer. Compress this tool output preserving:\n' +
+    '- ALL errors/warnings verbatim\n' +
+    '- File paths, function names, line numbers, counts\n' +
+    '- Overall structure (sections, item counts)\n' +
+    '- First few items of lists verbatim\n' +
+    'Drop: verbose repetition, successful routine output, function bodies.\n' +
+    'Never add information not in the original.\n' +
+    'Respond with ONLY the summary, no preamble.';
+/**
+ * Core class that creates an AfterToolHook for auto-delegating large tool results.
+ */
+export class ToolResultDelegator {
+    store;
+    config;
+    provider;
+    onEvent;
+    constructor(options) {
+        this.provider = options.provider;
+        this.config = { ...DEFAULT_DELEGATION_CONFIG, ...options.config };
+        this.onEvent = options.onEvent;
+        this.store = new DelegatedResultStore({
+            maxSize: this.config.maxStoredResults,
+            defaultTTL: this.config.resultTTL,
+        });
+    }
+    /**
+     * Returns an AfterToolHook to register with HooksManager.
+     */
+    createHook() {
+        const getToolConfig = this.getToolConfig.bind(this);
+        const delegateResult = this.delegateResult.bind(this);
+        return (context) => {
+            // Skip failed results — errors should always pass through
+            if (!context.result.success)
+                return undefined;
+            // Never re-delegate recall_full_result — that would create a loop
+            if (context.toolName === 'recall_full_result')
+                return undefined;
+            // Check if delegation is enabled for this tool
+            const toolConfig = getToolConfig(context.toolName);
+            if (!toolConfig.enabled)
+                return undefined;
+            // Serialize the result content
+            const content = typeof context.result.result === 'string'
+                ? context.result.result
+                : JSON.stringify(context.result.result);
+            // Count tokens
+            const tokens = countTokens(content);
+            // Below threshold — pass through unchanged
+            if (tokens <= toolConfig.threshold)
+                return undefined;
+            // Delegate asynchronously
+            return delegateResult(context, content, tokens, toolConfig);
+        };
+    }
+    /**
+     * Perform the actual delegation (async path).
+     */
+    async delegateResult(context, content, tokens, toolConfig) {
+        // Generate delegation ID
+        const id = this.store.generateId();
+        this.onEvent?.({
+            type: 'delegation:started',
+            toolName: context.toolName,
+            originalTokens: tokens,
+            delegationId: id,
+        });
+        try {
+            // Determine strategy
+            const strategy = toolConfig.strategy === 'auto' ? 'extractive' : toolConfig.strategy;
+            let summary;
+            let usedStrategy = strategy;
+            if (strategy === 'llm') {
+                const llmSummary = await this.summarizeLLM(content, context.toolName);
+                if (llmSummary !== null) {
+                    summary = llmSummary;
+                    usedStrategy = 'llm';
+                }
+                else {
+                    // LLM failed, fall back to extractive
+                    summary = this.summarizeExtractive(content);
+                    usedStrategy = 'extractive';
+                }
+            }
+            else if (toolConfig.strategy === 'auto') {
+                // Auto: try LLM first, fall back to extractive
+                const llmSummary = await this.summarizeLLM(content, context.toolName);
+                if (llmSummary !== null) {
+                    summary = llmSummary;
+                    usedStrategy = 'llm';
+                }
+                else {
+                    summary = this.summarizeExtractive(content);
+                    usedStrategy = 'extractive';
+                }
+            }
+            else {
+                summary = this.summarizeExtractive(content);
+                usedStrategy = 'extractive';
+            }
+            const summaryTokens = countTokens(summary);
+            // Store the full result
+            const now = Date.now();
+            const stored = {
+                id,
+                toolName: context.toolName,
+                toolInput: context.input,
+                fullContent: content,
+                fullTokens: tokens,
+                summary,
+                summaryTokens,
+                storedAt: now,
+                expiresAt: now + this.config.resultTTL,
+            };
+            this.store.add(stored);
+            this.onEvent?.({
+                type: 'delegation:completed',
+                toolName: context.toolName,
+                originalTokens: tokens,
+                summaryTokens,
+                delegationId: id,
+                strategy: usedStrategy,
+            });
+            // Return modified result with summary
+            // The format must be unmistakable so the LLM never confuses
+            // a delegated summary with the actual tool output.
+            return {
+                result: {
+                    success: true,
+                    result: {
+                        _delegated: true,
+                        _delegationId: id,
+                        _originalTokens: tokens,
+                        _summaryTokens: summaryTokens,
+                        _warning: 'THIS IS A SUMMARY, NOT THE FULL RESULT. You did not see the full output.',
+                        summary,
+                        recall: `To get the full output, call recall_full_result with id="${id}"`,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            this.onEvent?.({
+                type: 'delegation:failed',
+                toolName: context.toolName,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // On failure, return original result unchanged
+            return { result: context.result };
+        }
+    }
+    /**
+     * Access the store (needed by recall_full_result tool).
+     */
+    getStore() {
+        return this.store;
+    }
+    /**
+     * Get the resolved config for a specific tool.
+     */
+    getToolConfig(toolName) {
+        const override = this.config.toolOverrides?.[toolName];
+        return {
+            enabled: override?.enabled ?? this.config.enabled,
+            threshold: override?.threshold ?? this.config.delegationThreshold,
+            strategy: override?.strategy ?? this.config.strategy,
+        };
+    }
+    /**
+     * Extractive summarization: first/last lines + prioritized structural markers.
+     * No LLM cost, fast, preserves actual code signatures.
+     */
+    summarizeExtractive(content) {
+        const lines = content.split('\n');
+        const totalLines = lines.length;
+        if (totalLines <= 40) {
+            // Small enough to include mostly as-is
+            return content;
+        }
+        const parts = [];
+        // Header: makes it impossible to confuse with full content
+        parts.push(`[SUMMARIZED — showing first 20 + last 10 of ${String(totalLines)} lines, plus key signatures. Use recall_full_result for complete output.]`);
+        parts.push('');
+        // First 20 lines
+        parts.push(...lines.slice(0, 20));
+        // Extract structural markers from the middle, prioritized by importance
+        const middleLines = lines.slice(20, -10);
+        // High priority: exports, class/interface/function declarations with signatures
+        const highPriority = /^\s*export\s+(default\s+)?(async\s+)?(function|class|interface|type|const|enum)\s/;
+        // Medium priority: non-exported declarations, method signatures
+        const medPriority = /^\s*(async\s+)?(function|class|interface|type|const|enum)\s|^\s+(async\s+)?(\w+)\s*\([^)]*\)\s*[:{]/;
+        // Low priority: errors, headings, section markers
+        const lowPriority = /^\s*(ERROR|WARN|FAIL|error|warning|#{1,6}\s|---{3,}|\*{3,}|={3,}|\/\/\s*={3,})/;
+        const high = [];
+        const med = [];
+        const low = [];
+        for (const line of middleLines) {
+            if (highPriority.test(line)) {
+                high.push(line);
+            }
+            else if (medPriority.test(line)) {
+                med.push(line);
+            }
+            else if (lowPriority.test(line)) {
+                low.push(line);
+            }
+        }
+        // Budget: scale markers with file size, cap at 40
+        const totalMarkers = high.length + med.length + low.length;
+        const budget = Math.min(40, Math.max(15, Math.floor(totalLines / 80)));
+        // Fill budget: all high, then medium, then low
+        const selected = [];
+        for (const line of high) {
+            if (selected.length >= budget)
+                break;
+            selected.push(line);
+        }
+        for (const line of med) {
+            if (selected.length >= budget)
+                break;
+            selected.push(line);
+        }
+        for (const line of low) {
+            if (selected.length >= budget)
+                break;
+            selected.push(line);
+        }
+        if (selected.length > 0) {
+            parts.push('');
+            parts.push(`... (${String(middleLines.length)} lines omitted, ${String(totalMarkers)} structural markers found, showing ${String(selected.length)} key signatures) ...`);
+            parts.push(...selected);
+            if (totalMarkers > selected.length) {
+                parts.push(`... (${String(totalMarkers - selected.length)} more markers omitted) ...`);
+            }
+        }
+        else {
+            parts.push('');
+            parts.push(`... (${String(middleLines.length)} lines omitted) ...`);
+        }
+        // Last 10 lines
+        parts.push('');
+        parts.push(...lines.slice(-10));
+        parts.push('');
+        parts.push(`[Total: ${String(totalLines)} lines]`);
+        return parts.join('\n');
+    }
+    /**
+     * LLM-based summarization using the provider.
+     * Returns null if the LLM call fails.
+     */
+    async summarizeLLM(content, toolName) {
+        try {
+            const messages = [
+                {
+                    role: 'system',
+                    content: SUMMARIZATION_SYSTEM_PROMPT,
+                },
+                {
+                    role: 'user',
+                    content: `Summarize this ${toolName} tool result (keep under ${String(this.config.summaryMaxTokens)} tokens):\n\n${content}`,
+                },
+            ];
+            let text = '';
+            for await (const chunk of this.provider.chat(messages, {
+                maxTokens: this.config.summaryMaxTokens,
+                temperature: 0,
+                model: undefined, // Use the provider's default model
+            })) {
+                if (chunk.type === 'text' && chunk.text) {
+                    text += chunk.text;
+                }
+            }
+            return text.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/**
+ * System prompt addition when delegation is enabled.
+ * Append to the agent's system prompt.
+ */
+export const DELEGATION_SYSTEM_PROMPT = '\n\n## Tool Result Delegation\n' +
+    'Some tool results are automatically summarized to conserve context. When a result has `_delegated: true`, ' +
+    'you received a SUMMARY, not the full output. You MUST acknowledge this — never claim you read the full content.\n' +
+    'Delegated results include:\n' +
+    '- `_warning`: confirms this is a summary\n' +
+    '- `summary`: extracted key information\n' +
+    '- `recall`: how to get the full output\n' +
+    'Use `recall_full_result` with the delegation ID to get the full output when the summary is insufficient.\n' +
+    'Only recall when you need specific code, exact values, or the summary indicates omitted content.\n';

package/dist/index.d.ts

@@ -31,16 +31,16 @@ export { PerplexityProvider, createPerplexityProvider } from './providers/index.
 export type { PerplexityProviderConfig } from './providers/index.js';
 export { OpenRouterProvider, createOpenRouterProvider } from './providers/index.js';
 export type { OpenRouterProviderConfig } from './providers/index.js';
-export type { Tool, ToolHandler, ToolRegistry, ToolInputSchema, ToolExecutionResult, ToolRegistryOptions, ToolFallbackHandler, DefineToolOptions, ReadFileInput, WriteFileInput, BashInput, BashResult, FifoDetectionResult, GrepInput, GlobInput, EditInput, TodoWriteInput, TodoReadInput, TodoItem, TodoStatus, TodoContextCleanupOptions, TaskInput, TaskResult, AgentTypeConfig, TaskToolOptions, ContextMode, ThoroughnessLevel, SubAgentEventInfo, SuggestInput, SuggestToolOptions, } from './tools/index.js';
+export type { Tool, ToolHandler, ToolRegistry, ToolInputSchema, ToolExecutionResult, ToolRegistryOptions, ToolFallbackHandler, DefineToolOptions, ReadFileInput, WriteFileInput, BashInput, BashResult, FifoDetectionResult, GrepInput, GlobInput, EditInput, TodoWriteInput, TodoReadInput, TodoItem, TodoStatus, TodoContextCleanupOptions, TaskInput, TaskResult, AgentTypeConfig, TaskToolOptions, ContextMode, ThoroughnessLevel, SubAgentEventInfo, SuggestInput, SuggestToolOptions, RecallResultInput, RecallResultToolOptions, } from './tools/index.js';
 export { defineTool, createSuccessResult, createErrorResult, wrapToolExecute, DefaultToolRegistry, createToolRegistry, } from './tools/index.js';
-export { readFileTool, createReadFileTool, writeFileTool, createWriteFileTool, bashTool, createBashTool, execStream, detectFifoUsage, bashOutputTool, createBashOutputTool, killShellTool, createKillShellTool, ShellManager, getDefaultShellManager, setDefaultShellManager, grepTool, createGrepTool, globTool, createGlobTool, editTool, createEditTool, todoWriteTool, todoReadTool, createTodoTools, TodoStore, resetDefaultTodoStore, getDefaultTodoStore, createIsolatedTodoStore, cleanupTodoContextMessages, getTodoContextStats, webFetchTool, createWebFetchTool, createTaskTool, defaultAgentTypes, suggestTool, createSuggestTool, builtinTools, allBuiltinTools, TOOL_NAMES, TOOL_SETS, } from './tools/index.js';
+export { readFileTool, createReadFileTool, writeFileTool, createWriteFileTool, bashTool, createBashTool, execStream, detectFifoUsage, bashOutputTool, createBashOutputTool, killShellTool, createKillShellTool, ShellManager, getDefaultShellManager, setDefaultShellManager, grepTool, createGrepTool, globTool, createGlobTool, editTool, createEditTool, todoWriteTool, todoReadTool, createTodoTools, TodoStore, resetDefaultTodoStore, getDefaultTodoStore, createIsolatedTodoStore, cleanupTodoContextMessages, getTodoContextStats, webFetchTool, createWebFetchTool, createTaskTool, defaultAgentTypes, suggestTool, createSuggestTool, createRecallResultTool, builtinTools, allBuiltinTools, TOOL_NAMES, TOOL_SETS, } from './tools/index.js';
 export { userMessage, assistantMessage, systemMessage, textBlock, toolUseBlock, toolResultBlock, getTextContent, getToolUses, getToolResults, hasToolUses, validateToolUseResultPairing, repairToolPairing, ensureMessageContent, normalizeMessages, } from './messages/index.js';
 export type { ToolPairingValidation } from './messages/index.js';
-export { generateId, sleep, retry, truncate, withRetryGenerator, calculateBackoffDelay, DEFAULT_RETRY_CONFIG, } from './utils/index.js';
+export { generateId, sleep, retry, truncate, withRetryGenerator, calculateBackoffDelay, DEFAULT_RETRY_CONFIG, countTokens, countMessageTokens, } from './utils/index.js';
 export type { RetryConfig as LLMRetryConfig, WithRetryOptions } from './utils/index.js';
 export { AgentError, ProviderError, ToolError, ToolTimeoutError, ToolLoopError, ValidationError, MaxIterationsError, AbortError, ContextOverflowError, isAgentError, isProviderError, isToolError, isToolTimeoutError, isToolLoopError, isContextOverflowError, wrapError, } from './errors.js';
-export { ContextManager, DEFAULT_CONTEXT_CONFIG, FileAccessTracker, createFileTrackingHook, TRACKED_TOOLS, } from './context/index.js';
-export type { ContextManagerOptions, ContextCategory, BudgetAllocation, CategoryBudgetInfo, PreflightResult, VerbosityLevel, VerbosityConfig, ContextConfig, FilteringConfig, CompactionConfig, SummarizationConfig, CompactionResult, SummarizationResult, FilteringResult, ContextEvent, ContextEventHandler, ContextStats, FileAccessType, FileAccess, FileAccessTrackerOptions, FormatHintsOptions, FileAccessStats, } from './context/index.js';
+export { ContextManager, DEFAULT_CONTEXT_CONFIG, FileAccessTracker, createFileTrackingHook, TRACKED_TOOLS, DelegatedResultStore, ToolResultDelegator, DELEGATION_SYSTEM_PROMPT, DEFAULT_DELEGATION_CONFIG, } from './context/index.js';
+export type { ContextManagerOptions, ContextCategory, BudgetAllocation, CategoryBudgetInfo, PreflightResult, VerbosityLevel, VerbosityConfig, ContextConfig, FilteringConfig, CompactionConfig, SummarizationConfig, CompactionResult, SummarizationResult, FilteringResult, ContextEvent, ContextEventHandler, ContextStats, FileAccessType, FileAccess, FileAccessTrackerOptions, FormatHintsOptions, FileAccessStats, DelegatedResultStoreStats, ToolResultDelegatorOptions, DelegationConfig, StoredResult, DelegationEvent, } from './context/index.js';
 export { SkillRegistry, defineSkill, createSkillRegistry, builtinSkills, getDefaultSkillRegistry, resetDefaultSkillRegistry, } from './skills/index.js';
 export type { Skill, SkillInvocationResult, SkillInvokeOptions } from './skills/index.js';
 export { JsonSerializer, CompactJsonSerializer, defaultSerializer, MemoryCheckpointer, FileCheckpointer, StateError, StateErrorCode, CURRENT_STATE_VERSION, } from './state/index.js';

package/dist/index.js

@@ -29,7 +29,9 @@ export { readFileTool, createReadFileTool, writeFileTool, createWriteFileTool, b
 // Task tool (sub-agent spawning)
 createTaskTool, defaultAgentTypes, 
 // Suggest tool (next action suggestions)
-suggestTool, createSuggestTool, builtinTools, allBuiltinTools, 
+suggestTool, createSuggestTool, 
+// Recall result tool (delegation)
+createRecallResultTool, builtinTools, allBuiltinTools, 
 // Tool names - single source of truth
 TOOL_NAMES, TOOL_SETS, } from './tools/index.js';
 // Message utilities
@@ -37,11 +39,15 @@ export { userMessage, assistantMessage, systemMessage, textBlock, toolUseBlock,
 // Utilities
 export { generateId, sleep, 
 // eslint-disable-next-line @typescript-eslint/no-deprecated -- Kept for backward compatibility
-retry, truncate, withRetryGenerator, calculateBackoffDelay, DEFAULT_RETRY_CONFIG, } from './utils/index.js';
+retry, truncate, withRetryGenerator, calculateBackoffDelay, DEFAULT_RETRY_CONFIG, 
+// Token counting (tiktoken-based)
+countTokens, countMessageTokens, } from './utils/index.js';
 // Errors
 export { AgentError, ProviderError, ToolError, ToolTimeoutError, ToolLoopError, ValidationError, MaxIterationsError, AbortError, ContextOverflowError, isAgentError, isProviderError, isToolError, isToolTimeoutError, isToolLoopError, isContextOverflowError, wrapError, } from './errors.js';
 // Context management
-export { ContextManager, DEFAULT_CONTEXT_CONFIG, FileAccessTracker, createFileTrackingHook, TRACKED_TOOLS, } from './context/index.js';
+export { ContextManager, DEFAULT_CONTEXT_CONFIG, FileAccessTracker, createFileTrackingHook, TRACKED_TOOLS, 
+// Tool result delegation
+DelegatedResultStore, ToolResultDelegator, DELEGATION_SYSTEM_PROMPT, DEFAULT_DELEGATION_CONFIG, } from './context/index.js';
 // Skills system
 export { SkillRegistry, defineSkill, createSkillRegistry, builtinSkills, getDefaultSkillRegistry, resetDefaultSkillRegistry, } from './skills/index.js';
 // State management

package/dist/memory/loader.js

@@ -25,6 +25,7 @@
  */
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import { countTokens } from '../utils/tokenizer.js';
 /**
  * Built-in patterns for various LLM providers
  */
@@ -268,7 +269,7 @@ export class ProjectMemoryLoader {
             files,
             content,
             rootDir: absoluteRoot,
-            estimatedTokens: Math.ceil(content.length / 4),
+            estimatedTokens: countTokens(content),
         };
         this.emit({ type: 'memory:search_complete', memory });
         return memory;

package/dist/memory/types.d.ts

@@ -41,7 +41,7 @@ export interface ProjectMemory {
     content: string;
     /** The root directory where search started */
     rootDir: string;
-    /** Total token estimate (rough: chars / 4) */
+    /** Total token estimate (tiktoken cl100k_base) */
     estimatedTokens: number;
 }
 /**

package/dist/providers/claude.d.ts

@@ -61,11 +61,7 @@ export declare class ClaudeProvider implements LLMProvider {
      */
     chat(messages: Message[], options?: ChatOptions): AsyncIterable<StreamChunk>;
     /**
-     * Count tokens in messages (not yet available in SDK v0.30)
-     *
-     * Note: Token counting API is available via Anthropic's beta endpoints
-     * but not yet exposed in the stable SDK. For now, this provides an
-     * approximation based on character count.
+     * Count tokens in messages using tiktoken (cl100k_base encoding)
      */
     countTokens(messages: Message[]): Promise<number>;
     /**

package/dist/providers/claude.js

@@ -11,6 +11,7 @@
  * ```
  */
 import Anthropic from '@anthropic-ai/sdk';
+import { countMessageTokens } from '../utils/tokenizer.js';
 import { ProviderError } from '../errors.js';
 /**
  * Default model for Claude API
@@ -122,36 +123,10 @@ export class ClaudeProvider {
         }
     }
     /**
-     * Count tokens in messages (not yet available in SDK v0.30)
-     *
-     * Note: Token counting API is available via Anthropic's beta endpoints
-     * but not yet exposed in the stable SDK. For now, this provides an
-     * approximation based on character count.
+     * Count tokens in messages using tiktoken (cl100k_base encoding)
      */
     countTokens(messages) {
-        // Approximation: ~4 characters per token (rough estimate)
-        let charCount = 0;
-        for (const msg of messages) {
-            if (typeof msg.content === 'string') {
-                charCount += msg.content.length;
-            }
-            else {
-                for (const block of msg.content) {
-                    switch (block.type) {
-                        case 'text':
-                            charCount += block.text.length;
-                            break;
-                        case 'tool_use':
-                            charCount += JSON.stringify(block.input).length;
-                            break;
-                        case 'tool_result':
-                            charCount += block.content.length;
-                            break;
-                    }
-                }
-            }
-        }
-        return Promise.resolve(Math.ceil(charCount / 4));
+        return Promise.resolve(countMessageTokens(messages));
     }
     /**
      * Convert our Message format to Anthropic's format

package/dist/providers/gemini-native.d.ts

@@ -52,7 +52,7 @@ export declare class GeminiNativeProvider implements LLMProvider {
      */
     chat(messages: Message[], options?: ChatOptions): AsyncIterable<StreamChunk>;
     /**
-     * Count tokens in messages (approximation)
+     * Count tokens in messages using tiktoken (cl100k_base encoding)
      */
     countTokens(messages: Message[]): Promise<number>;
     /**

package/dist/providers/gemini-native.js

@@ -15,6 +15,7 @@
  */
 import { GoogleGenAI } from '@google/genai';
 import { ProviderError } from '../errors.js';
+import { countMessageTokens } from '../utils/tokenizer.js';
 /**
  * Default model for Gemini API
  */
@@ -137,32 +138,10 @@ export class GeminiNativeProvider {
         }
     }
     /**
-     * Count tokens in messages (approximation)
+     * Count tokens in messages using tiktoken (cl100k_base encoding)
      */
     countTokens(messages) {
-        // Approximation: ~4 characters per token
-        let charCount = 0;
-        for (const msg of messages) {
-            if (typeof msg.content === 'string') {
-                charCount += msg.content.length;
-            }
-            else {
-                for (const block of msg.content) {
-                    switch (block.type) {
-                        case 'text':
-                            charCount += block.text.length;
-                            break;
-                        case 'tool_use':
-                            charCount += JSON.stringify(block.input).length;
-                            break;
-                        case 'tool_result':
-                            charCount += block.content.length;
-                            break;
-                    }
-                }
-            }
-        }
-        return Promise.resolve(Math.ceil(charCount / 4));
+        return Promise.resolve(countMessageTokens(messages));
     }
     /**
      * Convert our Message format to Google's format