@a3s-lab/code 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,1107 @@
+/**
+ * A3S Code Agent gRPC Client
+ *
+ * Full implementation of the CodeAgentService interface.
+ */
+import { type OpenAIMessage, type OpenAIChatCompletion, type OpenAIChatCompletionChunk } from './openai-compat.js';
+export type HealthStatus = 'STATUS_UNKNOWN' | 'STATUS_HEALTHY' | 'STATUS_DEGRADED' | 'STATUS_UNHEALTHY';
+export type SessionState = 'SESSION_STATE_UNKNOWN' | 'SESSION_STATE_ACTIVE' | 'SESSION_STATE_PAUSED' | 'SESSION_STATE_COMPLETED' | 'SESSION_STATE_ERROR';
+export type MessageRole = 'user' | 'assistant' | 'system' | 'tool';
+export type FinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'error';
+export type ChunkType = 'content' | 'tool_call' | 'tool_result' | 'metadata' | 'done';
+export type EventType = 'EVENT_TYPE_UNKNOWN' | 'EVENT_TYPE_SESSION_CREATED' | 'EVENT_TYPE_SESSION_DESTROYED' | 'EVENT_TYPE_GENERATION_STARTED' | 'EVENT_TYPE_GENERATION_COMPLETED' | 'EVENT_TYPE_TOOL_CALLED' | 'EVENT_TYPE_TOOL_COMPLETED' | 'EVENT_TYPE_ERROR' | 'EVENT_TYPE_WARNING' | 'EVENT_TYPE_INFO' | 'EVENT_TYPE_CONFIRMATION_REQUIRED' | 'EVENT_TYPE_CONFIRMATION_RECEIVED' | 'EVENT_TYPE_CONFIRMATION_TIMEOUT' | 'EVENT_TYPE_EXTERNAL_TASK_PENDING' | 'EVENT_TYPE_EXTERNAL_TASK_COMPLETED' | 'EVENT_TYPE_PERMISSION_DENIED';
+export type SessionLaneType = 'SESSION_LANE_UNKNOWN' | 'SESSION_LANE_CONTROL' | 'SESSION_LANE_QUERY' | 'SESSION_LANE_EXECUTE' | 'SESSION_LANE_GENERATE';
+export type TimeoutActionType = 'TIMEOUT_ACTION_UNKNOWN' | 'TIMEOUT_ACTION_REJECT' | 'TIMEOUT_ACTION_AUTO_APPROVE';
+export type TaskHandlerModeType = 'TASK_HANDLER_MODE_UNKNOWN' | 'TASK_HANDLER_MODE_INTERNAL' | 'TASK_HANDLER_MODE_EXTERNAL' | 'TASK_HANDLER_MODE_HYBRID';
+export type PermissionDecision = 'PERMISSION_DECISION_UNKNOWN' | 'PERMISSION_DECISION_ALLOW' | 'PERMISSION_DECISION_DENY' | 'PERMISSION_DECISION_ASK';
+export type StorageTypeString = 'STORAGE_TYPE_UNSPECIFIED' | 'STORAGE_TYPE_MEMORY' | 'STORAGE_TYPE_FILE';
+export declare const StorageType: {
+    readonly STORAGE_TYPE_UNSPECIFIED: 0;
+    readonly STORAGE_TYPE_MEMORY: 1;
+    readonly STORAGE_TYPE_FILE: 2;
+};
+export declare const SessionLane: {
+    readonly SESSION_LANE_UNKNOWN: 0;
+    readonly SESSION_LANE_CONTROL: 1;
+    readonly SESSION_LANE_QUERY: 2;
+    readonly SESSION_LANE_EXECUTE: 3;
+    readonly SESSION_LANE_GENERATE: 4;
+};
+export declare const TimeoutAction: {
+    readonly TIMEOUT_ACTION_UNKNOWN: 0;
+    readonly TIMEOUT_ACTION_REJECT: 1;
+    readonly TIMEOUT_ACTION_AUTO_APPROVE: 2;
+};
+export declare const TaskHandlerMode: {
+    readonly TASK_HANDLER_MODE_UNKNOWN: 0;
+    readonly TASK_HANDLER_MODE_INTERNAL: 1;
+    readonly TASK_HANDLER_MODE_EXTERNAL: 2;
+    readonly TASK_HANDLER_MODE_HYBRID: 3;
+};
+export interface HealthCheckResponse {
+    status: HealthStatus;
+    message: string;
+    details: Record<string, string>;
+}
+export interface AgentInfo {
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    license: string;
+    homepage: string;
+}
+export interface ToolCapability {
+    name: string;
+    description: string;
+    parameters: string[];
+    async: boolean;
+}
+export interface ModelCapability {
+    provider: string;
+    model: string;
+    features: string[];
+}
+export interface ResourceLimits {
+    maxContextTokens: number;
+    maxConcurrentSessions: number;
+    maxToolsPerRequest: number;
+}
+export interface GetCapabilitiesResponse {
+    info?: AgentInfo;
+    features: string[];
+    tools: ToolCapability[];
+    models: ModelCapability[];
+    limits?: ResourceLimits;
+    metadata: Record<string, string>;
+}
+export interface InitializeResponse {
+    success: boolean;
+    message: string;
+    info?: AgentInfo;
+}
+export interface ShutdownResponse {
+    success: boolean;
+    message: string;
+}
+export interface LLMConfig {
+    provider: string;
+    model: string;
+    apiKey?: string;
+    baseUrl?: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+export interface SessionConfig {
+    name: string;
+    workspace: string;
+    llm?: LLMConfig;
+    systemPrompt?: string;
+    maxContextLength?: number;
+    autoCompact?: boolean;
+    storageType?: number;
+}
+export interface ContextUsage {
+    totalTokens: number;
+    promptTokens: number;
+    completionTokens: number;
+    messageCount: number;
+}
+export interface Session {
+    sessionId: string;
+    config?: SessionConfig;
+    state: SessionState;
+    contextUsage?: ContextUsage;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface CreateSessionResponse {
+    sessionId: string;
+    session?: Session;
+}
+export interface DestroySessionResponse {
+    success: boolean;
+}
+export interface ListSessionsResponse {
+    sessions: Session[];
+}
+export interface GetSessionResponse {
+    session?: Session;
+}
+export interface ConfigureSessionResponse {
+    session?: Session;
+}
+export interface Message {
+    role: MessageRole;
+    content: string;
+    metadata?: Record<string, string>;
+}
+export interface TextContent {
+    text: string;
+}
+export interface ToolUseContent {
+    id: string;
+    name: string;
+    arguments: string;
+}
+export interface ToolResultContent {
+    toolUseId: string;
+    content: string;
+    isError: boolean;
+}
+export interface ContentBlock {
+    text?: TextContent;
+    toolUse?: ToolUseContent;
+    toolResult?: ToolResultContent;
+}
+export interface ConversationMessage {
+    id: string;
+    role: string;
+    content: ContentBlock[];
+    timestamp: number;
+    metadata: Record<string, string>;
+}
+export interface GetMessagesResponse {
+    messages: ConversationMessage[];
+    totalCount: number;
+    hasMore: boolean;
+}
+export interface ToolResult {
+    success: boolean;
+    output: string;
+    error: string;
+    metadata: Record<string, string>;
+}
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+    result?: ToolResult;
+}
+export interface Usage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+export interface GenerateResponse {
+    sessionId: string;
+    message?: Message;
+    toolCalls: ToolCall[];
+    usage?: Usage;
+    finishReason: FinishReason;
+    metadata: Record<string, string>;
+}
+export interface GenerateChunk {
+    type: ChunkType;
+    sessionId: string;
+    content: string;
+    toolCall?: ToolCall;
+    toolResult?: ToolResult;
+    metadata: Record<string, string>;
+    finishReason?: FinishReason;
+}
+export interface GenerateStructuredResponse {
+    sessionId: string;
+    data: string;
+    usage?: Usage;
+    metadata: Record<string, string>;
+}
+export interface GenerateStructuredChunk {
+    sessionId: string;
+    data: string;
+    done: boolean;
+}
+export interface Skill {
+    name: string;
+    description: string;
+    tools: string[];
+    metadata: Record<string, string>;
+}
+export interface LoadSkillResponse {
+    success: boolean;
+    toolNames: string[];
+}
+export interface UnloadSkillResponse {
+    success: boolean;
+    removedTools: string[];
+}
+export interface ListSkillsResponse {
+    skills: Skill[];
+}
+export interface ClaudeCodeSkill {
+    name: string;
+    description: string;
+    allowedTools?: string;
+    disableModelInvocation: boolean;
+    content: string;
+}
+export interface GetClaudeCodeSkillsResponse {
+    skills: ClaudeCodeSkill[];
+}
+export interface GetContextUsageResponse {
+    usage?: ContextUsage;
+}
+export interface CompactContextResponse {
+    success: boolean;
+    before?: ContextUsage;
+    after?: ContextUsage;
+}
+export interface ClearContextResponse {
+    success: boolean;
+}
+export interface AgentEvent {
+    type: EventType;
+    sessionId?: string;
+    timestamp: number;
+    message: string;
+    data: Record<string, string>;
+}
+export interface CancelResponse {
+    success: boolean;
+}
+export interface PauseResponse {
+    success: boolean;
+}
+export interface ResumeResponse {
+    success: boolean;
+}
+export interface ConfirmationPolicy {
+    enabled: boolean;
+    autoApproveTools: string[];
+    requireConfirmTools: string[];
+    defaultTimeoutMs: number;
+    timeoutAction: TimeoutActionType;
+    yoloLanes: SessionLaneType[];
+}
+export interface ConfirmToolExecutionResponse {
+    success: boolean;
+    error: string;
+}
+export interface SetConfirmationPolicyResponse {
+    success: boolean;
+    policy?: ConfirmationPolicy;
+}
+export interface GetConfirmationPolicyResponse {
+    policy?: ConfirmationPolicy;
+}
+export interface LaneHandlerConfig {
+    mode: TaskHandlerModeType;
+    timeoutMs: number;
+}
+export interface ExternalTask {
+    taskId: string;
+    sessionId: string;
+    lane: SessionLaneType;
+    commandType: string;
+    payload: string;
+    timeoutMs: number;
+    remainingMs: number;
+}
+export interface SetLaneHandlerResponse {
+    success: boolean;
+    config?: LaneHandlerConfig;
+}
+export interface GetLaneHandlerResponse {
+    config?: LaneHandlerConfig;
+}
+export interface CompleteExternalTaskResponse {
+    success: boolean;
+    error: string;
+}
+export interface ListPendingExternalTasksResponse {
+    tasks: ExternalTask[];
+}
+export interface PermissionRule {
+    rule: string;
+}
+export interface PermissionPolicy {
+    deny: PermissionRule[];
+    allow: PermissionRule[];
+    ask: PermissionRule[];
+    defaultDecision: PermissionDecision;
+    enabled: boolean;
+}
+export interface SetPermissionPolicyResponse {
+    success: boolean;
+    policy?: PermissionPolicy;
+}
+export interface GetPermissionPolicyResponse {
+    policy?: PermissionPolicy;
+}
+export interface CheckPermissionResponse {
+    decision: PermissionDecision;
+    matchingRules: string[];
+}
+export interface AddPermissionRuleResponse {
+    success: boolean;
+    error: string;
+}
+export interface Todo {
+    id: string;
+    content: string;
+    status: string;
+    priority: string;
+}
+export interface GetTodosResponse {
+    todos: Todo[];
+}
+export interface SetTodosResponse {
+    success: boolean;
+    todos: Todo[];
+}
+export interface ModelCostInfo {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+}
+export interface ModelLimitInfo {
+    context: number;
+    output: number;
+}
+export interface ModelModalitiesInfo {
+    input: string[];
+    output: string[];
+}
+export interface ModelInfo {
+    id: string;
+    name: string;
+    family: string;
+    apiKey?: string;
+    baseUrl?: string;
+    attachment: boolean;
+    reasoning: boolean;
+    toolCall: boolean;
+    temperature: boolean;
+    releaseDate?: string;
+    modalities?: ModelModalitiesInfo;
+    cost?: ModelCostInfo;
+    limit?: ModelLimitInfo;
+}
+export interface ProviderInfo {
+    name: string;
+    apiKey?: string;
+    baseUrl?: string;
+    models: ModelInfo[];
+}
+export interface ListProvidersResponse {
+    providers: ProviderInfo[];
+    defaultProvider?: string;
+    defaultModel?: string;
+}
+export interface GetProviderResponse {
+    provider?: ProviderInfo;
+}
+export interface AddProviderResponse {
+    success: boolean;
+    error: string;
+    provider?: ProviderInfo;
+}
+export interface UpdateProviderResponse {
+    success: boolean;
+    error: string;
+    provider?: ProviderInfo;
+}
+export interface RemoveProviderResponse {
+    success: boolean;
+    error: string;
+}
+export interface SetDefaultModelResponse {
+    success: boolean;
+    error: string;
+    provider: string;
+    model: string;
+}
+export interface GetDefaultModelResponse {
+    provider?: string;
+    model?: string;
+}
+export type Complexity = 'COMPLEXITY_UNKNOWN' | 'COMPLEXITY_SIMPLE' | 'COMPLEXITY_MEDIUM' | 'COMPLEXITY_COMPLEX' | 'COMPLEXITY_VERY_COMPLEX';
+export type StepStatus = 'STEP_STATUS_UNKNOWN' | 'STEP_STATUS_PENDING' | 'STEP_STATUS_IN_PROGRESS' | 'STEP_STATUS_COMPLETED' | 'STEP_STATUS_FAILED' | 'STEP_STATUS_SKIPPED';
+export interface PlanStep {
+    id: string;
+    description: string;
+    tool?: string;
+    dependencies: string[];
+    status: StepStatus;
+    successCriteria: string[];
+}
+export interface ExecutionPlan {
+    goal: string;
+    steps: PlanStep[];
+    complexity: Complexity;
+    requiredTools: string[];
+    estimatedSteps: number;
+}
+export interface AgentGoal {
+    description: string;
+    successCriteria: string[];
+    progress: number;
+    achieved: boolean;
+    createdAt: number;
+    achievedAt?: number;
+}
+export interface CreatePlanResponse {
+    plan?: ExecutionPlan;
+}
+export interface GetPlanResponse {
+    plan?: ExecutionPlan;
+}
+export interface ExtractGoalResponse {
+    goal?: AgentGoal;
+}
+export interface CheckGoalAchievementResponse {
+    achieved: boolean;
+    progress: number;
+    remainingCriteria: string[];
+}
+export type MemoryType = 'MEMORY_TYPE_UNKNOWN' | 'MEMORY_TYPE_EPISODIC' | 'MEMORY_TYPE_SEMANTIC' | 'MEMORY_TYPE_PROCEDURAL' | 'MEMORY_TYPE_WORKING';
+export interface MemoryItem {
+    id: string;
+    content: string;
+    timestamp: number;
+    importance: number;
+    tags: string[];
+    memoryType: MemoryType;
+    metadata: Record<string, string>;
+    accessCount: number;
+    lastAccessed?: number;
+}
+export interface MemoryStats {
+    longTermCount: number;
+    shortTermCount: number;
+    workingCount: number;
+}
+export interface StoreMemoryResponse {
+    success: boolean;
+    memoryId: string;
+}
+export interface RetrieveMemoryResponse {
+    memory?: MemoryItem;
+}
+export interface SearchMemoriesResponse {
+    memories: MemoryItem[];
+    totalCount: number;
+}
+export interface GetMemoryStatsResponse {
+    stats?: MemoryStats;
+}
+export interface ClearMemoriesResponse {
+    success: boolean;
+    clearedCount: number;
+}
+export interface McpStdioTransport {
+    command: string;
+    args: string[];
+}
+export interface McpHttpTransport {
+    url: string;
+    headers: Record<string, string>;
+}
+export interface McpTransport {
+    stdio?: McpStdioTransport;
+    http?: McpHttpTransport;
+}
+export interface McpServerConfig {
+    name: string;
+    transport: McpTransport;
+    enabled: boolean;
+    env: Record<string, string>;
+}
+export interface RegisterMcpServerResponse {
+    success: boolean;
+    message: string;
+}
+export interface ConnectMcpServerResponse {
+    success: boolean;
+    message: string;
+    toolNames: string[];
+}
+export interface DisconnectMcpServerResponse {
+    success: boolean;
+}
+export interface McpServerInfo {
+    name: string;
+    connected: boolean;
+    enabled: boolean;
+    toolCount: number;
+    error?: string;
+}
+export interface ListMcpServersResponse {
+    servers: McpServerInfo[];
+}
+export interface McpToolInfo {
+    fullName: string;
+    serverName: string;
+    toolName: string;
+    description: string;
+    inputSchema: string;
+}
+export interface GetMcpToolsResponse {
+    tools: McpToolInfo[];
+}
+export interface LspServerInfo {
+    language: string;
+    name: string;
+    version?: string;
+    running: boolean;
+}
+export interface LspPosition {
+    line: number;
+    character: number;
+}
+export interface LspRange {
+    start: LspPosition;
+    end: LspPosition;
+}
+export interface LspLocation {
+    uri: string;
+    range?: LspRange;
+}
+export interface LspSymbol {
+    name: string;
+    kind: string;
+    location?: LspLocation;
+    containerName?: string;
+}
+export interface LspDiagnostic {
+    uri: string;
+    range?: LspRange;
+    severity: string;
+    message: string;
+    code?: string;
+    source?: string;
+}
+export interface StartLspServerResponse {
+    success: boolean;
+    message: string;
+    serverInfo?: LspServerInfo;
+}
+export interface StopLspServerResponse {
+    success: boolean;
+}
+export interface ListLspServersResponse {
+    servers: LspServerInfo[];
+}
+export interface LspHoverResponse {
+    found: boolean;
+    content: string;
+    range?: LspRange;
+}
+export interface LspDefinitionResponse {
+    locations: LspLocation[];
+}
+export interface LspReferencesResponse {
+    locations: LspLocation[];
+}
+export interface LspSymbolsResponse {
+    symbols: LspSymbol[];
+}
+export interface LspDiagnosticsResponse {
+    diagnostics: LspDiagnostic[];
+}
+export type CronJobStatus = 'CRON_JOB_STATUS_UNKNOWN' | 'CRON_JOB_STATUS_ACTIVE' | 'CRON_JOB_STATUS_PAUSED' | 'CRON_JOB_STATUS_RUNNING';
+export type CronExecutionStatus = 'CRON_EXECUTION_STATUS_UNKNOWN' | 'CRON_EXECUTION_STATUS_SUCCESS' | 'CRON_EXECUTION_STATUS_FAILED' | 'CRON_EXECUTION_STATUS_TIMEOUT' | 'CRON_EXECUTION_STATUS_CANCELLED';
+export declare const CronJobStatusEnum: {
+    readonly UNKNOWN: 0;
+    readonly ACTIVE: 1;
+    readonly PAUSED: 2;
+    readonly RUNNING: 3;
+};
+export declare const CronExecutionStatusEnum: {
+    readonly UNKNOWN: 0;
+    readonly SUCCESS: 1;
+    readonly FAILED: 2;
+    readonly TIMEOUT: 3;
+    readonly CANCELLED: 4;
+};
+export interface CronJob {
+    id: string;
+    name: string;
+    schedule: string;
+    command: string;
+    status: number;
+    timeoutMs: number;
+    createdAt: number;
+    updatedAt: number;
+    lastRun?: number;
+    nextRun?: number;
+    runCount: number;
+    failCount: number;
+    workingDir?: string;
+}
+export interface CronExecution {
+    id: string;
+    jobId: string;
+    status: number;
+    startedAt: number;
+    endedAt?: number;
+    durationMs?: number;
+    exitCode?: number;
+    stdout: string;
+    stderr: string;
+    error?: string;
+}
+export interface ListCronJobsResponse {
+    jobs: CronJob[];
+}
+export interface CreateCronJobResponse {
+    success: boolean;
+    job?: CronJob;
+    error: string;
+}
+export interface GetCronJobResponse {
+    job?: CronJob;
+}
+export interface UpdateCronJobResponse {
+    success: boolean;
+    job?: CronJob;
+    error: string;
+}
+export interface PauseCronJobResponse {
+    success: boolean;
+    job?: CronJob;
+    error: string;
+}
+export interface ResumeCronJobResponse {
+    success: boolean;
+    job?: CronJob;
+    error: string;
+}
+export interface DeleteCronJobResponse {
+    success: boolean;
+    error: string;
+}
+export interface GetCronHistoryResponse {
+    executions: CronExecution[];
+}
+export interface RunCronJobResponse {
+    success: boolean;
+    execution?: CronExecution;
+    error: string;
+}
+export interface ParseCronScheduleResponse {
+    success: boolean;
+    cronExpression: string;
+    description: string;
+    error: string;
+}
+export interface A3sClientOptions {
+    /** gRPC server address (default: localhost:4088) */
+    address?: string;
+    /** Use TLS for connection */
+    useTls?: boolean;
+    /** Connection timeout in milliseconds */
+    timeout?: number;
+    /** Path to config directory containing config.json */
+    configDir?: string;
+    /** Path to config.json file */
+    configPath?: string;
+}
+/**
+ * A3S Code Agent gRPC Client
+ *
+ * Provides a TypeScript interface to all CodeAgentService RPCs.
+ *
+ * @example
+ * ```typescript
+ * // Create client with config directory
+ * const client = new A3sClient({ configDir: '/path/to/a3s' });
+ *
+ * // Create client with config file
+ * const client = new A3sClient({ configPath: '/path/to/config.json' });
+ *
+ * // Create client with explicit address
+ * const client = new A3sClient({ address: 'localhost:4088' });
+ * ```
+ */
+export declare class A3sClient {
+    private client;
+    private address;
+    private configDir?;
+    constructor(options?: A3sClientOptions);
+    /**
+     * Get the config directory path
+     */
+    getConfigDir(): string | undefined;
+    /**
+     * Get the server address
+     */
+    getAddress(): string;
+    /**
+     * Close the client connection
+     */
+    close(): void;
+    private promisify;
+    /**
+     * Check the health status of the agent
+     */
+    healthCheck(): Promise<HealthCheckResponse>;
+    /**
+     * Get agent capabilities
+     */
+    getCapabilities(): Promise<GetCapabilitiesResponse>;
+    /**
+     * Initialize the agent with workspace and environment
+     */
+    initialize(workspace: string, env?: Record<string, string>): Promise<InitializeResponse>;
+    /**
+     * Shutdown the agent
+     */
+    shutdown(): Promise<ShutdownResponse>;
+    /**
+     * Create a new session
+     */
+    createSession(config?: SessionConfig, sessionId?: string, initialContext?: Message[]): Promise<CreateSessionResponse>;
+    /**
+     * Destroy a session
+     */
+    destroySession(sessionId: string): Promise<DestroySessionResponse>;
+    /**
+     * List all sessions
+     */
+    listSessions(): Promise<ListSessionsResponse>;
+    /**
+     * Get a specific session
+     */
+    getSession(sessionId: string): Promise<GetSessionResponse>;
+    /**
+     * Configure a session
+     */
+    configureSession(sessionId: string, config: SessionConfig): Promise<ConfigureSessionResponse>;
+    /**
+     * Get messages from a session
+     */
+    getMessages(sessionId: string, limit?: number, offset?: number): Promise<GetMessagesResponse>;
+    /**
+     * Generate a response (unary)
+     *
+     * Supports both A3S and OpenAI message formats:
+     * - A3S: { role: 'ROLE_USER', content: '...' }
+     * - OpenAI: { role: 'user', content: '...' }
+     */
+    generate(sessionId: string, messages: (Message | OpenAIMessage)[]): Promise<GenerateResponse>;
+    /**
+     * Generate a response (streaming)
+     *
+     * Supports both A3S and OpenAI message formats.
+     */
+    streamGenerate(sessionId: string, messages: (Message | OpenAIMessage)[]): AsyncIterable<GenerateChunk>;
+    /**
+     * Generate structured output (unary)
+     *
+     * Supports both A3S and OpenAI message formats.
+     */
+    generateStructured(sessionId: string, messages: (Message | OpenAIMessage)[], schema: string): Promise<GenerateStructuredResponse>;
+    /**
+     * Generate structured output (streaming)
+     *
+     * Supports both A3S and OpenAI message formats.
+     */
+    streamGenerateStructured(sessionId: string, messages: (Message | OpenAIMessage)[], schema: string): AsyncIterable<GenerateStructuredChunk>;
+    /**
+     * Generate a response in OpenAI ChatCompletion format
+     *
+     * This method provides full OpenAI API compatibility.
+     *
+     * @example
+     * ```typescript
+     * const completion = await client.chatCompletion(sessionId, [
+     *   { role: 'user', content: 'Hello!' }
+     * ]);
+     * console.log(completion.choices[0].message.content);
+     * ```
+     */
+    chatCompletion(sessionId: string, messages: OpenAIMessage[], options?: {
+        model?: string;
+    }): Promise<OpenAIChatCompletion>;
+    /**
+     * Stream a response in OpenAI ChatCompletionChunk format
+     *
+     * This method provides full OpenAI API compatibility for streaming.
+     *
+     * @example
+     * ```typescript
+     * for await (const chunk of client.streamChatCompletion(sessionId, [
+     *   { role: 'user', content: 'Hello!' }
+     * ])) {
+     *   const content = chunk.choices[0].delta.content;
+     *   if (content) process.stdout.write(content);
+     * }
+     * ```
+     */
+    streamChatCompletion(sessionId: string, messages: OpenAIMessage[], options?: {
+        model?: string;
+    }): AsyncIterable<OpenAIChatCompletionChunk>;
+    /**
+     * Load a skill into a session
+     */
+    loadSkill(sessionId: string, skillName: string, skillContent?: string): Promise<LoadSkillResponse>;
+    /**
+     * Unload a skill from a session
+     */
+    unloadSkill(sessionId: string, skillName: string): Promise<UnloadSkillResponse>;
+    /**
+     * List available skills
+     */
+    listSkills(sessionId?: string): Promise<ListSkillsResponse>;
+    /**
+     * Get Claude Code skills
+     */
+    getClaudeCodeSkills(name?: string): Promise<GetClaudeCodeSkillsResponse>;
+    /**
+     * Get context usage for a session
+     */
+    getContextUsage(sessionId: string): Promise<GetContextUsageResponse>;
+    /**
+     * Compact context for a session
+     */
+    compactContext(sessionId: string): Promise<CompactContextResponse>;
+    /**
+     * Clear context for a session
+     */
+    clearContext(sessionId: string): Promise<ClearContextResponse>;
+    /**
+     * Subscribe to agent events
+     */
+    subscribeEvents(sessionId?: string, eventTypes?: string[]): AsyncIterable<AgentEvent>;
+    /**
+     * Cancel an operation
+     */
+    cancel(sessionId: string, operationId?: string): Promise<CancelResponse>;
+    /**
+     * Pause a session
+     */
+    pause(sessionId: string): Promise<PauseResponse>;
+    /**
+     * Resume a session
+     */
+    resume(sessionId: string): Promise<ResumeResponse>;
+    /**
+     * Confirm or reject tool execution
+     */
+    confirmToolExecution(sessionId: string, toolId: string, approved: boolean, reason?: string): Promise<ConfirmToolExecutionResponse>;
+    /**
+     * Set confirmation policy for a session
+     */
+    setConfirmationPolicy(sessionId: string, policy: ConfirmationPolicy): Promise<SetConfirmationPolicyResponse>;
+    /**
+     * Get confirmation policy for a session
+     */
+    getConfirmationPolicy(sessionId: string): Promise<GetConfirmationPolicyResponse>;
+    /**
+     * Set lane handler configuration
+     */
+    setLaneHandler(sessionId: string, lane: SessionLaneType, config: LaneHandlerConfig): Promise<SetLaneHandlerResponse>;
+    /**
+     * Get lane handler configuration
+     */
+    getLaneHandler(sessionId: string, lane: SessionLaneType): Promise<GetLaneHandlerResponse>;
+    /**
+     * Complete an external task
+     */
+    completeExternalTask(sessionId: string, taskId: string, success: boolean, result?: string, error?: string): Promise<CompleteExternalTaskResponse>;
+    /**
+     * List pending external tasks
+     */
+    listPendingExternalTasks(sessionId: string): Promise<ListPendingExternalTasksResponse>;
+    /**
+     * Set permission policy for a session
+     */
+    setPermissionPolicy(sessionId: string, policy: PermissionPolicy): Promise<SetPermissionPolicyResponse>;
+    /**
+     * Get permission policy for a session
+     */
+    getPermissionPolicy(sessionId: string): Promise<GetPermissionPolicyResponse>;
+    /**
+     * Check permission for a tool call
+     */
+    checkPermission(sessionId: string, toolName: string, args: string): Promise<CheckPermissionResponse>;
+    /**
+     * Add a permission rule
+     */
+    addPermissionRule(sessionId: string, ruleType: 'allow' | 'deny' | 'ask', rule: string): Promise<AddPermissionRuleResponse>;
+    /**
+     * Get todos for a session
+     */
+    getTodos(sessionId: string): Promise<GetTodosResponse>;
+    /**
+     * Set todos for a session
+     */
+    setTodos(sessionId: string, todos: Todo[]): Promise<SetTodosResponse>;
+    /**
+     * List all providers
+     */
+    listProviders(): Promise<ListProvidersResponse>;
+    /**
+     * Get a specific provider
+     */
+    getProvider(name: string): Promise<GetProviderResponse>;
+    /**
+     * Add a new provider
+     */
+    addProvider(provider: ProviderInfo): Promise<AddProviderResponse>;
+    /**
+     * Update an existing provider
+     */
+    updateProvider(provider: ProviderInfo): Promise<UpdateProviderResponse>;
+    /**
+     * Remove a provider
+     */
+    removeProvider(name: string): Promise<RemoveProviderResponse>;
+    /**
+     * Set the default model
+     */
+    setDefaultModel(provider: string, model: string): Promise<SetDefaultModelResponse>;
+    /**
+     * Get the default model
+     */
+    getDefaultModel(): Promise<GetDefaultModelResponse>;
+    /**
+     * Create an execution plan
+     */
+    createPlan(sessionId: string, prompt: string, context?: string): Promise<CreatePlanResponse>;
+    /**
+     * Get an existing plan
+     */
+    getPlan(sessionId: string, planId: string): Promise<GetPlanResponse>;
+    /**
+     * Extract goal from prompt
+     */
+    extractGoal(sessionId: string, prompt: string): Promise<ExtractGoalResponse>;
+    /**
+     * Check if goal is achieved
+     */
+    checkGoalAchievement(sessionId: string, goal: AgentGoal, currentState: string): Promise<CheckGoalAchievementResponse>;
+    /**
+     * Store a memory item
+     */
+    storeMemory(sessionId: string, memory: MemoryItem): Promise<StoreMemoryResponse>;
+    /**
+     * Retrieve a memory by ID
+     */
+    retrieveMemory(sessionId: string, memoryId: string): Promise<RetrieveMemoryResponse>;
+    /**
+     * Search memories
+     */
+    searchMemories(sessionId: string, query?: string, tags?: string[], limit?: number, recentOnly?: boolean, minImportance?: number): Promise<SearchMemoriesResponse>;
+    /**
+     * Get memory statistics
+     */
+    getMemoryStats(sessionId: string): Promise<GetMemoryStatsResponse>;
+    /**
+     * Clear memories
+     */
+    clearMemories(sessionId: string, clearLongTerm?: boolean, clearShortTerm?: boolean, clearWorking?: boolean): Promise<ClearMemoriesResponse>;
+    /**
+     * Register an MCP server
+     */
+    registerMcpServer(config: McpServerConfig): Promise<RegisterMcpServerResponse>;
+    /**
+     * Connect to an MCP server
+     */
+    connectMcpServer(name: string): Promise<ConnectMcpServerResponse>;
+    /**
+     * Disconnect from an MCP server
+     */
+    disconnectMcpServer(name: string): Promise<DisconnectMcpServerResponse>;
+    /**
+     * List all MCP servers
+     */
+    listMcpServers(): Promise<ListMcpServersResponse>;
+    /**
+     * Get MCP tools
+     */
+    getMcpTools(serverName?: string): Promise<GetMcpToolsResponse>;
+    /**
+     * Start a language server for a specific language
+     */
+    startLspServer(language: string, rootUri?: string): Promise<StartLspServerResponse>;
+    /**
+     * Stop a running language server
+     */
+    stopLspServer(language: string): Promise<StopLspServerResponse>;
+    /**
+     * List all running language servers
+     */
+    listLspServers(): Promise<ListLspServersResponse>;
+    /**
+     * Get hover information at a specific position
+     */
+    lspHover(filePath: string, line: number, column: number): Promise<LspHoverResponse>;
+    /**
+     * Go to definition at a specific position
+     */
+    lspDefinition(filePath: string, line: number, column: number): Promise<LspDefinitionResponse>;
+    /**
+     * Find all references at a specific position
+     */
+    lspReferences(filePath: string, line: number, column: number, includeDeclaration?: boolean): Promise<LspReferencesResponse>;
+    /**
+     * Search for symbols in the workspace
+     */
+    lspSymbols(query: string, limit?: number): Promise<LspSymbolsResponse>;
+    /**
+     * Get diagnostics for a file
+     */
+    lspDiagnostics(filePath?: string): Promise<LspDiagnosticsResponse>;
+    /**
+     * List all cron jobs
+     */
+    listCronJobs(): Promise<ListCronJobsResponse>;
+    /**
+     * Create a new cron job
+     * @param name Job name
+     * @param schedule Schedule expression (cron syntax or natural language)
+     * @param command Command to execute
+     * @param timeoutMs Execution timeout in milliseconds (default: 60000)
+     */
+    createCronJob(name: string, schedule: string, command: string, timeoutMs?: number): Promise<CreateCronJobResponse>;
+    /**
+     * Get a cron job by ID or name
+     * @param id Job ID
+     * @param name Job name (alternative to ID)
+     */
+    getCronJob(id?: string, name?: string): Promise<GetCronJobResponse>;
+    /**
+     * Update a cron job
+     * @param id Job ID
+     * @param schedule New schedule expression
+     * @param command New command
+     * @param timeoutMs New timeout
+     */
+    updateCronJob(id: string, schedule?: string, command?: string, timeoutMs?: number): Promise<UpdateCronJobResponse>;
+    /**
+     * Pause a cron job
+     * @param id Job ID
+     */
+    pauseCronJob(id: string): Promise<PauseCronJobResponse>;
+    /**
+     * Resume a paused cron job
+     * @param id Job ID
+     */
+    resumeCronJob(id: string): Promise<ResumeCronJobResponse>;
+    /**
+     * Delete a cron job
+     * @param id Job ID
+     */
+    deleteCronJob(id: string): Promise<DeleteCronJobResponse>;
+    /**
+     * Get execution history for a cron job
+     * @param id Job ID
+     * @param limit Max records to return (default: 10)
+     */
+    getCronHistory(id: string, limit?: number): Promise<GetCronHistoryResponse>;
+    /**
+     * Manually run a cron job
+     * @param id Job ID
+     */
+    runCronJob(id: string): Promise<RunCronJobResponse>;
+    /**
+     * Parse natural language schedule to cron expression
+     * @param input Natural language or cron expression
+     */
+    parseCronSchedule(input: string): Promise<ParseCronScheduleResponse>;
+    private streamToAsyncIterable;
+}
+//# sourceMappingURL=client.d.ts.map