@compilr-dev/agents 0.3.0 → 0.3.2

package/dist/agent.d.ts

@@ -16,6 +16,7 @@ import { ContextManager } from './context/manager.js';
 import { FileAccessTracker } from './context/file-tracker.js';
 import { AnchorManager } from './anchors/manager.js';
 import { GuardrailManager } from './guardrails/manager.js';
+import { type RetryConfig } from './utils/index.js';
 /**
  * Event types emitted during agent execution
  */
@@ -146,6 +147,18 @@ export type AgentEvent = {
     type: 'iteration_limit_extended';
     newMaxIterations: number;
     addedIterations: number;
+} | {
+    type: 'llm_retry';
+    attempt: number;
+    maxAttempts: number;
+    error: string;
+    delayMs: number;
+    provider: string;
+} | {
+    type: 'llm_retry_exhausted';
+    attempts: number;
+    error: string;
+    provider: string;
 };
 /**
  * Event handler function type
@@ -268,6 +281,29 @@ export interface AgentConfig {
      * Event handler for monitoring agent execution
      */
     onEvent?: AgentEventHandler;
+    /**
+     * Configuration for automatic retry on transient LLM errors.
+     * Enabled by default with sensible defaults (10 attempts, exponential backoff).
+     *
+     * Retryable errors include:
+     * - Rate limit (429)
+     * - Server errors (5xx)
+     * - Connection/network errors
+     * - Anthropic overloaded (529)
+     *
+     * @example
+     * ```typescript
+     * const agent = new Agent({
+     *   provider,
+     *   retry: {
+     *     maxAttempts: 5,      // Max 5 retries
+     *     baseDelayMs: 2000,   // Start with 2s delay
+     *     maxDelayMs: 60000,   // Cap at 60s
+     *   }
+     * });
+     * ```
+     */
+    retry?: RetryConfig;
     /**
      * Checkpointer for persisting agent state.
      * If provided, enables checkpoint() and resume() functionality.
@@ -377,6 +413,15 @@ export interface AgentConfig {
      * ```
      */
     permissions?: PermissionManagerOptions;
+    /**
+     * Pre-existing PermissionManager instance.
+     *
+     * Use this to share a PermissionManager between agents (e.g., parent and sub-agents).
+     * When provided, takes precedence over `permissions` options.
+     *
+     * This is primarily used internally for sub-agent permission inheritance.
+     */
+    permissionManager?: PermissionManager;
     /**
      * Pre-loaded project memory to prepend to system prompt.
      *
@@ -649,6 +694,20 @@ export interface SubAgentConfig {
      * Default: false (uses shared store)
      */
     stateIsolation?: boolean;
+    /**
+     * Inherit parent's permission manager.
+     *
+     * When true (default), the sub-agent uses the parent's PermissionManager,
+     * sharing session grants and permission rules. This ensures:
+     * - Sub-agents follow the same permission rules as parent
+     * - Session grants from parent are available to sub-agents
+     * - User sees permission prompts for sub-agent tool usage
+     *
+     * Set to false to allow sub-agents to bypass permissions (use with caution).
+     *
+     * Default: true
+     */
+    inheritPermissions?: boolean;
 }
 /**
  * Result from a sub-agent execution
@@ -712,6 +771,7 @@ export declare class Agent {
     private readonly autoContextManagement;
     private readonly onEvent?;
     private readonly onIterationLimitReached?;
+    private readonly retryConfig;
     private readonly checkpointer?;
     private readonly _sessionId;
     private readonly autoCheckpoint;
@@ -1136,8 +1196,14 @@ export declare class Agent {
     /**
      * Set the conversation history (for manual compaction/restoration)
      * Also updates the context manager's token count if configured.
+     *
+     * @param messages - The message history to restore
+     * @param options - Optional restore options
+     * @param options.turnCount - The turn count to restore (important for compaction)
      */
-    setHistory(messages: Message[]): Promise<this>;
+    setHistory(messages: Message[], options?: {
+        turnCount?: number;
+    }): Promise<this>;
     /**
      * Get the context manager (if configured)
      */
@@ -1454,9 +1520,24 @@ export declare class Agent {
      * Process stream chunks into text, tool uses, and usage data
      */
     private processChunks;
+    /**
+     * Wrap provider.chat() with automatic retry on transient errors.
+     *
+     * Retries the entire stream on failure with exponential backoff.
+     * Emits llm_retry events before each retry attempt.
+     *
+     * @param messages - Messages to send
+     * @param options - Chat options
+     * @param emit - Event emitter function
+     * @param signal - Optional abort signal
+     */
+    private chatWithRetry;
     /**
      * Generate a summary of messages using the LLM provider.
      * Used for context summarization when approaching limits.
+     *
+     * If anchors are configured, the summary will prioritize keeping
+     * information related to anchor content (anchor-weighted summarization).
      */
     private generateSummary;
     /**

package/dist/agent.js

@@ -11,10 +11,11 @@ import { FileAccessTracker } from './context/file-tracker.js';
 import { createFileTrackingHook } from './context/file-tracking-hook.js';
 import { AnchorManager } from './anchors/manager.js';
 import { GuardrailManager } from './guardrails/manager.js';
-import { MaxIterationsError, ToolLoopError } from './errors.js';
+import { MaxIterationsError, ToolLoopError, ProviderError } from './errors.js';
 import { generateSessionId, createAgentState, deserializeTodos } from './state/agent-state.js';
 import { getDefaultTodoStore, createIsolatedTodoStore } from './tools/builtin/todo.js';
 import { repairToolPairing } from './messages/index.js';
+import { DEFAULT_RETRY_CONFIG, withRetryGenerator } from './utils/index.js';
 /**
  * Agent class - orchestrates LLM interactions with tool use
  *
@@ -44,6 +45,8 @@ export class Agent {
     autoContextManagement;
     onEvent;
     onIterationLimitReached;
+    // Retry configuration
+    retryConfig;
     // State management
     checkpointer;
     _sessionId;
@@ -120,7 +123,12 @@ export class Agent {
             this.guardrailManager = new GuardrailManager(config.guardrails);
         }
         // Permission management
-        if (config.permissions !== undefined) {
+        // Use pre-existing permissionManager if provided (for sub-agent inheritance)
+        // Otherwise create one from options
+        if (config.permissionManager !== undefined) {
+            this.permissionManager = config.permissionManager;
+        }
+        else if (config.permissions !== undefined) {
             this.permissionManager = new PermissionManager(config.permissions);
         }
         // Project memory - store and prepend to system prompt
@@ -183,6 +191,13 @@ export class Agent {
             // Hooks manager without file tracking
             this.hooksManager = new HooksManager({ hooks: config.hooks });
         }
+        // Retry configuration with defaults
+        this.retryConfig = {
+            enabled: config.retry?.enabled ?? DEFAULT_RETRY_CONFIG.enabled,
+            maxAttempts: config.retry?.maxAttempts ?? DEFAULT_RETRY_CONFIG.maxAttempts,
+            baseDelayMs: config.retry?.baseDelayMs ?? DEFAULT_RETRY_CONFIG.baseDelayMs,
+            maxDelayMs: config.retry?.maxDelayMs ?? DEFAULT_RETRY_CONFIG.maxDelayMs,
+        };
     }
     // ==========================================================================
     // Static Factory Methods
@@ -710,11 +725,28 @@ export class Agent {
     /**
      * Set the conversation history (for manual compaction/restoration)
      * Also updates the context manager's token count if configured.
+     *
+     * @param messages - The message history to restore
+     * @param options - Optional restore options
+     * @param options.turnCount - The turn count to restore (important for compaction)
      */
-    async setHistory(messages) {
-        this.conversationHistory = [...messages];
+    async setHistory(messages, options) {
+        // Repair tool_use/tool_result pairing to fix any corrupted messages
+        // This is especially important after resuming from a saved session
+        const repairedMessages = repairToolPairing(messages);
+        this.conversationHistory = [...repairedMessages];
         if (this.contextManager) {
-            await this.contextManager.updateTokenCount(messages);
+            await this.contextManager.updateTokenCount(repairedMessages);
+            // Restore turn count if provided
+            if (options?.turnCount !== undefined) {
+                this.contextManager.setTurnCount(options.turnCount);
+            }
+            else {
+                // Infer turn count from messages as a fallback
+                // Count user messages as a proxy for turns
+                const inferredTurnCount = repairedMessages.filter((m) => m.role === 'user').length;
+                this.contextManager.setTurnCount(inferredTurnCount);
+            }
         }
         return this;
     }
@@ -926,6 +958,7 @@ export class Agent {
             messages: this.conversationHistory,
             todos: todoStore.getAll(),
             currentIteration: this._currentIteration,
+            turnCount: this.contextManager?.getTurnCount() ?? 0,
             totalTokensUsed: this._totalTokensUsed,
             createdAt: this._createdAt,
         });
@@ -1054,6 +1087,11 @@ export class Agent {
         agent._createdAt = state.createdAt;
         agent._totalTokensUsed = state.totalTokensUsed;
         agent._currentIteration = state.currentIteration;
+        // Restore turn count to context manager if configured
+        // Note: turnCount is guaranteed to exist - deserializer ensures backward compatibility
+        if (agent.contextManager) {
+            agent.contextManager.setTurnCount(state.turnCount);
+        }
         // Restore todos
         if (state.todos.length > 0) {
             const todoStore = getDefaultTodoStore();
@@ -1118,6 +1156,9 @@ export class Agent {
         for (const tool of toolsToRegister) {
             subAgentToolRegistry.register(tool);
         }
+        // Determine if sub-agent should inherit parent's permissions
+        // Default: true (sub-agents follow same permission rules as parent)
+        const inheritPermissions = config.inheritPermissions ?? true;
         // Create the sub-agent
         const subAgent = new Agent({
             provider: this.provider,
@@ -1128,6 +1169,12 @@ export class Agent {
             contextManager: subAgentContextManager,
             autoContextManagement: true,
             onEvent: this.onEvent, // Forward events to parent
+            // Sub-agents should summarize their findings when hitting iteration limit
+            // rather than throwing an error with no response
+            iterationLimitBehavior: 'summarize',
+            // Inherit parent's permission manager if enabled
+            // This shares session grants and permission rules with sub-agents
+            permissionManager: inheritPermissions ? this.permissionManager : undefined,
         });
         // Store the sub-agent
         this.subAgents.set(config.name, { config, agent: subAgent });
@@ -1390,22 +1437,34 @@ export class Agent {
         // Build messages: system prompt + history + new user message
         let messages = [];
         // Add system message if present
-        if (this.systemPrompt) {
-            messages.push({
-                role: 'system',
-                content: this.systemPrompt,
-            });
-        }
-        // Inject anchors (critical information that survives context compaction)
+        // NOTE: Anchors are now appended to the system prompt (not a separate message)
+        // to avoid multiple system messages which can confuse Claude's role identity
+        let systemContent = this.systemPrompt;
+        // Inject anchors into the system prompt (not as separate message)
         if (this.anchorManager && this.anchorManager.size > 0) {
             const anchorsContent = this.anchorManager.format();
             if (anchorsContent) {
-                messages.push({
-                    role: 'system',
-                    content: `## Active Anchors (Critical Information)\n\n${anchorsContent}`,
-                });
+                // Insert anchors BEFORE the role ending (if present) so role reinforcement stays at the end
+                const roleEndingMarker = '## YOUR ASSIGNED ROLE:';
+                const roleEndingIndex = systemContent.indexOf(roleEndingMarker);
+                if (roleEndingIndex > 0) {
+                    // Insert anchors before the role ending
+                    const beforeRole = systemContent.substring(0, roleEndingIndex);
+                    const roleEnding = systemContent.substring(roleEndingIndex);
+                    systemContent = `${beforeRole}\n\n---\n\n## Active Anchors (Critical Information)\n\n${anchorsContent}\n\n---\n\n${roleEnding}`;
+                }
+                else {
+                    // No role ending, just append anchors
+                    systemContent = `${systemContent}\n\n---\n\n## Active Anchors (Critical Information)\n\n${anchorsContent}`;
+                }
             }
         }
+        if (systemContent) {
+            messages.push({
+                role: 'system',
+                content: systemContent,
+            });
+        }
         // Add conversation history
         messages.push(...this.conversationHistory);
         // Add new user message
@@ -1514,10 +1573,10 @@ export class Agent {
             const llmStartTime = Date.now();
             const chunks = [];
             try {
-                for await (const chunk of this.provider.chat(messages, {
+                for await (const chunk of this.chatWithRetry(messages, {
                     ...chatOptions,
                     tools: tools.length > 0 ? tools : undefined,
-                })) {
+                }, emit, signal)) {
                     // Check for abort during streaming
                     if (signal?.aborted) {
                         aborted = true;
@@ -1615,6 +1674,7 @@ export class Agent {
                         id: tu.id,
                         name: tu.name,
                         input: tu.input,
+                        signature: tu.signature, // Gemini 3 thought signature (required for multi-turn)
                     })),
                 ],
             };
@@ -2111,6 +2171,7 @@ export class Agent {
                             id: chunk.toolUse.id,
                             name: chunk.toolUse.name,
                             inputJson: '',
+                            signature: chunk.toolUse.signature, // Capture Gemini 3 thought signature
                         };
                     }
                     break;
@@ -2129,6 +2190,7 @@ export class Agent {
                                 id: currentToolUse.id,
                                 name: currentToolUse.name,
                                 input,
+                                signature: currentToolUse.signature, // Pass through the signature
                             });
                         }
                         catch {
@@ -2146,27 +2208,100 @@ export class Agent {
         }
         return { text, toolUses, usage, model };
     }
+    /**
+     * Wrap provider.chat() with automatic retry on transient errors.
+     *
+     * Retries the entire stream on failure with exponential backoff.
+     * Emits llm_retry events before each retry attempt.
+     *
+     * @param messages - Messages to send
+     * @param options - Chat options
+     * @param emit - Event emitter function
+     * @param signal - Optional abort signal
+     */
+    chatWithRetry(messages, options, emit, signal) {
+        // If retry is disabled, return the raw provider stream
+        if (!this.retryConfig.enabled) {
+            return this.provider.chat(messages, options);
+        }
+        const providerName = this.provider.name;
+        const { maxAttempts, baseDelayMs, maxDelayMs } = this.retryConfig;
+        return withRetryGenerator(() => this.provider.chat(messages, options), {
+            maxAttempts,
+            baseDelayMs,
+            maxDelayMs,
+            isRetryable: (error) => {
+                // Use the ProviderError's built-in retryable check
+                return error instanceof ProviderError && error.isRetryable();
+            },
+            onRetry: (attempt, max, error, delayMs) => {
+                emit({
+                    type: 'llm_retry',
+                    attempt,
+                    maxAttempts: max,
+                    error: error.message,
+                    delayMs,
+                    provider: providerName,
+                });
+            },
+            onExhausted: (attempts, error) => {
+                emit({
+                    type: 'llm_retry_exhausted',
+                    attempts,
+                    error: error.message,
+                    provider: providerName,
+                });
+            },
+            signal,
+        });
+    }
     /**
      * Generate a summary of messages using the LLM provider.
      * Used for context summarization when approaching limits.
+     *
+     * If anchors are configured, the summary will prioritize keeping
+     * information related to anchor content (anchor-weighted summarization).
      */
     async generateSummary(messages) {
+        // Build anchor context if available (for weighted summarization)
+        let anchorContext = '';
+        if (this.anchorManager && this.anchorManager.size > 0) {
+            const anchors = this.anchorManager.getAll();
+            if (anchors.length > 0) {
+                const anchorItems = anchors.map((a) => `- [${a.priority}] ${a.content}`).join('\n');
+                anchorContext = `
+## PRIORITY CONTEXT (Anchors)
+
+The following are critical anchors that should be preserved in context. When summarizing,
+PRIORITIZE keeping information that relates to these anchors:
+
+${anchorItems}
+
+Ensure the summary captures any conversation details related to these anchors.
+`;
+            }
+        }
         const summaryPrompt = `Please provide a concise summary of the following conversation. Focus on:
 1. Key decisions made
 2. Important context established
 3. Tasks completed or in progress
 4. Any relevant file paths or code snippets mentioned
-
+${anchorContext ? '5. Information related to the priority anchors listed below' : ''}
+${anchorContext}
 Keep the summary under 500 words.
 
 Conversation to summarize:
 ${messages.map((m) => `${m.role}: ${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`).join('\n\n')}`;
         const summaryMessages = [{ role: 'user', content: summaryPrompt }];
+        // Create emit function for retry events (uses main event handler)
+        const emit = (event) => {
+            this.onEvent?.(event);
+        };
         let summary = '';
-        for await (const chunk of this.provider.chat(summaryMessages, {
+        for await (const chunk of this.chatWithRetry(summaryMessages, {
             ...this.chatOptions,
             maxTokens: this.contextManager?.getConfig().summarization.summaryMaxTokens ?? 2000,
-        })) {
+        }, emit)) {
             if (chunk.type === 'text' && chunk.text) {
                 summary += chunk.text;
             }
@@ -2205,11 +2340,15 @@ ${messages
             .map((m) => `${m.role}: ${typeof m.content === 'string' ? m.content.slice(0, 500) : '[complex content]'}`)
             .join('\n\n')}`;
         const summaryMessages = [{ role: 'user', content: summaryPrompt }];
+        // Create emit function for retry events (uses main event handler)
+        const emit = (event) => {
+            this.onEvent?.(event);
+        };
         let summary = '';
-        for await (const chunk of this.provider.chat(summaryMessages, {
+        for await (const chunk of this.chatWithRetry(summaryMessages, {
             ...this.chatOptions,
             maxTokens: 1000, // Keep summary concise
-        })) {
+        }, emit)) {
             if (chunk.type === 'text' && chunk.text) {
                 summary += chunk.text;
             }

package/dist/context/manager.d.ts

@@ -98,6 +98,14 @@ export declare class ContextManager {
      * Increment turn count (call after each assistant response)
      */
     incrementTurn(): void;
+    /**
+     * Get the current turn count
+     */
+    getTurnCount(): number;
+    /**
+     * Set the turn count (for restoring from saved state)
+     */
+    setTurnCount(count: number): void;
     /**
      * Check if compaction is needed
      */

package/dist/context/manager.js

@@ -17,6 +17,7 @@
  * }
  * ```
  */
+import { repairToolPairing } from '../messages/index.js';
 /**
  * Default budget allocation
  */
@@ -176,6 +177,23 @@ export class ContextManager {
     incrementTurn() {
         this.turnCount++;
     }
+    /**
+     * Get the current turn count
+     */
+    getTurnCount() {
+        return this.turnCount;
+    }
+    /**
+     * Set the turn count (for restoring from saved state)
+     */
+    setTurnCount(count) {
+        this.turnCount = count;
+        // If we're restoring state, assume last compaction was at turn 0
+        // to prevent immediate compaction after restore
+        if (this.lastCompactionTurn === 0 && count > 0) {
+            this.lastCompactionTurn = count;
+        }
+    }
     /**
      * Check if compaction is needed
      */
@@ -588,12 +606,15 @@ export class ContextManager {
         }
         // Reconstruct messages in original order
         // System messages come first, then summary (if any), then tool results, then recent
-        const finalMessages = [
+        let finalMessages = [
             ...categorized.system,
             ...compactedHistory,
             ...compactedToolResults,
             ...categorized.recentMessages,
         ];
+        // Repair tool_use/tool_result pairing after compaction
+        // This fixes orphaned blocks that cause API errors
+        finalMessages = repairToolPairing(finalMessages);
         // If history was summarized, add assistant acknowledgment after summary
         if (categoryStats.history.action === 'summarized' && compactedHistory.length > 0) {
             // Insert assistant acknowledgment after the summary message
@@ -894,7 +915,9 @@ export class ContextManager {
                 compactedOld.push({ ...msg, content: compactedBlocks });
             }
         }
-        const compactedMessages = [...compactedOld, ...recentMessages];
+        // Repair tool_use/tool_result pairing after compaction
+        // This fixes orphaned blocks that cause API errors
+        const compactedMessages = repairToolPairing([...compactedOld, ...recentMessages]);
         const tokensAfter = await this.countTokens(compactedMessages);
         this.compactionCount++;
         this.lastCompactionTurn = this.turnCount;

package/dist/errors.d.ts

@@ -43,7 +43,26 @@ export declare class ProviderError extends AgentError {
      */
     isServerError(): boolean;
     /**
-     * Check if this error is retryable
+     * Check if this is a connection/network error.
+     * These errors typically have no status code but are retryable.
+     */
+    isConnectionError(): boolean;
+    /**
+     * Check if this is an Anthropic overloaded error (529)
+     */
+    isOverloadedError(): boolean;
+    /**
+     * Check if this error is retryable.
+     * Retryable errors include:
+     * - Rate limit (429)
+     * - Server errors (5xx)
+     * - Connection/network errors
+     * - Anthropic overloaded (529)
+     *
+     * Non-retryable errors include:
+     * - Authentication errors (401, 403)
+     * - Bad request (400)
+     * - Not found (404)
      */
     isRetryable(): boolean;
 }

package/dist/errors.js

@@ -62,10 +62,52 @@ export class ProviderError extends AgentError {
         return this.statusCode !== undefined && this.statusCode >= 500 && this.statusCode < 600;
     }
     /**
-     * Check if this error is retryable
+     * Check if this is a connection/network error.
+     * These errors typically have no status code but are retryable.
+     */
+    isConnectionError() {
+        if (this.statusCode !== undefined) {
+            return false;
+        }
+        const msg = this.message.toLowerCase();
+        return (msg.includes('connection') ||
+            msg.includes('econnrefused') ||
+            msg.includes('econnreset') ||
+            msg.includes('etimedout') ||
+            msg.includes('enotfound') ||
+            msg.includes('network') ||
+            msg.includes('socket') ||
+            msg.includes('dns'));
+    }
+    /**
+     * Check if this is an Anthropic overloaded error (529)
+     */
+    isOverloadedError() {
+        return this.statusCode === 529;
+    }
+    /**
+     * Check if this error is retryable.
+     * Retryable errors include:
+     * - Rate limit (429)
+     * - Server errors (5xx)
+     * - Connection/network errors
+     * - Anthropic overloaded (529)
+     *
+     * Non-retryable errors include:
+     * - Authentication errors (401, 403)
+     * - Bad request (400)
+     * - Not found (404)
      */
     isRetryable() {
-        return this.isRateLimitError() || this.isServerError();
+        // Never retry auth errors
+        if (this.isAuthError()) {
+            return false;
+        }
+        // Retry transient errors
+        return (this.isRateLimitError() ||
+            this.isServerError() ||
+            this.isConnectionError() ||
+            this.isOverloadedError());
     }
 }
 /**

package/dist/index.d.ts

@@ -15,6 +15,10 @@ export { OpenAIProvider, createOpenAIProvider } from './providers/index.js';
 export type { OpenAIProviderConfig } from './providers/index.js';
 export { GeminiProvider, createGeminiProvider } from './providers/index.js';
 export type { GeminiProviderConfig } from './providers/index.js';
+export { GeminiNativeProvider, createGeminiNativeProvider } from './providers/index.js';
+export type { GeminiNativeProviderConfig } from './providers/index.js';
+export { GeminiLegacyProvider, createGeminiLegacyProvider } from './providers/index.js';
+export type { GeminiLegacyProviderConfig } from './providers/index.js';
 export { OpenAICompatibleProvider } from './providers/index.js';
 export type { OpenAICompatibleConfig } from './providers/index.js';
 export type { Tool, ToolHandler, ToolRegistry, ToolInputSchema, ToolExecutionResult, ToolRegistryOptions, 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';
@@ -22,7 +26,8 @@ export { defineTool, createSuccessResult, createErrorResult, wrapToolExecute, De
 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 { 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 } from './utils/index.js';
+export { generateId, sleep, retry, truncate, withRetryGenerator, calculateBackoffDelay, DEFAULT_RETRY_CONFIG, } 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';

package/dist/index.js

@@ -11,6 +11,10 @@ export { ClaudeProvider, createClaudeProvider } from './providers/index.js';
 export { OllamaProvider, createOllamaProvider } from './providers/index.js';
 export { OpenAIProvider, createOpenAIProvider } from './providers/index.js';
 export { GeminiProvider, createGeminiProvider } from './providers/index.js';
+// Also export native Gemini provider explicitly for clarity
+export { GeminiNativeProvider, createGeminiNativeProvider } from './providers/index.js';
+// Legacy Gemini provider (OpenAI-compatible endpoint)
+export { GeminiLegacyProvider, createGeminiLegacyProvider } from './providers/index.js';
 export { OpenAICompatibleProvider } from './providers/index.js';
 // Tool utilities
 export { defineTool, createSuccessResult, createErrorResult, wrapToolExecute, DefaultToolRegistry, createToolRegistry, } from './tools/index.js';
@@ -25,7 +29,9 @@ TOOL_NAMES, TOOL_SETS, } from './tools/index.js';
 // Message utilities
 export { userMessage, assistantMessage, systemMessage, textBlock, toolUseBlock, toolResultBlock, getTextContent, getToolUses, getToolResults, hasToolUses, validateToolUseResultPairing, repairToolPairing, ensureMessageContent, normalizeMessages, } from './messages/index.js';
 // Utilities
-export { generateId, sleep, retry, truncate } from './utils/index.js';
+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';
 // Errors
 export { AgentError, ProviderError, ToolError, ToolTimeoutError, ToolLoopError, ValidationError, MaxIterationsError, AbortError, ContextOverflowError, isAgentError, isProviderError, isToolError, isToolTimeoutError, isToolLoopError, isContextOverflowError, wrapError, } from './errors.js';
 // Context management