byterover-cli 1.8.0 → 2.1.0

package/dist/agent/infra/agent/cipher-agent.js

@@ -1,7 +1,14 @@
+import { randomUUID } from 'node:crypto';
 import { setMaxListeners } from 'node:events';
+import { getEffectiveMaxInputTokens, resolveRegistryProvider } from '../../core/domain/llm/index.js';
 import { STREAMING_EVENT_NAMES } from '../../core/domain/streaming/types.js';
+import { ToolName } from '../../core/domain/tools/constants.js';
 import { AgentEventBus } from '../events/event-emitter.js';
+import { createGeneratorForProvider } from '../llm/providers/index.js';
+import { EventBasedLogger } from '../logger/event-based-logger.js';
+import { deregisterRootEligibleSession, registerRootEligibleSession } from '../map/agentic-map-service.js';
 import { SessionManager } from '../session/session-manager.js';
+import { TransportEventBridge } from '../transport/transport-event-bridge.js';
 import { AgentError } from './agent-error.js';
 import { BaseAgent } from './base-agent.js';
 import { createCipherAgentServices } from './service-initializer.js';
@@ -29,12 +36,25 @@ export class CipherAgent extends BaseAgent {
     // Private state (must come before methods)
     _agentEventBus;
     _brvConfig;
+    /** Unique ID for this agent instance — scopes nesting registry ownership. */
+    _instanceId = randomUUID();
+    _projectIdProvider;
     /**
      * Session ID - created once during start().
      * Each agent has exactly 1 session (Single-Session pattern).
      */
     _sessionId;
+    _sessionKeyProvider;
+    _spaceIdProvider;
+    _teamIdProvider;
+    _transportClient;
     activeStreamControllers = new Map();
+    eventBridge;
+    /**
+     * Tracks session IDs this agent instance registered as root-eligible.
+     * Used for bulk deregistration on agent teardown (cleanupServices).
+     */
+    rootEligibleSessions = new Set();
     sessionManager;
     /**
      * Creates a new CipherAgent instance.
@@ -42,18 +62,29 @@ export class CipherAgent extends BaseAgent {
      *
      * @param config - Agent configuration (Zod-validated AgentConfig)
      * @param brvConfig - Optional ByteRover config for spaceId/teamId
+     * @param options - Optional lazy providers and transport client; resolved per HTTP request from StateServer
+     * @param options.projectIdProvider - Lazy provider for project ID
+     * @param options.sessionKeyProvider - Lazy provider for session key
+     * @param options.spaceIdProvider - Lazy provider for space ID
+     * @param options.teamIdProvider - Lazy provider for team ID
+     * @param options.transportClient - Transport client for daemon communication
      */
-    constructor(config, brvConfig) {
+    constructor(config, brvConfig, options) {
         // Call parent constructor (validates with Zod)
         super(config);
         // Create event bus early (DextoAgent pattern - available before start)
         this._agentEventBus = new AgentEventBus();
         this._brvConfig = brvConfig;
+        this._projectIdProvider = options?.projectIdProvider;
+        this._sessionKeyProvider = options?.sessionKeyProvider;
+        this._spaceIdProvider = options?.spaceIdProvider;
+        this._teamIdProvider = options?.teamIdProvider;
+        this._transportClient = options?.transportClient;
     }
-    // === Public Getters (expose services for backward compatibility) ===
     get agentEventBus() {
         return this.services?.agentEventBus;
     }
+    // === Public Getters (expose services for backward compatibility) ===
     get fileSystemService() {
         return this.services?.fileSystemService;
     }
@@ -82,7 +113,13 @@ export class CipherAgent extends BaseAgent {
     get toolProvider() {
         return this.services?.toolProvider;
     }
-    // === Public Methods (alphabetical order) ===
+    /**
+     * Get the injected transport client (if any).
+     * Available when agent runs as a child process connected to daemon.
+     */
+    get transportClient() {
+        return this._transportClient;
+    }
     /**
      * Cancels the currently running turn for the agent's default session.
      * Safe to call even if no run is in progress.
@@ -107,12 +144,25 @@ export class CipherAgent extends BaseAgent {
         // If no session found but stream was aborted, still return true
         return Boolean(streamController);
     }
+    // === Public Methods (alphabetical order) ===
     async cleanupServices() {
         // Abort all active streams and clear controllers
         for (const controller of this.activeStreamControllers.values()) {
             controller.abort();
         }
         this.activeStreamControllers.clear();
+        // Dispose event bridge (removes all transport forwarding listeners)
+        if (this.eventBridge) {
+            this.eventBridge.dispose();
+            this.eventBridge = undefined;
+        }
+        // Deregister all root-eligible sessions before session manager disposal.
+        // stop()/restart() disposes without calling deleteSession() per session,
+        // so this bulk cleanup prevents registry accumulation across restarts.
+        for (const sessionId of this.rootEligibleSessions) {
+            deregisterRootEligibleSession(sessionId, this._instanceId);
+        }
+        this.rootEligibleSessions.clear();
         // Dispose session manager
         if (this.sessionManager) {
             this.sessionManager.dispose();
@@ -136,7 +186,43 @@ export class CipherAgent extends BaseAgent {
      */
     async createSession(sessionId) {
         this.ensureStarted();
-        return this.getSessionManagerInternal().createSession(sessionId);
+        const session = await this.getSessionManagerInternal().createSession(sessionId);
+        this.registerSessionInternal(session.id);
+        return session;
+    }
+    /**
+     * Create a task-scoped child session for parallel execution.
+     * The session gets its own sandbox, context manager, and LLM service.
+     */
+    async createTaskSession(taskId, commandType, options) {
+        this.ensureStarted();
+        const sessionMgr = this.getSessionManagerInternal();
+        const parentSessionId = this.getSessionIdInternal();
+        const childSession = await sessionMgr.createChildSession(parentSessionId, commandType, `task-${commandType}-${taskId}`);
+        // Only register as root-eligible when explicitly opted in.
+        // Top-level executors that may call agentic_map (curate-executor,
+        // folder-pack-executor) pass mapRootEligible: true.
+        // For agentic_map sub-sessions (created by processItem), registration
+        // is skipped here — processItem sets its own isRootCaller: false record.
+        if (options?.mapRootEligible) {
+            this.registerSessionInternal(childSession.id);
+        }
+        return childSession.id;
+    }
+    /**
+     * Delete a sandbox variable from the agent's default session.
+     */
+    deleteSandboxVariable(key) {
+        this.ensureStarted();
+        const sessionId = this.getSessionIdInternal();
+        this.services.sandboxService.deleteSandboxVariable(sessionId, key);
+    }
+    /**
+     * Delete a sandbox variable from a specific session's sandbox.
+     */
+    deleteSandboxVariableOnSession(sessionId, key) {
+        this.ensureStarted();
+        this.services.sandboxService.deleteSandboxVariable(sessionId, key);
     }
     /**
      * Delete a session completely (memory + history).
@@ -147,7 +233,30 @@ export class CipherAgent extends BaseAgent {
         if (this.stateManager) {
             this.stateManager.clearSessionOverride(sessionId);
         }
-        return this.getSessionManagerInternal().deleteSession(sessionId);
+        const deleted = await this.getSessionManagerInternal().deleteSession(sessionId);
+        if (deleted && this.rootEligibleSessions.has(sessionId)) {
+            // Deregister only if this agent instance owns the session.
+            // Scoping prevents one agent's teardown from removing another
+            // agent's live record when they share a session ID.
+            deregisterRootEligibleSession(sessionId, this._instanceId);
+            this.rootEligibleSessions.delete(sessionId);
+        }
+        return deleted;
+    }
+    /**
+     * Delete a task session and all its resources (sandbox + history).
+     */
+    async deleteTaskSession(sessionId) {
+        this.ensureStarted();
+        await this.services.sandboxService.clearSession(sessionId);
+        await this.getSessionManagerInternal().deleteSession(sessionId);
+        // Deregister root-eligible record if this agent owns it.
+        // For agentic_map sub-sessions, the record was overwritten to isRootCaller: false
+        // by processItem, so deregisterRootEligibleSession is a no-op (correct).
+        if (this.rootEligibleSessions.has(sessionId)) {
+            deregisterRootEligibleSession(sessionId, this._instanceId);
+            this.rootEligibleSessions.delete(sessionId);
+        }
     }
     /**
      * Execute the agent with user input.
@@ -168,6 +277,19 @@ export class CipherAgent extends BaseAgent {
         });
         return response.content;
     }
+    /**
+     * Execute the agent on a specific session (not the default session).
+     * Used for per-task session isolation in parallel execution.
+     */
+    async executeOnSession(sessionId, input, options) {
+        this.ensureStarted();
+        const response = await this.generate(input, {
+            executionContext: options?.executionContext,
+            sessionId,
+            taskId: options?.taskId,
+        });
+        return response.content;
+    }
     /**
      * Generate a complete response (waits for full completion).
      * Wrapper around stream() that collects all events and returns final result.
@@ -222,7 +344,11 @@ export class CipherAgent extends BaseAgent {
         this.ensureStarted();
         const sessionMgr = this.getSessionManagerInternal();
         const existingSession = sessionMgr.getSession(sessionId);
-        return existingSession ?? sessionMgr.createSession(sessionId);
+        if (existingSession)
+            return existingSession;
+        const newSession = await sessionMgr.createSession(sessionId);
+        this.registerSessionInternal(newSession.id); // only on actual creation
+        return newSession;
     }
     /**
      * Get a session by ID.
@@ -279,7 +405,63 @@ export class CipherAgent extends BaseAgent {
         this.ensureStarted();
         return this.getSessionManagerInternal().listSessions();
     }
-    // === Protected Methods (implement abstract from BaseAgent) ===
+    /**
+     * Hot-swap the provider/model configuration by rebuilding the SessionManager.
+     * Called by agent-process when a provider:updated event is received.
+     *
+     * Safety: this is called at the start of executeTask (before LLM calls), and
+     * the task queue is sequential (max concurrency = 1), so no concurrent task
+     * can be using the old SessionManager when this runs.
+     *
+     * @param providerUpdate - New provider configuration from daemon state server
+     */
+    refreshProviderConfig(providerUpdate) {
+        this.ensureStarted();
+        const services = this.getServices();
+        const httpConfig = this.buildHttpConfig();
+        // Build new LLM config with updated provider fields
+        const sessionLLMConfig = {
+            httpReferer: this.config.httpReferer,
+            maxInputTokens: providerUpdate.maxInputTokens,
+            maxIterations: this.config.llm.maxIterations,
+            maxTokens: this.config.llm.maxTokens,
+            model: providerUpdate.model,
+            openRouterApiKey: providerUpdate.openRouterApiKey,
+            provider: providerUpdate.provider,
+            providerApiKey: providerUpdate.providerApiKey,
+            providerBaseUrl: providerUpdate.providerBaseUrl,
+            providerHeaders: providerUpdate.providerHeaders,
+            siteName: this.config.siteName,
+            temperature: this.config.llm.temperature,
+            verbose: this.config.llm.verbose,
+        };
+        // Create new SessionManager FIRST — if this throws, old SM remains intact
+        const newSessionManager = new SessionManager(services, httpConfig, sessionLLMConfig, {
+            config: {
+                maxSessions: this.config.sessions.maxSessions,
+                sessionTTL: this.config.sessions.sessionTTL,
+            },
+            onSessionRemoved: (sessionId) => {
+                this.handleSessionRemoved(sessionId);
+            },
+        });
+        // Success — dispose old and swap.
+        // Deregister all root-eligible sessions from the old SM first —
+        // they no longer exist after dispose(). The next stream()/execute()
+        // will recreate sessions via getOrCreateSession and re-register them.
+        if (this.sessionManager) {
+            for (const sid of this.rootEligibleSessions) {
+                deregisterRootEligibleSession(sid, this._instanceId);
+            }
+            this.rootEligibleSessions.clear();
+            this.sessionManager.dispose();
+        }
+        this.sessionManager = newSessionManager;
+        // Re-wire SessionManager into sandbox for tools.agentQuery()
+        this.services.sandboxService.setSessionManager?.(this.sessionManager);
+        // Rebind map tools with fresh generator/tokenizer/maxContextTokens
+        this.rebindMapTools(services, httpConfig, sessionLLMConfig);
+    }
     /**
      * Reset the agent to initial state.
      * Resets execution state only. To reset sessions, use resetSession(sessionId).
@@ -290,20 +472,49 @@ export class CipherAgent extends BaseAgent {
             this.stateManager.reset();
         }
     }
+    // === Protected Methods (implement abstract from BaseAgent) ===
     /**
      * Reset a specific session's conversation history.
      * @param sessionId - The session ID to reset
      */
-    resetSession(sessionId) {
+    async resetSession(sessionId) {
         const session = this.getSessionManagerInternal().getSession(sessionId);
         if (session) {
-            session.reset();
+            await session.reset();
         }
         // Emit conversation reset event (only if agent is started)
         if (this._isStarted && this.services?.agentEventBus) {
             this.services.agentEventBus.emit('cipher:conversationReset', { sessionId });
         }
     }
+    /**
+     * Set a variable in the agent's default session sandbox.
+     */
+    setSandboxVariable(key, value) {
+        this.ensureStarted();
+        const sessionId = this.getSessionIdInternal();
+        this.services.sandboxService.setSandboxVariable(sessionId, key, value);
+    }
+    /**
+     * Set a variable in a specific session's sandbox.
+     */
+    setSandboxVariableOnSession(sessionId, key, value) {
+        this.ensureStarted();
+        this.services.sandboxService.setSandboxVariable(sessionId, key, value);
+    }
+    /**
+     * Setup per-task event forwarding via TransportEventBridge.
+     * Registers listeners on AgentEventBus that forward llmservice:* events
+     * matching the given taskId to the transport server.
+     *
+     * Only effective when a transport client is injected (child process mode).
+     *
+     * @param taskId - Task ID to filter events by
+     * @returns Cleanup function that removes listeners, or undefined if no bridge
+     */
+    setupTaskForwarding(taskId) {
+        return this.eventBridge?.setupForTask(taskId);
+    }
     /**
      * Start the agent - initializes all services asynchronously.
      * Must be called before execute().
@@ -313,23 +524,19 @@ export class CipherAgent extends BaseAgent {
         await super.start();
         // Create SessionManager with shared services
         const services = this.getServices();
-        // Extract HTTP config
-        const httpConfig = {
-            accessToken: this.config.accessToken,
-            apiBaseUrl: this.config.apiBaseUrl,
-            projectId: this.config.projectId,
-            region: this.config.region,
-            sessionKey: this.config.sessionKey,
-            spaceId: this.config.spaceId ?? this._brvConfig?.spaceId ?? '',
-            teamId: this.config.teamId ?? this._brvConfig?.teamId ?? '',
-        };
+        const httpConfig = this.buildHttpConfig();
         // Extract LLM config for sessions
         const sessionLLMConfig = {
             httpReferer: this.config.httpReferer,
+            maxInputTokens: this.config.maxInputTokens,
             maxIterations: this.config.llm.maxIterations,
             maxTokens: this.config.llm.maxTokens,
             model: this.config.model,
             openRouterApiKey: this.config.openRouterApiKey,
+            provider: this.config.provider,
+            providerApiKey: this.config.providerApiKey,
+            providerBaseUrl: this.config.providerBaseUrl,
+            providerHeaders: this.config.providerHeaders,
             siteName: this.config.siteName,
             temperature: this.config.llm.temperature,
             verbose: this.config.llm.verbose,
@@ -340,11 +547,29 @@ export class CipherAgent extends BaseAgent {
                 maxSessions: this.config.sessions.maxSessions,
                 sessionTTL: this.config.sessions.sessionTTL,
             },
+            onSessionRemoved: (sessionId) => {
+                this.handleSessionRemoved(sessionId);
+            },
         });
+        // Wire SessionManager into sandbox for tools.agentQuery() sub-agent delegation
+        this.services.sandboxService.setSessionManager?.(this.sessionManager);
         // Create default session (Single-Session pattern)
         // Each agent has exactly 1 session created at start time
         const defaultSession = await this.sessionManager.createSession();
         this._sessionId = defaultSession.id;
+        this.registerSessionInternal(defaultSession.id);
+        // Inject agent instance and content generator into ToolProvider for map tools.
+        // Uses rebindMapTools() which atomically replaces map tools with fresh deps
+        // (generator, tokenizer, maxContextTokens, logger).
+        this.rebindMapTools(services, httpConfig, sessionLLMConfig);
+        // Create event bridge if transport client is injected (child process mode).
+        // The bridge forwards AgentEventBus llmservice:* events to the transport server.
+        if (this._transportClient) {
+            this.eventBridge = new TransportEventBridge({
+                eventBus: this._agentEventBus,
+                transport: this._transportClient,
+            });
+        }
     }
     /**
      * Stream a response with real-time event emission.
@@ -356,7 +581,8 @@ export class CipherAgent extends BaseAgent {
      */
     async stream(input, options) {
         this.ensureStarted();
-        const sessionId = this.getSessionIdInternal();
+        // Use provided sessionId (per-task session) or fall back to default session
+        const sessionId = options?.sessionId ?? this.getSessionIdInternal();
         const signal = options?.signal;
         // Event queue for aggregation
         const eventQueue = [];
@@ -420,6 +646,9 @@ export class CipherAgent extends BaseAgent {
                 const sessionMgr = this.getSessionManagerInternal();
                 const existingSession = sessionMgr.getSession(sessionId);
                 const session = existingSession ?? (await sessionMgr.createSession(sessionId));
+                if (!existingSession) {
+                    this.registerSessionInternal(session.id); // only on actual creation
+                }
                 // Increment iteration counter
                 this.getStateManager().incrementIteration();
                 // Call session.streamRun() which emits events and run:complete
@@ -534,6 +763,20 @@ export class CipherAgent extends BaseAgent {
         }
         this._sessionId = sessionId;
     }
+    /**
+     * Build HTTP config for ByteRover API calls.
+     * Uses lazy providers when injected (child process mode), otherwise static config.
+     */
+    buildHttpConfig() {
+        return {
+            apiBaseUrl: this.config.apiBaseUrl,
+            projectId: this._projectIdProvider ?? this.config.projectId,
+            region: this.config.region,
+            sessionKey: this._sessionKeyProvider ?? this.config.sessionKey,
+            spaceId: this._spaceIdProvider ?? this.config.spaceId ?? this._brvConfig?.spaceId ?? '',
+            teamId: this._teamIdProvider ?? this.config.teamId ?? this._brvConfig?.teamId ?? '',
+        };
+    }
     // === Private Helpers (alphabetical order) ===
     getHistoryStorageInternal() {
         const storage = this.services?.historyStorage;
@@ -561,4 +804,63 @@ export class CipherAgent extends BaseAgent {
         }
         return manager;
     }
+    /**
+     * Handle SessionManager lifecycle removals (delete/end/TTL-expire) and keep
+     * root-eligible tracking synchronized with the global nesting registry.
+     */
+    handleSessionRemoved(sessionId) {
+        if (!this.rootEligibleSessions.has(sessionId))
+            return;
+        deregisterRootEligibleSession(sessionId, this._instanceId);
+        this.rootEligibleSessions.delete(sessionId);
+    }
+    /**
+     * Rebuild map tool dependencies and update ToolProvider + SandboxService.
+     * Called from both start() (initial setup) and refreshProviderConfig() (hot-swap).
+     */
+    rebindMapTools(services, httpConfig, sessionLLMConfig) {
+        const mapProvider = sessionLLMConfig.provider
+            ?? (sessionLLMConfig.openRouterApiKey ? 'openrouter' : 'byterover');
+        const mapGenerator = createGeneratorForProvider(mapProvider, {
+            apiKey: mapProvider === 'openrouter'
+                ? (sessionLLMConfig.openRouterApiKey ?? sessionLLMConfig.providerApiKey)
+                : sessionLLMConfig.providerApiKey,
+            baseUrl: sessionLLMConfig.providerBaseUrl,
+            headers: sessionLLMConfig.providerHeaders,
+            httpConfig: httpConfig,
+            httpReferer: sessionLLMConfig.httpReferer,
+            maxTokens: 4096,
+            model: sessionLLMConfig.model,
+            siteName: sessionLLMConfig.siteName,
+            temperature: 0,
+        });
+        // Adapter pattern: wrap mapGenerator.estimateTokensSync() as ITokenizer
+        const mapTokenizer = {
+            countTokens: (text) => mapGenerator.estimateTokensSync(text),
+        };
+        // Compute registry-clamped maxContextTokens
+        const mapModel = sessionLLMConfig.model ?? 'gemini-3-flash-preview';
+        const mapRegistryProvider = resolveRegistryProvider(mapModel, mapProvider);
+        const effectiveMaxContextTokens = getEffectiveMaxInputTokens(mapRegistryProvider, mapModel, sessionLLMConfig.maxInputTokens);
+        const mapLogger = new EventBasedLogger(this._agentEventBus, 'MapTools');
+        // Atomically replace map tools with fresh generator/tokenizer/maxContextTokens.
+        // replaceTools() is build-then-swap — if build fails, old tools remain intact.
+        services.toolProvider.replaceTools([ToolName.LLM_MAP, ToolName.AGENTIC_MAP], {
+            agentInstance: this,
+            contentGenerator: mapGenerator,
+            logger: mapLogger,
+            maxContextTokens: effectiveMaxContextTokens,
+            tokenizer: mapTokenizer,
+        });
+        // Update sandbox for tools.curation.mapExtract()
+        services.sandboxService.setContentGenerator?.(mapGenerator);
+    }
+    /**
+     * Register a session as root-eligible and track it for lifecycle cleanup.
+     * Routes all root-eligible registrations through a single point.
+     */
+    registerSessionInternal(sessionId) {
+        registerRootEligibleSession(sessionId, this._instanceId); // throws if id is a live sub-session record
+        this.rootEligibleSessions.add(sessionId);
+    }
 }

package/dist/agent/infra/agent/interactive-loop.js

@@ -128,8 +128,6 @@ function setupEventListeners(eventBus, spinnerState) {
         }
         process.stdout.write('\n' + chalk.red(payload.error) + '\n\n');
     };
-    // eslint-disable-next-line no-warning-comments -- Tracked for v0.5.0 release
-    // TODO(v0.5.0): Move to outer scope for better performance
     // eslint-disable-next-line unicorn/consistent-function-scoping
     const uiListener = (payload) => {
         switch (payload.type) {
@@ -168,8 +166,6 @@ function setupEventListeners(eventBus, spinnerState) {
             }
         }
     };
-    // eslint-disable-next-line no-warning-comments -- Tracked for v0.5.0 release
-    // TODO(v0.5.0): Move to outer scope for better performance
     // eslint-disable-next-line unicorn/consistent-function-scoping
     const logListener = (payload) => {
         const prefix = payload.source ? `[${payload.source}] ` : '';
@@ -274,7 +270,7 @@ async function executePrompt(prompt, agent, state, eventBus) {
  */
 export async function startInteractiveLoop(agent, options) {
     // Display welcome message
-    displayWelcome(options?.sessionId ?? 'cipher-agent-session', options?.model ?? 'gemini-3-flash-preview', options?.eventBus);
+    displayWelcome(options?.sessionId ?? 'agent-session', options?.model ?? 'gemini-3-flash-preview', options?.eventBus);
     // Create readline interface
     const rl = readline.createInterface({
         input: process.stdin,

package/dist/agent/infra/agent/provider-update-config.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Configuration payload for hot-swapping the LLM provider/model at runtime.
+ * Passed from the daemon state server to CipherAgent.refreshProviderConfig().
+ *
+ * Fields mirror the provider-specific subset of ProviderConfigResponse (schemas.ts).
+ * When adding a new provider field to ProviderConfigResponse, update this type
+ * and the explicit mapping in agent-process.ts hotSwapProvider() accordingly.
+ */
+export interface ProviderUpdateConfig {
+    maxInputTokens?: number;
+    model: string;
+    openRouterApiKey?: string;
+    provider?: string;
+    providerApiKey?: string;
+    providerBaseUrl?: string;
+    providerHeaders?: Record<string, string>;
+}

package/dist/agent/infra/agent/service-initializer.d.ts

@@ -15,15 +15,18 @@ import type { ValidatedAgentConfig } from './agent-schemas.js';
 import { AgentEventBus } from '../events/event-emitter.js';
 /**
  * HTTP configuration for ByteRover LLM service.
+ *
+ * projectId, sessionKey, spaceId, teamId accept either a static string or a provider function.
+ * Provider functions are resolved lazily on each HTTP request,
+ * so long-lived agents always get the latest values from the StateServer.
  */
 export interface ByteRoverHttpConfig {
-    accessToken: string;
     apiBaseUrl: string;
-    projectId: string;
+    projectId: (() => string) | string;
     region?: string;
-    sessionKey: string;
-    spaceId: string;
-    teamId: string;
+    sessionKey: (() => string) | string;
+    spaceId: (() => string) | string;
+    teamId: (() => string) | string;
     timeout?: number;
 }
 /**
@@ -31,10 +34,24 @@ export interface ByteRoverHttpConfig {
  */
 export interface SessionLLMConfig {
     httpReferer?: string;
+    /**
+     * Override for the model's context window size in tokens.
+     * When provided for an unknown model (e.g. from OpenRouter API), this becomes
+     * the authoritative context limit instead of the 128K registry fallback.
+     */
+    maxInputTokens?: number;
     maxIterations?: number;
     maxTokens?: number;
     model: string;
     openRouterApiKey?: string;
+    /** Provider ID (anthropic, openai, google, xai, groq, mistral, openrouter, byterover) */
+    provider?: string;
+    /** API key for the direct provider */
+    providerApiKey?: string;
+    /** Base URL for OpenAI-compatible providers */
+    providerBaseUrl?: string;
+    /** Custom headers for the provider */
+    providerHeaders?: Record<string, string>;
     siteName?: string;
     temperature?: number;
     verbose?: boolean;
@@ -55,7 +72,7 @@ export type { CipherAgentServices, SessionManagerConfig, SessionServices } from
  * 8. Policy engine (no dependencies)
  * 9. Tool scheduler (depends on ToolProvider, PolicyEngine)
  * 10. Tool manager (depends on ToolProvider, ToolScheduler)
- * 11. History storage (depends on BlobStorage)
+ * 11. History storage (file-based granular storage)
  * 12. Return all services
  *
  * @param config - Validated agent configuration (Zod-validated)
@@ -66,7 +83,7 @@ export declare function createCipherAgentServices(config: ValidatedAgentConfig,
 /**
  * Creates session-specific services for a ChatSession.
  * Generator composition order (innermost to outermost):
- * 1. Base generator (ByteRoverContentGenerator or OpenRouterContentGenerator)
+ * 1. Base generator (created via provider registry)
  * 2. RetryableContentGenerator - handles transient errors with backoff
  * 3. LoggingContentGenerator - debug logging (if verbose enabled)
  *