byterover-cli 1.5.0 → 1.7.0

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

@@ -0,0 +1,264 @@
+import { z } from 'zod';
+/**
+ * LLM configuration schema with validation and defaults.
+ */
+export declare const LLMConfigSchema: z.ZodObject<{
+    maxIterations: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodDefault<z.ZodNumber>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    topK: z.ZodOptional<z.ZodNumber>;
+    topP: z.ZodOptional<z.ZodNumber>;
+    verbose: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    maxIterations: number;
+    temperature: number;
+    maxTokens: number;
+    verbose: boolean;
+    topK?: number | undefined;
+    topP?: number | undefined;
+}, {
+    maxIterations?: number | undefined;
+    temperature?: number | undefined;
+    maxTokens?: number | undefined;
+    topK?: number | undefined;
+    topP?: number | undefined;
+    verbose?: boolean | undefined;
+}>;
+export type LLMConfig = z.input<typeof LLMConfigSchema>;
+export type ValidatedLLMConfig = z.output<typeof LLMConfigSchema>;
+/**
+ * Session configuration schema.
+ */
+export declare const SessionConfigSchema: z.ZodObject<{
+    maxSessions: z.ZodDefault<z.ZodNumber>;
+    sessionTTL: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    maxSessions: number;
+    sessionTTL: number;
+}, {
+    maxSessions?: number | undefined;
+    sessionTTL?: number | undefined;
+}>;
+export type SessionConfig = z.input<typeof SessionConfigSchema>;
+export type ValidatedSessionConfig = z.output<typeof SessionConfigSchema>;
+/**
+ * File system configuration schema.
+ */
+export declare const FileSystemConfigSchema: z.ZodObject<{
+    allowedExtensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    maxFileSize: z.ZodOptional<z.ZodNumber>;
+    workingDirectory: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    allowedExtensions?: string[] | undefined;
+    workingDirectory?: string | undefined;
+    maxFileSize?: number | undefined;
+}, {
+    allowedExtensions?: string[] | undefined;
+    workingDirectory?: string | undefined;
+    maxFileSize?: number | undefined;
+}>;
+export type FileSystemConfig = z.input<typeof FileSystemConfigSchema>;
+export type ValidatedFileSystemConfig = z.output<typeof FileSystemConfigSchema>;
+/**
+ * Blob storage configuration schema.
+ */
+export declare const BlobStorageConfigSchema: z.ZodObject<{
+    maxBlobSize: z.ZodDefault<z.ZodNumber>;
+    maxTotalSize: z.ZodDefault<z.ZodNumber>;
+    storageDir: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    maxTotalSize: number;
+    maxBlobSize: number;
+    storageDir: string;
+}, {
+    storageDir: string;
+    maxTotalSize?: number | undefined;
+    maxBlobSize?: number | undefined;
+}>;
+export type BlobStorageConfig = z.input<typeof BlobStorageConfigSchema>;
+export type ValidatedBlobStorageConfig = z.output<typeof BlobStorageConfigSchema>;
+/**
+ * Main agent configuration schema.
+ * Combines all sub-schemas with validation and defaults.
+ *
+ * This schema validates and transforms raw config into a fully-typed
+ * configuration with all defaults applied.
+ */
+export declare const AgentConfigSchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    apiBaseUrl: z.ZodString;
+    blobStorage: z.ZodOptional<z.ZodObject<{
+        maxBlobSize: z.ZodDefault<z.ZodNumber>;
+        maxTotalSize: z.ZodDefault<z.ZodNumber>;
+        storageDir: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        maxTotalSize: number;
+        maxBlobSize: number;
+        storageDir: string;
+    }, {
+        storageDir: string;
+        maxTotalSize?: number | undefined;
+        maxBlobSize?: number | undefined;
+    }>>;
+    fileSystem: z.ZodOptional<z.ZodObject<{
+        allowedExtensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        maxFileSize: z.ZodOptional<z.ZodNumber>;
+        workingDirectory: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        allowedExtensions?: string[] | undefined;
+        workingDirectory?: string | undefined;
+        maxFileSize?: number | undefined;
+    }, {
+        allowedExtensions?: string[] | undefined;
+        workingDirectory?: string | undefined;
+        maxFileSize?: number | undefined;
+    }>>;
+    httpReferer: z.ZodOptional<z.ZodString>;
+    llm: z.ZodDefault<z.ZodObject<{
+        maxIterations: z.ZodDefault<z.ZodNumber>;
+        maxTokens: z.ZodDefault<z.ZodNumber>;
+        temperature: z.ZodDefault<z.ZodNumber>;
+        topK: z.ZodOptional<z.ZodNumber>;
+        topP: z.ZodOptional<z.ZodNumber>;
+        verbose: z.ZodDefault<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        maxIterations: number;
+        temperature: number;
+        maxTokens: number;
+        verbose: boolean;
+        topK?: number | undefined;
+        topP?: number | undefined;
+    }, {
+        maxIterations?: number | undefined;
+        temperature?: number | undefined;
+        maxTokens?: number | undefined;
+        topK?: number | undefined;
+        topP?: number | undefined;
+        verbose?: boolean | undefined;
+    }>>;
+    model: z.ZodString;
+    openRouterApiKey: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodString;
+    region: z.ZodOptional<z.ZodString>;
+    sessionKey: z.ZodString;
+    sessions: z.ZodDefault<z.ZodObject<{
+        maxSessions: z.ZodDefault<z.ZodNumber>;
+        sessionTTL: z.ZodDefault<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        maxSessions: number;
+        sessionTTL: number;
+    }, {
+        maxSessions?: number | undefined;
+        sessionTTL?: number | undefined;
+    }>>;
+    siteName: z.ZodOptional<z.ZodString>;
+    spaceId: z.ZodOptional<z.ZodString>;
+    teamId: z.ZodOptional<z.ZodString>;
+    useGranularStorage: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    model: string;
+    llm: {
+        maxIterations: number;
+        temperature: number;
+        maxTokens: number;
+        verbose: boolean;
+        topK?: number | undefined;
+        topP?: number | undefined;
+    };
+    sessions: {
+        maxSessions: number;
+        sessionTTL: number;
+    };
+    accessToken: string;
+    apiBaseUrl: string;
+    projectId: string;
+    sessionKey: string;
+    useGranularStorage: boolean;
+    blobStorage?: {
+        maxTotalSize: number;
+        maxBlobSize: number;
+        storageDir: string;
+    } | undefined;
+    fileSystem?: {
+        allowedExtensions?: string[] | undefined;
+        workingDirectory?: string | undefined;
+        maxFileSize?: number | undefined;
+    } | undefined;
+    httpReferer?: string | undefined;
+    openRouterApiKey?: string | undefined;
+    region?: string | undefined;
+    siteName?: string | undefined;
+    spaceId?: string | undefined;
+    teamId?: string | undefined;
+}, {
+    model: string;
+    accessToken: string;
+    apiBaseUrl: string;
+    projectId: string;
+    sessionKey: string;
+    llm?: {
+        maxIterations?: number | undefined;
+        temperature?: number | undefined;
+        maxTokens?: number | undefined;
+        topK?: number | undefined;
+        topP?: number | undefined;
+        verbose?: boolean | undefined;
+    } | undefined;
+    sessions?: {
+        maxSessions?: number | undefined;
+        sessionTTL?: number | undefined;
+    } | undefined;
+    blobStorage?: {
+        storageDir: string;
+        maxTotalSize?: number | undefined;
+        maxBlobSize?: number | undefined;
+    } | undefined;
+    fileSystem?: {
+        allowedExtensions?: string[] | undefined;
+        workingDirectory?: string | undefined;
+        maxFileSize?: number | undefined;
+    } | undefined;
+    httpReferer?: string | undefined;
+    openRouterApiKey?: string | undefined;
+    region?: string | undefined;
+    siteName?: string | undefined;
+    spaceId?: string | undefined;
+    teamId?: string | undefined;
+    useGranularStorage?: boolean | undefined;
+}>;
+export type AgentConfig = z.input<typeof AgentConfigSchema>;
+export type ValidatedAgentConfig = z.output<typeof AgentConfigSchema>;
+/**
+ * LLM updates schema for runtime config changes.
+ * All fields optional - only provided fields will be updated.
+ */
+export declare const LLMUpdatesSchema: z.ZodObject<{
+    maxIterations: z.ZodOptional<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    model: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    verbose: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    maxIterations?: number | undefined;
+    model?: string | undefined;
+    temperature?: number | undefined;
+    maxTokens?: number | undefined;
+    verbose?: boolean | undefined;
+}, {
+    maxIterations?: number | undefined;
+    model?: string | undefined;
+    temperature?: number | undefined;
+    maxTokens?: number | undefined;
+    verbose?: boolean | undefined;
+}>;
+export type LLMUpdates = z.input<typeof LLMUpdatesSchema>;
+/**
+ * Validate agent configuration.
+ * Returns validated config with defaults applied, or throws on validation error.
+ */
+export declare function validateAgentConfig(config: unknown): ValidatedAgentConfig;
+/**
+ * Safely validate agent configuration.
+ * Returns result object with success flag and either data or error.
+ */
+export declare function safeValidateAgentConfig(config: unknown): z.SafeParseReturnType<AgentConfig, ValidatedAgentConfig>;

package/dist/agent/infra/agent/agent-state-manager.d.ts

@@ -0,0 +1,140 @@
+import type { TerminationReason } from '../../core/domain/agent/agent-state.js';
+import type { AgentExecutionState, AgentState } from '../../core/interfaces/i-cipher-agent.js';
+import type { AgentEventBus } from '../events/event-emitter.js';
+import type { ValidatedAgentConfig, ValidatedLLMConfig } from './agent-schemas.js';
+/**
+ * Session-specific overrides that can differ from the global configuration.
+ */
+export interface SessionOverride {
+    llm?: Partial<ValidatedLLMConfig>;
+}
+/**
+ * Unified agent state manager combining DextoAgent config patterns with execution state tracking.
+ *
+ * Manages two concerns:
+ *
+ * 1. Configuration State (DextoAgent pattern):
+ *    - baselineConfig: Original validated config, never mutated
+ *    - runtimeConfig: Current active config, can be mutated
+ *    - sessionOverrides: Per-session config overrides
+ *
+ * 2. Execution State (runtime tracking):
+ *    - currentIteration: Turn counter
+ *    - executionState: idle | executing | complete | error | aborted | tool_calling
+ *    - terminationReason: Why execution ended
+ *    - timing: startTime, endTime, durationMs
+ *    - toolCallsExecuted: Tool call counter
+ *    - executionHistory: Legacy history records
+ */
+export declare class AgentStateManager {
+    private readonly agentEventBus;
+    private readonly baselineConfig;
+    private currentIteration;
+    private durationMs?;
+    private endTime?;
+    private executionHistory;
+    private executionState;
+    private runtimeConfig;
+    private readonly sessionOverrides;
+    private startTime?;
+    private terminationReason?;
+    private toolCallsExecuted;
+    constructor(staticConfig: ValidatedAgentConfig, agentEventBus: AgentEventBus);
+    /**
+     * Add an execution record to history (legacy method).
+     * @param record - Execution record to add
+     */
+    addExecutionRecord(record: string): void;
+    /**
+     * Clear session-specific overrides.
+     */
+    clearSessionOverride(sessionId: string): void;
+    /**
+     * Mark execution as complete with reason.
+     * @param reason - Why execution terminated
+     */
+    complete(reason: TerminationReason): void;
+    /**
+     * Export current runtime state as a config object.
+     */
+    exportAsConfig(): ValidatedAgentConfig;
+    /**
+     * Mark execution as errored.
+     * @param reason - Error termination reason
+     */
+    fail(reason: TerminationReason): void;
+    /**
+     * Get the original baseline configuration.
+     */
+    getBaselineConfig(): Readonly<ValidatedAgentConfig>;
+    /**
+     * Get the current execution state.
+     * @returns Current agent state with all execution fields
+     */
+    getExecutionState(): AgentState;
+    /**
+     * Get effective LLM config for a session.
+     */
+    getLLMConfig(sessionId?: string): Readonly<ValidatedLLMConfig>;
+    /**
+     * Get the current model identifier.
+     */
+    getModel(sessionId?: string): string;
+    /**
+     * Get runtime configuration for a session (includes session overrides if sessionId provided).
+     */
+    getRuntimeConfig(sessionId?: string): Readonly<ValidatedAgentConfig>;
+    /**
+     * Get all session IDs that have overrides.
+     */
+    getSessionsWithOverrides(): string[];
+    /**
+     * Check if a session has overrides.
+     */
+    hasSessionOverride(sessionId: string): boolean;
+    /**
+     * Increment the iteration counter.
+     * @returns The new iteration count
+     */
+    incrementIteration(): number;
+    /**
+     * Increment the tool calls counter.
+     * @returns The new tool calls count
+     */
+    incrementToolCalls(): number;
+    /**
+     * Reset all state to initial values.
+     * Resets both execution state and configuration state.
+     */
+    reset(): void;
+    /**
+     * Reset runtime configuration to baseline.
+     * Also clears all session overrides.
+     */
+    resetToBaseline(): void;
+    /**
+     * Set the current execution state.
+     * @param state - New execution state
+     */
+    setExecutionState(state: AgentExecutionState): void;
+    /**
+     * Start execution tracking.
+     * Sets startTime and transitions to executing state.
+     */
+    startExecution(): void;
+    /**
+     * Update LLM configuration globally or for a specific session.
+     *
+     * @param updates - Partial LLM configuration updates
+     * @param sessionId - Optional session ID for session-specific override
+     */
+    updateLLM(updates: Partial<ValidatedLLMConfig>, sessionId?: string): void;
+    /**
+     * Update the model globally or for a specific session.
+     */
+    updateModel(model: string, sessionId?: string): void;
+    /**
+     * Set a session-specific override.
+     */
+    private setSessionOverride;
+}

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

@@ -0,0 +1,118 @@
+import type { CipherAgentServices } from '../../core/interfaces/cipher-services.js';
+import type { AgentEventBus } from '../events/event-emitter.js';
+import { type LLMUpdates, type ValidatedAgentConfig, type ValidatedLLMConfig } from './agent-schemas.js';
+import { AgentStateManager } from './agent-state-manager.js';
+/**
+ * Abstract base agent class encapsulating DextoAgent patterns.
+ *
+ * Provides:
+ * - Two-phase initialization (constructor + start)
+ * - Lifecycle management (start, stop, restart)
+ * - State management with session overrides
+ * - Typed error handling
+ * - Configuration validation
+ *
+ * Subclasses must implement:
+ * - initializeServices(): Create agent-specific services
+ * - cleanupServices(): Cleanup on stop
+ */
+export declare abstract class BaseAgent {
+    protected _isStarted: boolean;
+    protected _isStopped: boolean;
+    readonly config: ValidatedAgentConfig;
+    protected services?: CipherAgentServices;
+    protected stateManager?: AgentStateManager;
+    /**
+     * Create a new agent instance.
+     * Does NOT initialize services - call start() for async initialization.
+     *
+     * @param config - Agent configuration (will be validated with Zod)
+     * @throws AgentError if configuration validation fails
+     */
+    constructor(config: unknown);
+    /**
+     * Cleanup agent-specific services.
+     * Called during stop().
+     */
+    protected abstract cleanupServices(): Promise<void>;
+    /**
+     * Clear session-specific configuration overrides.
+     */
+    clearSessionConfig(sessionId: string): void;
+    /**
+     * Ensure the agent is started before operations.
+     * @throws AgentError if not started or stopped
+     */
+    protected ensureStarted(): void;
+    /**
+     * Get the agent event bus (for subscribing to events).
+     */
+    getAgentEventBus(): AgentEventBus;
+    /**
+     * Get the baseline configuration (original config, never modified).
+     */
+    getBaselineConfig(): Readonly<ValidatedAgentConfig>;
+    /**
+     * Get effective configuration for a session.
+     * Includes session-specific overrides if sessionId is provided.
+     */
+    getEffectiveConfig(sessionId?: string): Readonly<ValidatedAgentConfig>;
+    /**
+     * Get current LLM configuration.
+     */
+    getLLMConfig(sessionId?: string): Readonly<ValidatedLLMConfig>;
+    /**
+     * Get services (guaranteed to be defined after start).
+     */
+    protected getServices(): CipherAgentServices;
+    /**
+     * Get the state manager (guaranteed to be defined after start).
+     */
+    protected getStateManager(): AgentStateManager;
+    /**
+     * Initialize agent-specific services.
+     * Called during start().
+     */
+    protected abstract initializeServices(): Promise<CipherAgentServices>;
+    /**
+     * Check if the agent is started.
+     */
+    isStarted(): boolean;
+    /**
+     * Check if the agent is stopped.
+     */
+    isStopped(): boolean;
+    /**
+     * Reset configuration to baseline.
+     */
+    resetConfig(): void;
+    /**
+     * Restart the agent (stop + start).
+     */
+    restart(): Promise<void>;
+    /**
+     * Start the agent and initialize all services.
+     * Must be called before using other methods.
+     *
+     * @throws AgentError if already started or initialization fails
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the agent and cleanup all services.
+     * After stopping, the agent can be restarted with start().
+     */
+    stop(): Promise<void>;
+    /**
+     * Update LLM configuration at runtime.
+     *
+     * @param updates - Partial LLM configuration updates
+     * @param sessionId - Optional session ID for session-specific override
+     * @returns Updated LLM configuration
+     */
+    updateLLM(updates: LLMUpdates, sessionId?: string): ValidatedLLMConfig;
+    /**
+     * Validate that all required services are present.
+     * Can be overridden by subclasses to add custom validation.
+     */
+    protected validateServices(services: CipherAgentServices): void;
+}

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

@@ -0,0 +1,173 @@
+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';
+import type { IChatSession } from '../../core/interfaces/i-chat-session.js';
+import type { AgentState, ExecutionContext, ICipherAgent } from '../../core/interfaces/i-cipher-agent.js';
+import type { IHistoryStorage } from '../../core/interfaces/i-history-storage.js';
+import type { FileSystemService } from '../file-system/file-system-service.js';
+import type { MemoryManager } from '../memory/memory-manager.js';
+import type { ProcessService } from '../process/process-service.js';
+import type { SystemPromptManager } from '../system-prompt/system-prompt-manager.js';
+import type { ToolManager } from '../tools/tool-manager.js';
+import type { ToolProvider } from '../tools/tool-provider.js';
+import type { AgentConfig } from './agent-schemas.js';
+import { AgentEventBus } from '../events/event-emitter.js';
+import { BaseAgent } from './base-agent.js';
+/**
+ * CipherAgent - Main agent implementation extending BaseAgent.
+ *
+ * Inherits from BaseAgent:
+ * - Two-phase initialization (constructor + start)
+ * - Lifecycle management (start, stop, restart)
+ * - State management with session overrides
+ * - Typed error handling
+ * - Configuration validation (Zod)
+ *
+ * Architecture (DextoAgent pattern):
+ * - Agent creates AgentEventBus in constructor (available before start)
+ * - Agent creates and owns shared services (ToolManager, SystemPromptManager, etc.)
+ * - SessionManager creates session-specific services (LLM, SessionEventBus)
+ * - Agent delegates execution to sessions via session.run()
+ *
+ * Usage:
+ * - execute(input) uses default session automatically
+ * - execute(input, sessionId) for multi-session support
+ */
+export declare class CipherAgent extends BaseAgent implements ICipherAgent {
+    private readonly _agentEventBus;
+    private readonly _brvConfig?;
+    /**
+     * Session ID - created once during start().
+     * Each agent has exactly 1 session (Single-Session pattern).
+     */
+    private _sessionId?;
+    private readonly activeStreamControllers;
+    private sessionManager?;
+    /**
+     * Creates a new CipherAgent instance.
+     * Does NOT initialize services - call start() for async initialization.
+     *
+     * @param config - Agent configuration (Zod-validated AgentConfig)
+     * @param brvConfig - Optional ByteRover config for spaceId/teamId
+     */
+    constructor(config: AgentConfig, brvConfig?: BrvConfig);
+    get agentEventBus(): AgentEventBus | undefined;
+    get fileSystemService(): FileSystemService | undefined;
+    get historyStorage(): IHistoryStorage | undefined;
+    get memoryManager(): MemoryManager | undefined;
+    get processService(): ProcessService | undefined;
+    /**
+     * Get the session ID (created during start()).
+     * Each agent has exactly 1 session (Single-Session pattern).
+     */
+    get sessionId(): string | undefined;
+    get systemPromptManager(): SystemPromptManager | undefined;
+    get toolManager(): ToolManager | undefined;
+    get toolProvider(): ToolProvider | undefined;
+    /**
+     * Cancels the currently running turn for the agent's default session.
+     * Safe to call even if no run is in progress.
+     *
+     * @returns true if a run was in progress and was signaled to abort; false otherwise
+     */
+    cancel(): Promise<boolean>;
+    protected cleanupServices(): Promise<void>;
+    /**
+     * Create a new session.
+     */
+    createSession(sessionId?: string): Promise<IChatSession>;
+    /**
+     * Delete a session completely (memory + history).
+     */
+    deleteSession(sessionId: string): Promise<boolean>;
+    /**
+     * Execute the agent with user input.
+     * Uses the agent's default session (created during start()).
+     * Internally uses generate() for single code path maintainability.
+     *
+     * @param input - User message
+     * @param options - Optional execution options
+     * @param options.executionContext - Optional execution context
+     * @param options.taskId - Optional task ID for concurrent task isolation
+     */
+    execute(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.
+     * Uses the agent's default session (created during start()).
+     *
+     * @param input - User message
+     * @param options - Optional configuration (signal for cancellation, taskId for billing)
+     * @returns Complete response with content, usage, and tool calls
+     */
+    generate(input: string, options?: StreamOptions): Promise<GenerateResponse>;
+    /**
+     * Get an existing session or create a new one.
+     */
+    getOrCreateSession(sessionId: string): Promise<IChatSession>;
+    /**
+     * Get a session by ID.
+     */
+    getSession(sessionId: string): IChatSession | undefined;
+    /**
+     * Get session metadata without loading full history.
+     */
+    getSessionMetadata(sessionId: string): Promise<import('../../core/domain/storage/history-types.js').SessionMetadata | undefined>;
+    /**
+     * Get current agent state.
+     * Returns default state if agent is not yet started.
+     */
+    getState(): AgentState;
+    /**
+     * Get the current system prompt.
+     */
+    getSystemPrompt(): Promise<string>;
+    protected initializeServices(): Promise<CipherAgentServices>;
+    /**
+     * List all persisted session IDs from history storage.
+     */
+    listPersistedSessions(): Promise<string[]>;
+    /**
+     * List all session IDs (in-memory only).
+     */
+    listSessions(): string[];
+    /**
+     * Reset the agent to initial state.
+     * Resets execution state only. To reset sessions, use resetSession(sessionId).
+     */
+    reset(): void;
+    /**
+     * Reset a specific session's conversation history.
+     * @param sessionId - The session ID to reset
+     */
+    resetSession(sessionId: string): void;
+    /**
+     * Start the agent - initializes all services asynchronously.
+     * Must be called before execute().
+     */
+    start(): Promise<void>;
+    /**
+     * Stream a response with real-time event emission.
+     * Uses the agent's default session (created during start()).
+     *
+     * @param input - User message
+     * @param options - Optional configuration (signal for cancellation, taskId for billing)
+     * @returns AsyncIterator that yields StreamingEvent objects
+     */
+    stream(input: string, options?: StreamOptions): Promise<AsyncIterableIterator<StreamingEvent>>;
+    /**
+     * Switch the default session to a different session ID.
+     * The session must already exist (created via createSession).
+     *
+     * @param sessionId - The session ID to switch to
+     * @throws Error if session does not exist
+     */
+    switchDefaultSession(sessionId: string): void;
+    private getHistoryStorageInternal;
+    private getSessionIdInternal;
+    private getSessionManagerInternal;
+    private getSystemPromptManagerInternal;
+}