byterover-cli 1.8.0 → 2.0.0

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

@@ -50,20 +50,27 @@ export const BlobStorageConfigSchema = z
  */
 export const AgentConfigSchema = z
     .object({
-    accessToken: z.string().min(1).describe('ByteRover access token'),
     apiBaseUrl: z.string().url().describe('ByteRover API base URL'),
     blobStorage: BlobStorageConfigSchema.optional().describe('Blob storage configuration'),
     fileSystem: FileSystemConfigSchema.optional().describe('File system configuration'),
     httpReferer: z.string().optional().describe('HTTP Referer for OpenRouter rankings'),
     llm: LLMConfigSchema.default({}).describe('LLM configuration'),
+    maxInputTokens: z.number().positive().optional().describe('Context window size from provider API'),
     model: z.string().min(1).describe('LLM model identifier'),
-    openRouterApiKey: z.string().optional().describe('OpenRouter API key'),
+    openRouterApiKey: z.string().optional().describe('OpenRouter API key (backward compat)'),
     projectId: z.string().min(1).describe('ByteRover project ID'),
+    provider: z.string().optional().describe('Direct provider ID (anthropic, openai, google, xai, groq, mistral)'),
+    providerApiKey: z.string().optional().describe('API key for direct provider'),
+    providerBaseUrl: z.string().optional().describe('Base URL for OpenAI-compatible provider'),
+    providerHeaders: z.record(z.string()).optional().describe('Custom headers for provider'),
+    providerLocation: z.string().optional().describe('GCP location for Vertex AI (default: us-central1)'),
+    providerProject: z.string().optional().describe('GCP project ID for Vertex AI'),
     region: z.string().optional().describe('API region'),
-    sessionKey: z.string().min(1).describe('ByteRover session key'),
+    sessionKey: z.string().default('').describe('ByteRover session key'),
     sessions: SessionConfigSchema.default({}).describe('Session management configuration'),
     siteName: z.string().optional().describe('Site name for OpenRouter rankings'),
     spaceId: z.string().optional().describe('ByteRover space ID'),
+    storagePath: z.string().min(1).describe('XDG storage directory for blob, key, and session storage'),
     teamId: z.string().optional().describe('ByteRover team ID'),
     useGranularStorage: z.boolean().default(false).describe('Enable granular history storage'),
 })

package/dist/agent/infra/agent/cipher-agent.d.ts

@@ -1,3 +1,4 @@
+import type { ITransportClient } from '@campfirein/brv-transport-client';
 import type { BrvConfig } from '../../../server/core/domain/entities/brv-config.js';
 import type { GenerateResponse, StreamingEvent, StreamOptions } from '../../core/domain/streaming/types.js';
 import type { CipherAgentServices } from '../../core/interfaces/cipher-services.js';
@@ -11,6 +12,7 @@ import type { SystemPromptManager } from '../system-prompt/system-prompt-manager
 import type { ToolManager } from '../tools/tool-manager.js';
 import type { ToolProvider } from '../tools/tool-provider.js';
 import type { AgentConfig } from './agent-schemas.js';
+import type { ProviderUpdateConfig } from './provider-update-config.js';
 import { AgentEventBus } from '../events/event-emitter.js';
 import { BaseAgent } from './base-agent.js';
 /**
@@ -36,12 +38,18 @@ import { BaseAgent } from './base-agent.js';
 export declare class CipherAgent extends BaseAgent implements ICipherAgent {
     private readonly _agentEventBus;
     private readonly _brvConfig?;
+    private readonly _projectIdProvider?;
     /**
      * Session ID - created once during start().
      * Each agent has exactly 1 session (Single-Session pattern).
      */
     private _sessionId?;
+    private readonly _sessionKeyProvider?;
+    private readonly _spaceIdProvider?;
+    private readonly _teamIdProvider?;
+    private readonly _transportClient?;
     private readonly activeStreamControllers;
+    private eventBridge?;
     private sessionManager?;
     /**
      * Creates a new CipherAgent instance.
@@ -49,8 +57,20 @@ export declare class CipherAgent extends BaseAgent implements ICipherAgent {
      *
      * @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: AgentConfig, brvConfig?: BrvConfig);
+    constructor(config: AgentConfig, brvConfig?: BrvConfig, options?: {
+        projectIdProvider?: () => string;
+        sessionKeyProvider?: () => string;
+        spaceIdProvider?: () => string;
+        teamIdProvider?: () => string;
+        transportClient?: ITransportClient;
+    });
     get agentEventBus(): AgentEventBus | undefined;
     get fileSystemService(): FileSystemService | undefined;
     get historyStorage(): IHistoryStorage | undefined;
@@ -64,6 +84,11 @@ export declare class CipherAgent extends BaseAgent implements ICipherAgent {
     get systemPromptManager(): SystemPromptManager | undefined;
     get toolManager(): ToolManager | undefined;
     get toolProvider(): ToolProvider | undefined;
+    /**
+     * Get the injected transport client (if any).
+     * Available when agent runs as a child process connected to daemon.
+     */
+    get transportClient(): ITransportClient | undefined;
     /**
      * Cancels the currently running turn for the agent's default session.
      * Safe to call even if no run is in progress.
@@ -76,10 +101,27 @@ export declare class CipherAgent extends BaseAgent implements ICipherAgent {
      * Create a new session.
      */
     createSession(sessionId?: string): Promise<IChatSession>;
+    /**
+     * Create a task-scoped child session for parallel execution.
+     * The session gets its own sandbox, context manager, and LLM service.
+     */
+    createTaskSession(taskId: string, commandType: string): Promise<string>;
+    /**
+     * Delete a sandbox variable from the agent's default session.
+     */
+    deleteSandboxVariable(key: string): void;
+    /**
+     * Delete a sandbox variable from a specific session's sandbox.
+     */
+    deleteSandboxVariableOnSession(sessionId: string, key: string): void;
     /**
      * Delete a session completely (memory + history).
      */
     deleteSession(sessionId: string): Promise<boolean>;
+    /**
+     * Delete a task session and all its resources (sandbox + history).
+     */
+    deleteTaskSession(sessionId: string): Promise<void>;
     /**
      * Execute the agent with user input.
      * Uses the agent's default session (created during start()).
@@ -94,6 +136,14 @@ export declare class CipherAgent extends BaseAgent implements ICipherAgent {
         executionContext?: ExecutionContext;
         taskId?: string;
     }): Promise<string>;
+    /**
+     * Execute the agent on a specific session (not the default session).
+     * Used for per-task session isolation in parallel execution.
+     */
+    executeOnSession(sessionId: string, input: string, options?: {
+        executionContext?: ExecutionContext;
+        taskId?: string;
+    }): Promise<string>;
     /**
      * Generate a complete response (waits for full completion).
      * Wrapper around stream() that collects all events and returns final result.
@@ -134,6 +184,17 @@ export declare class CipherAgent extends BaseAgent implements ICipherAgent {
      * List all session IDs (in-memory only).
      */
     listSessions(): string[];
+    /**
+     * 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: ProviderUpdateConfig): void;
     /**
      * Reset the agent to initial state.
      * Resets execution state only. To reset sessions, use resetSession(sessionId).
@@ -143,7 +204,26 @@ export declare class CipherAgent extends BaseAgent implements ICipherAgent {
      * Reset a specific session's conversation history.
      * @param sessionId - The session ID to reset
      */
-    resetSession(sessionId: string): void;
+    resetSession(sessionId: string): Promise<void>;
+    /**
+     * Set a variable in the agent's default session sandbox.
+     */
+    setSandboxVariable(key: string, value: unknown): void;
+    /**
+     * Set a variable in a specific session's sandbox.
+     */
+    setSandboxVariableOnSession(sessionId: string, key: string, value: unknown): void;
+    /**
+     * 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: string): (() => void) | undefined;
     /**
      * Start the agent - initializes all services asynchronously.
      * Must be called before execute().
@@ -166,6 +246,11 @@ export declare class CipherAgent extends BaseAgent implements ICipherAgent {
      * @throws Error if session does not exist
      */
     switchDefaultSession(sessionId: string): void;
+    /**
+     * Build HTTP config for ByteRover API calls.
+     * Uses lazy providers when injected (child process mode), otherwise static config.
+     */
+    private buildHttpConfig;
     private getHistoryStorageInternal;
     private getSessionIdInternal;
     private getSessionManagerInternal;

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

@@ -2,6 +2,7 @@ import { setMaxListeners } from 'node:events';
 import { STREAMING_EVENT_NAMES } from '../../core/domain/streaming/types.js';
 import { AgentEventBus } from '../events/event-emitter.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 +30,18 @@ export class CipherAgent extends BaseAgent {
     // Private state (must come before methods)
     _agentEventBus;
     _brvConfig;
+    _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;
     sessionManager;
     /**
      * Creates a new CipherAgent instance.
@@ -42,18 +49,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 +100,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 +131,18 @@ 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;
+        }
         // Dispose session manager
         if (this.sessionManager) {
             this.sessionManager.dispose();
@@ -138,6 +168,32 @@ export class CipherAgent extends BaseAgent {
         this.ensureStarted();
         return this.getSessionManagerInternal().createSession(sessionId);
     }
+    /**
+     * Create a task-scoped child session for parallel execution.
+     * The session gets its own sandbox, context manager, and LLM service.
+     */
+    async createTaskSession(taskId, commandType) {
+        this.ensureStarted();
+        const sessionMgr = this.getSessionManagerInternal();
+        const parentSessionId = this.getSessionIdInternal();
+        const childSession = await sessionMgr.createChildSession(parentSessionId, commandType, `task-${commandType}-${taskId}`);
+        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).
      */
@@ -149,6 +205,14 @@ export class CipherAgent extends BaseAgent {
         }
         return this.getSessionManagerInternal().deleteSession(sessionId);
     }
+    /**
+     * 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);
+    }
     /**
      * Execute the agent with user input.
      * Uses the agent's default session (created during start()).
@@ -168,6 +232,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.
@@ -279,6 +356,53 @@ export class CipherAgent extends BaseAgent {
         this.ensureStarted();
         return this.getSessionManagerInternal().listSessions();
     }
+    /**
+     * 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,
+            providerLocation: providerUpdate.providerLocation,
+            providerProject: providerUpdate.providerProject,
+            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,
+            },
+        });
+        // Success — dispose old and swap
+        if (this.sessionManager) {
+            this.sessionManager.dispose();
+        }
+        this.sessionManager = newSessionManager;
+        // Re-wire SessionManager into sandbox for tools.agentQuery()
+        this.services.sandboxService.setSessionManager?.(this.sessionManager);
+    }
     // === Protected Methods (implement abstract from BaseAgent) ===
     /**
      * Reset the agent to initial state.
@@ -294,16 +418,44 @@ export class CipherAgent extends 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 +465,21 @@ 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,
+            providerLocation: this.config.providerLocation,
+            providerProject: this.config.providerProject,
             siteName: this.config.siteName,
             temperature: this.config.llm.temperature,
             verbose: this.config.llm.verbose,
@@ -341,10 +491,20 @@ export class CipherAgent extends BaseAgent {
                 sessionTTL: this.config.sessions.sessionTTL,
             },
         });
+        // 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;
+        // 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 +516,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 = [];
@@ -535,6 +696,20 @@ export class CipherAgent extends BaseAgent {
         this._sessionId = sessionId;
     }
     // === Private Helpers (alphabetical order) ===
+    /**
+     * 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 ?? '',
+        };
+    }
     getHistoryStorageInternal() {
         const storage = this.services?.historyStorage;
         if (!storage) {

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,19 @@
+/**
+ * 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>;
+    providerLocation?: string;
+    providerProject?: 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,28 @@ 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, google-vertex, 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>;
+    /** GCP location for Vertex AI (default: us-central1) */
+    providerLocation?: string;
+    /** GCP project ID for Vertex AI */
+    providerProject?: string;
     siteName?: string;
     temperature?: number;
     verbose?: boolean;
@@ -66,7 +87,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)
  *