@xutest1/sdk 0.1.7 → 0.2.0

package/gen/types.gen.d.ts

@@ -0,0 +1,2868 @@
+export type Project = {
+    id: string;
+    worktree: string;
+    vcs?: "git";
+    time: {
+        created: number;
+        initialized?: number;
+    };
+};
+/**
+ * Custom keybind configurations
+ */
+export type KeybindsConfig = {
+    /**
+     * Leader key for keybind combinations
+     */
+    leader?: string;
+    /**
+     * Show help dialog
+     */
+    app_help?: string;
+    /**
+     * Exit the application
+     */
+    app_exit?: string;
+    /**
+     * Open external editor
+     */
+    editor_open?: string;
+    /**
+     * List available themes
+     */
+    theme_list?: string;
+    /**
+     * Create/update AGENTS.md
+     */
+    project_init?: string;
+    /**
+     * Toggle tool details
+     */
+    tool_details?: string;
+    /**
+     * Toggle thinking blocks
+     */
+    thinking_blocks?: string;
+    /**
+     * Export session to editor
+     */
+    session_export?: string;
+    /**
+     * Create a new session
+     */
+    session_new?: string;
+    /**
+     * List all sessions
+     */
+    session_list?: string;
+    /**
+     * Show session timeline
+     */
+    session_timeline?: string;
+    /**
+     * Share current session
+     */
+    session_share?: string;
+    /**
+     * Unshare current session
+     */
+    session_unshare?: string;
+    /**
+     * Interrupt current session
+     */
+    session_interrupt?: string;
+    /**
+     * Compact the session
+     */
+    session_compact?: string;
+    /**
+     * Cycle to next child session
+     */
+    session_child_cycle?: string;
+    /**
+     * Cycle to previous child session
+     */
+    session_child_cycle_reverse?: string;
+    /**
+     * Scroll messages up by one page
+     */
+    messages_page_up?: string;
+    /**
+     * Scroll messages down by one page
+     */
+    messages_page_down?: string;
+    /**
+     * Scroll messages up by half page
+     */
+    messages_half_page_up?: string;
+    /**
+     * Scroll messages down by half page
+     */
+    messages_half_page_down?: string;
+    /**
+     * Navigate to first message
+     */
+    messages_first?: string;
+    /**
+     * Navigate to last message
+     */
+    messages_last?: string;
+    /**
+     * Copy message
+     */
+    messages_copy?: string;
+    /**
+     * Undo message
+     */
+    messages_undo?: string;
+    /**
+     * Redo message
+     */
+    messages_redo?: string;
+    /**
+     * List available models
+     */
+    model_list?: string;
+    /**
+     * Next recent model
+     */
+    model_cycle_recent?: string;
+    /**
+     * Previous recent model
+     */
+    model_cycle_recent_reverse?: string;
+    /**
+     * List agents
+     */
+    agent_list?: string;
+    /**
+     * Next agent
+     */
+    agent_cycle?: string;
+    /**
+     * Previous agent
+     */
+    agent_cycle_reverse?: string;
+    /**
+     * Clear input field
+     */
+    input_clear?: string;
+    /**
+     * Paste from clipboard
+     */
+    input_paste?: string;
+    /**
+     * Submit input
+     */
+    input_submit?: string;
+    /**
+     * Insert newline in input
+     */
+    input_newline?: string;
+    /**
+     * @deprecated use agent_cycle. Next mode
+     */
+    switch_mode?: string;
+    /**
+     * @deprecated use agent_cycle_reverse. Previous mode
+     */
+    switch_mode_reverse?: string;
+    /**
+     * @deprecated use agent_cycle. Next agent
+     */
+    switch_agent?: string;
+    /**
+     * @deprecated use agent_cycle_reverse. Previous agent
+     */
+    switch_agent_reverse?: string;
+    /**
+     * @deprecated Currently not available. List files
+     */
+    file_list?: string;
+    /**
+     * @deprecated Close file
+     */
+    file_close?: string;
+    /**
+     * @deprecated Search file
+     */
+    file_search?: string;
+    /**
+     * @deprecated Split/unified diff
+     */
+    file_diff_toggle?: string;
+    /**
+     * @deprecated Navigate to previous message
+     */
+    messages_previous?: string;
+    /**
+     * @deprecated Navigate to next message
+     */
+    messages_next?: string;
+    /**
+     * @deprecated Toggle layout
+     */
+    messages_layout_toggle?: string;
+    /**
+     * @deprecated use messages_undo. Revert message
+     */
+    messages_revert?: string;
+};
+export type AgentConfig = {
+    model?: string;
+    temperature?: number;
+    top_p?: number;
+    prompt?: string;
+    tools?: {
+        [key: string]: boolean;
+    };
+    disable?: boolean;
+    /**
+     * Description of when to use the agent
+     */
+    description?: string;
+    mode?: "subagent" | "primary" | "all";
+    permission?: {
+        edit?: "ask" | "allow" | "deny";
+        bash?: ("ask" | "allow" | "deny") | {
+            [key: string]: "ask" | "allow" | "deny";
+        };
+        webfetch?: "ask" | "allow" | "deny";
+    };
+    [key: string]: unknown | string | number | {
+        [key: string]: boolean;
+    } | boolean | ("subagent" | "primary" | "all") | {
+        edit?: "ask" | "allow" | "deny";
+        bash?: ("ask" | "allow" | "deny") | {
+            [key: string]: "ask" | "allow" | "deny";
+        };
+        webfetch?: "ask" | "allow" | "deny";
+    } | undefined;
+};
+export type McpLocalConfig = {
+    /**
+     * Type of MCP server connection
+     */
+    type: "local";
+    /**
+     * Command and arguments to run the MCP server
+     */
+    command: Array<string>;
+    /**
+     * Environment variables to set when running the MCP server
+     */
+    environment?: {
+        [key: string]: string;
+    };
+    /**
+     * Enable or disable the MCP server on startup
+     */
+    enabled?: boolean;
+};
+export type McpRemoteConfig = {
+    /**
+     * Type of MCP server connection
+     */
+    type: "remote";
+    /**
+     * URL of the remote MCP server
+     */
+    url: string;
+    /**
+     * Enable or disable the MCP server on startup
+     */
+    enabled?: boolean;
+    /**
+     * Headers to send with the request
+     */
+    headers?: {
+        [key: string]: string;
+    };
+};
+/**
+ * @deprecated Always uses stretch layout.
+ */
+export type LayoutConfig = "auto" | "stretch";
+export type Config = {
+    /**
+     * JSON schema reference for configuration validation
+     */
+    $schema?: string;
+    /**
+     * Theme name to use for the interface
+     */
+    theme?: string;
+    keybinds?: KeybindsConfig;
+    /**
+     * TUI specific settings
+     */
+    tui?: {
+        /**
+         * TUI scroll speed
+         */
+        scroll_speed?: number;
+    };
+    /**
+     * Command configuration, see https://opencode.ai/docs/commands
+     */
+    command?: {
+        [key: string]: {
+            template: string;
+            description?: string;
+            agent?: string;
+            model?: string;
+            subtask?: boolean;
+        };
+    };
+    watcher?: {
+        ignore?: Array<string>;
+    };
+    plugin?: Array<string>;
+    snapshot?: boolean;
+    /**
+     * Control sharing behavior:'manual' allows manual sharing via commands, 'auto' enables automatic sharing, 'disabled' disables all sharing
+     */
+    share?: "manual" | "auto" | "disabled";
+    /**
+     * @deprecated Use 'share' field instead. Share newly created sessions automatically
+     */
+    autoshare?: boolean;
+    /**
+     * Automatically update to the latest version
+     */
+    autoupdate?: boolean;
+    /**
+     * Custom update server URL for checking and downloading updates
+     */
+    updateServer?: string;
+    /**
+     * Disable providers that are loaded automatically
+     */
+    disabled_providers?: Array<string>;
+    /**
+     * Model to use in the format of provider/model, eg anthropic/claude-2
+     */
+    model?: string;
+    /**
+     * Small model to use for tasks like title generation in the format of provider/model
+     */
+    small_model?: string;
+    /**
+     * Custom username to display in conversations instead of system username
+     */
+    username?: string;
+    /**
+     * @deprecated Use `agent` field instead.
+     */
+    mode?: {
+        build?: AgentConfig;
+        plan?: AgentConfig;
+        [key: string]: AgentConfig | undefined;
+    };
+    /**
+     * Agent configuration, see https://opencode.ai/docs/agent
+     */
+    agent?: {
+        plan?: AgentConfig;
+        build?: AgentConfig;
+        general?: AgentConfig;
+        [key: string]: AgentConfig | undefined;
+    };
+    /**
+     * Custom provider configurations and model overrides
+     */
+    provider?: {
+        [key: string]: {
+            api?: string;
+            name?: string;
+            env?: Array<string>;
+            id?: string;
+            npm?: string;
+            models?: {
+                [key: string]: {
+                    id?: string;
+                    name?: string;
+                    release_date?: string;
+                    attachment?: boolean;
+                    reasoning?: boolean;
+                    temperature?: boolean;
+                    tool_call?: boolean;
+                    cost?: {
+                        input: number;
+                        output: number;
+                        cache_read?: number;
+                        cache_write?: number;
+                    };
+                    limit?: {
+                        context: number;
+                        output: number;
+                    };
+                    modalities?: {
+                        input: Array<"text" | "audio" | "image" | "video" | "pdf">;
+                        output: Array<"text" | "audio" | "image" | "video" | "pdf">;
+                    };
+                    experimental?: boolean;
+                    status?: "alpha" | "beta";
+                    options?: {
+                        [key: string]: unknown;
+                    };
+                    provider?: {
+                        npm: string;
+                    };
+                };
+            };
+            options?: {
+                apiKey?: string;
+                baseURL?: string;
+                /**
+                 * Timeout in milliseconds for requests to this provider. Default is 300000 (5 minutes). Set to false to disable timeout.
+                 */
+                timeout?: number | false;
+                [key: string]: unknown | string | (number | false) | undefined;
+            };
+        };
+    };
+    /**
+     * MCP (Model Context Protocol) server configurations
+     */
+    mcp?: {
+        [key: string]: McpLocalConfig | McpRemoteConfig;
+    };
+    formatter?: {
+        [key: string]: {
+            disabled?: boolean;
+            command?: Array<string>;
+            environment?: {
+                [key: string]: string;
+            };
+            extensions?: Array<string>;
+        };
+    };
+    lsp?: {
+        [key: string]: {
+            disabled: true;
+        } | {
+            command: Array<string>;
+            extensions?: Array<string>;
+            disabled?: boolean;
+            env?: {
+                [key: string]: string;
+            };
+            initialization?: {
+                [key: string]: unknown;
+            };
+        };
+    };
+    /**
+     * Additional instruction files or patterns to include
+     */
+    instructions?: Array<string>;
+    layout?: LayoutConfig;
+    permission?: {
+        edit?: "ask" | "allow" | "deny";
+        bash?: ("ask" | "allow" | "deny") | {
+            [key: string]: "ask" | "allow" | "deny";
+        };
+        webfetch?: "ask" | "allow" | "deny";
+    };
+    tools?: {
+        [key: string]: boolean;
+    };
+    experimental?: {
+        hook?: {
+            file_edited?: {
+                [key: string]: Array<{
+                    command: Array<string>;
+                    environment?: {
+                        [key: string]: string;
+                    };
+                }>;
+            };
+            session_completed?: Array<{
+                command: Array<string>;
+                environment?: {
+                    [key: string]: string;
+                };
+            }>;
+        };
+        /**
+         * Number of retries for chat completions on failure
+         */
+        chatMaxRetries?: number;
+        disable_paste_summary?: boolean;
+    };
+    /**
+     * Enable data science mode for Jupyter notebook support
+     */
+    dataScienceMode?: boolean;
+    /**
+     * Enable spec trajectory evaluation mode for improving specs based on execution feedback
+     */
+    specTrajectoryMode?: boolean;
+    /**
+     * List of enabled MCP server IDs
+     */
+    enabledMcps?: Array<string>;
+    /**
+     * Whether the selected model is a public model
+     */
+    public?: boolean;
+};
+export type BadRequestError = {
+    data: unknown | null;
+    errors: Array<{
+        [key: string]: unknown;
+    }>;
+    success: false;
+};
+export type ToolIds = Array<string>;
+export type ToolListItem = {
+    id: string;
+    description: string;
+    parameters: unknown;
+};
+export type ToolList = Array<ToolListItem>;
+export type Path = {
+    state: string;
+    config: string;
+    worktree: string;
+    directory: string;
+};
+export type FileDiff = {
+    file: string;
+    before: string;
+    after: string;
+    additions: number;
+    deletions: number;
+};
+export type Session = {
+    id: string;
+    projectID: string;
+    directory: string;
+    parentID?: string;
+    userContext?: string;
+    summary?: {
+        diffs: Array<FileDiff>;
+    };
+    share?: {
+        url: string;
+    };
+    title: string;
+    version: string;
+    time: {
+        created: number;
+        updated: number;
+        compacting?: number;
+    };
+    revert?: {
+        messageID: string;
+        partID?: string;
+        snapshot?: string;
+        diff?: string;
+    };
+};
+export type NotFoundError = {
+    name: "NotFoundError";
+    data: {
+        message: string;
+    };
+};
+export type Todo = {
+    /**
+     * Brief description of the task
+     */
+    content: string;
+    /**
+     * Current status of the task: pending, in_progress, completed, cancelled
+     */
+    status: string;
+    /**
+     * Priority level of the task: high, medium, low
+     */
+    priority: string;
+    /**
+     * Unique identifier for the todo item
+     */
+    id: string;
+};
+export type UserMessage = {
+    id: string;
+    sessionID: string;
+    role: "user";
+    time: {
+        created: number;
+    };
+    summary?: {
+        title?: string;
+        body?: string;
+        diffs: Array<FileDiff>;
+    };
+};
+export type ProviderAuthError = {
+    name: "ProviderAuthError";
+    data: {
+        providerID: string;
+        message: string;
+    };
+};
+export type UnknownError = {
+    name: "UnknownError";
+    data: {
+        message: string;
+    };
+};
+export type MessageOutputLengthError = {
+    name: "MessageOutputLengthError";
+    data: {
+        [key: string]: unknown;
+    };
+};
+export type MessageAbortedError = {
+    name: "MessageAbortedError";
+    data: {
+        message: string;
+    };
+};
+export type ApiError = {
+    name: "APIError";
+    data: {
+        message: string;
+        statusCode?: number;
+        isRetryable: boolean;
+        responseHeaders?: {
+            [key: string]: string;
+        };
+        responseBody?: string;
+    };
+};
+export type AssistantMessage = {
+    id: string;
+    sessionID: string;
+    role: "assistant";
+    time: {
+        created: number;
+        completed?: number;
+    };
+    error?: ProviderAuthError | UnknownError | MessageOutputLengthError | MessageAbortedError | ApiError;
+    system: Array<string>;
+    parentID: string;
+    modelID: string;
+    providerID: string;
+    mode: string;
+    path: {
+        cwd: string;
+        root: string;
+    };
+    summary?: boolean;
+    cost: number;
+    tokens: {
+        input: number;
+        output: number;
+        reasoning: number;
+        cache: {
+            read: number;
+            write: number;
+        };
+    };
+};
+export type Message = UserMessage | AssistantMessage;
+export type TextPart = {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "text";
+    text: string;
+    synthetic?: boolean;
+    time?: {
+        start: number;
+        end?: number;
+    };
+    metadata?: {
+        [key: string]: unknown;
+    };
+};
+export type ReasoningPart = {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "reasoning";
+    text: string;
+    metadata?: {
+        [key: string]: unknown;
+    };
+    time: {
+        start: number;
+        end?: number;
+    };
+};
+export type FilePartSourceText = {
+    value: string;
+    start: number;
+    end: number;
+};
+export type FileSource = {
+    text: FilePartSourceText;
+    type: "file";
+    path: string;
+};
+export type Range = {
+    start: {
+        line: number;
+        character: number;
+    };
+    end: {
+        line: number;
+        character: number;
+    };
+};
+export type SymbolSource = {
+    text: FilePartSourceText;
+    type: "symbol";
+    path: string;
+    range: Range;
+    name: string;
+    kind: number;
+};
+export type FilePartSource = FileSource | SymbolSource;
+export type FilePart = {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "file";
+    mime: string;
+    filename?: string;
+    url: string;
+    source?: FilePartSource;
+};
+export type ToolStatePending = {
+    status: "pending";
+};
+export type ToolStateRunning = {
+    status: "running";
+    input: unknown;
+    title?: string;
+    metadata?: {
+        [key: string]: unknown;
+    };
+    time: {
+        start: number;
+    };
+};
+export type ToolStateCompleted = {
+    status: "completed";
+    input: {
+        [key: string]: unknown;
+    };
+    output: string;
+    title: string;
+    metadata: {
+        [key: string]: unknown;
+    };
+    time: {
+        start: number;
+        end: number;
+        compacted?: number;
+    };
+    attachments?: Array<FilePart>;
+};
+export type ToolStateError = {
+    status: "error";
+    input: {
+        [key: string]: unknown;
+    };
+    error: string;
+    metadata?: {
+        [key: string]: unknown;
+    };
+    time: {
+        start: number;
+        end: number;
+    };
+};
+export type ToolState = ToolStatePending | ToolStateRunning | ToolStateCompleted | ToolStateError;
+export type ToolPart = {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "tool";
+    callID: string;
+    tool: string;
+    state: ToolState;
+    metadata?: {
+        [key: string]: unknown;
+    };
+};
+export type StepStartPart = {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "step-start";
+    snapshot?: string;
+};
+export type StepFinishPart = {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "step-finish";
+    reason: string;
+    snapshot?: string;
+    cost: number;
+    tokens: {
+        input: number;
+        output: number;
+        reasoning: number;
+        cache: {
+            read: number;
+            write: number;
+        };
+    };
+};
+export type SnapshotPart = {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "snapshot";
+    snapshot: string;
+};
+export type PatchPart = {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "patch";
+    hash: string;
+    files: Array<string>;
+};
+export type AgentPart = {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "agent";
+    name: string;
+    source?: {
+        value: string;
+        start: number;
+        end: number;
+    };
+};
+export type RetryPart = {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "retry";
+    attempt: number;
+    error: ApiError;
+    time: {
+        created: number;
+    };
+};
+export type Part = TextPart | ReasoningPart | FilePart | ToolPart | StepStartPart | StepFinishPart | SnapshotPart | PatchPart | AgentPart | RetryPart;
+export type TextPartInput = {
+    id?: string;
+    type: "text";
+    text: string;
+    synthetic?: boolean;
+    time?: {
+        start: number;
+        end?: number;
+    };
+    metadata?: {
+        [key: string]: unknown;
+    };
+};
+export type FilePartInput = {
+    id?: string;
+    type: "file";
+    mime: string;
+    filename?: string;
+    url: string;
+    source?: FilePartSource;
+};
+export type AgentPartInput = {
+    id?: string;
+    type: "agent";
+    name: string;
+    source?: {
+        value: string;
+        start: number;
+        end: number;
+    };
+};
+export type Command = {
+    name: string;
+    description?: string;
+    agent?: string;
+    model?: string;
+    template: string;
+    subtask?: boolean;
+};
+export type Model = {
+    id: string;
+    name: string;
+    release_date: string;
+    attachment: boolean;
+    reasoning: boolean;
+    temperature: boolean;
+    tool_call: boolean;
+    cost: {
+        input: number;
+        output: number;
+        cache_read?: number;
+        cache_write?: number;
+    };
+    limit: {
+        context: number;
+        output: number;
+    };
+    modalities?: {
+        input: Array<"text" | "audio" | "image" | "video" | "pdf">;
+        output: Array<"text" | "audio" | "image" | "video" | "pdf">;
+    };
+    experimental?: boolean;
+    status?: "alpha" | "beta";
+    options: {
+        [key: string]: unknown;
+    };
+    provider?: {
+        npm: string;
+    };
+};
+export type Provider = {
+    api?: string;
+    name: string;
+    env: Array<string>;
+    id: string;
+    npm?: string;
+    models: {
+        [key: string]: Model;
+    };
+};
+export type Symbol = {
+    name: string;
+    kind: number;
+    location: {
+        uri: string;
+        range: Range;
+    };
+};
+export type FileNode = {
+    name: string;
+    path: string;
+    absolute: string;
+    type: "file" | "directory";
+    ignored: boolean;
+};
+export type FileContent = {
+    type: "text";
+    content: string;
+    diff?: string;
+    patch?: {
+        oldFileName: string;
+        newFileName: string;
+        oldHeader?: string;
+        newHeader?: string;
+        hunks: Array<{
+            oldStart: number;
+            oldLines: number;
+            newStart: number;
+            newLines: number;
+            lines: Array<string>;
+        }>;
+        index?: string;
+    };
+    encoding?: "base64";
+    mimeType?: string;
+};
+export type File = {
+    path: string;
+    added: number;
+    removed: number;
+    status: "added" | "deleted" | "modified";
+};
+export type Agent = {
+    name: string;
+    description?: string;
+    mode: "subagent" | "primary" | "all";
+    builtIn: boolean;
+    topP?: number;
+    temperature?: number;
+    permission: {
+        edit: "ask" | "allow" | "deny";
+        bash: {
+            [key: string]: "ask" | "allow" | "deny";
+        };
+        webfetch?: "ask" | "allow" | "deny";
+    };
+    model?: {
+        modelID: string;
+        providerID: string;
+    };
+    prompt?: string;
+    tools: {
+        [key: string]: boolean;
+    };
+    options: {
+        [key: string]: unknown;
+    };
+};
+export type OAuth = {
+    type: "oauth";
+    refresh: string;
+    access: string;
+    expires: number;
+};
+export type ApiAuth = {
+    type: "api";
+    key: string;
+};
+export type WellKnownAuth = {
+    type: "wellknown";
+    key: string;
+    token: string;
+};
+export type Auth = OAuth | ApiAuth | WellKnownAuth;
+export type EventInstallationUpdated = {
+    type: "installation.updated";
+    properties: {
+        version: string;
+    };
+};
+export type EventLspClientDiagnostics = {
+    type: "lsp.client.diagnostics";
+    properties: {
+        serverID: string;
+        path: string;
+    };
+};
+export type EventMessageUpdated = {
+    type: "message.updated";
+    properties: {
+        info: Message;
+    };
+};
+export type EventMessageRemoved = {
+    type: "message.removed";
+    properties: {
+        sessionID: string;
+        messageID: string;
+    };
+};
+export type EventMessagePartUpdated = {
+    type: "message.part.updated";
+    properties: {
+        part: Part;
+        delta?: string;
+    };
+};
+export type EventMessagePartRemoved = {
+    type: "message.part.removed";
+    properties: {
+        sessionID: string;
+        messageID: string;
+        partID: string;
+    };
+};
+export type EventSessionCompacted = {
+    type: "session.compacted";
+    properties: {
+        sessionID: string;
+    };
+};
+export type Permission = {
+    id: string;
+    type: string;
+    pattern?: string | Array<string>;
+    sessionID: string;
+    messageID: string;
+    callID?: string;
+    title: string;
+    metadata: {
+        [key: string]: unknown;
+    };
+    time: {
+        created: number;
+    };
+};
+export type EventPermissionUpdated = {
+    type: "permission.updated";
+    properties: Permission;
+};
+export type EventPermissionReplied = {
+    type: "permission.replied";
+    properties: {
+        sessionID: string;
+        permissionID: string;
+        response: string;
+    };
+};
+export type EventFileEdited = {
+    type: "file.edited";
+    properties: {
+        file: string;
+    };
+};
+export type EventFileWatcherUpdated = {
+    type: "file.watcher.updated";
+    properties: {
+        file: string;
+        event: "add" | "change" | "unlink";
+    };
+};
+export type EventTodoUpdated = {
+    type: "todo.updated";
+    properties: {
+        sessionID: string;
+        todos: Array<Todo>;
+    };
+};
+export type EventSessionIdle = {
+    type: "session.idle";
+    properties: {
+        sessionID: string;
+    };
+};
+export type EventSessionCreated = {
+    type: "session.created";
+    properties: {
+        info: Session;
+    };
+};
+export type EventSessionUpdated = {
+    type: "session.updated";
+    properties: {
+        info: Session;
+    };
+};
+export type EventSessionDeleted = {
+    type: "session.deleted";
+    properties: {
+        info: Session;
+    };
+};
+export type EventSessionError = {
+    type: "session.error";
+    properties: {
+        sessionID?: string;
+        error?: ProviderAuthError | UnknownError | MessageOutputLengthError | MessageAbortedError | ApiError;
+    };
+};
+export type EventServerConnected = {
+    type: "server.connected";
+    properties: {
+        [key: string]: unknown;
+    };
+};
+export type EventIdeInstalled = {
+    type: "ide.installed";
+    properties: {
+        ide: string;
+    };
+};
+export type Event = EventInstallationUpdated | EventLspClientDiagnostics | EventMessageUpdated | EventMessageRemoved | EventMessagePartUpdated | EventMessagePartRemoved | EventSessionCompacted | EventPermissionUpdated | EventPermissionReplied | EventFileEdited | EventFileWatcherUpdated | EventTodoUpdated | EventSessionIdle | EventSessionCreated | EventSessionUpdated | EventSessionDeleted | EventSessionError | EventServerConnected | EventIdeInstalled;
+export type ProjectListData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/project";
+};
+export type ProjectListResponses = {
+    /**
+     * List of projects
+     */
+    200: Array<Project>;
+};
+export type ProjectListResponse = ProjectListResponses[keyof ProjectListResponses];
+export type ProjectCurrentData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/project/current";
+};
+export type ProjectCurrentResponses = {
+    /**
+     * Current project
+     */
+    200: Project;
+};
+export type ProjectCurrentResponse = ProjectCurrentResponses[keyof ProjectCurrentResponses];
+export type FdsDependenciesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/fds/dependencies";
+};
+export type FdsDependenciesResponses = {
+    /**
+     * Dependency check result
+     */
+    200: {
+        available: boolean;
+        message: string;
+    };
+};
+export type FdsDependenciesResponse = FdsDependenciesResponses[keyof FdsDependenciesResponses];
+export type FdsPaperLoadData = {
+    body?: {
+        /**
+         * File path or URL to the paper
+         */
+        source: string;
+    };
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/fds/paper/load";
+};
+export type FdsPaperLoadResponses = {
+    /**
+     * Paper loaded successfully
+     */
+    200: {
+        success: boolean;
+        paperId?: string;
+        metadata?: {
+            title: string;
+            authors: Array<string>;
+            year: string;
+            abstract: string;
+            source: string;
+            pages: number;
+            arxivId?: string;
+        };
+        preview?: string;
+        error?: string;
+    };
+};
+export type FdsPaperLoadResponse = FdsPaperLoadResponses[keyof FdsPaperLoadResponses];
+export type FdsPaperCurrentContextData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/fds/paper/current/context";
+};
+export type FdsPaperCurrentContextErrors = {
+    /**
+     * No paper loaded
+     */
+    404: unknown;
+};
+export type FdsPaperCurrentContextResponses = {
+    /**
+     * Paper context for LLM
+     */
+    200: {
+        context: string;
+        paperId: string;
+        phase: "setup" | "data" | "preprocess" | "model" | "signal" | "backtest" | "validate" | "report";
+        completedPhases: Array<"setup" | "data" | "preprocess" | "model" | "signal" | "backtest" | "validate" | "report">;
+    };
+};
+export type FdsPaperCurrentContextResponse = FdsPaperCurrentContextResponses[keyof FdsPaperCurrentContextResponses];
+export type FdsPaperContextData = {
+    body?: never;
+    path: {
+        /**
+         * Paper ID
+         */
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/fds/paper/{id}/context";
+};
+export type FdsPaperContextErrors = {
+    /**
+     * Paper not found
+     */
+    404: unknown;
+};
+export type FdsPaperContextResponses = {
+    /**
+     * Paper context for LLM
+     */
+    200: {
+        context: string;
+        paperId: string;
+        phase: "setup" | "data" | "preprocess" | "model" | "signal" | "backtest" | "validate" | "report";
+        completedPhases: Array<"setup" | "data" | "preprocess" | "model" | "signal" | "backtest" | "validate" | "report">;
+    };
+};
+export type FdsPaperContextResponse = FdsPaperContextResponses[keyof FdsPaperContextResponses];
+export type FdsPaperDeleteData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/fds/paper/{id}";
+};
+export type FdsPaperDeleteResponses = {
+    /**
+     * Paper deleted
+     */
+    200: {
+        success: boolean;
+    };
+};
+export type FdsPaperDeleteResponse = FdsPaperDeleteResponses[keyof FdsPaperDeleteResponses];
+export type FdsPaperGetData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/fds/paper/{id}";
+};
+export type FdsPaperGetErrors = {
+    /**
+     * Paper not found
+     */
+    404: unknown;
+};
+export type FdsPaperGetResponses = {
+    /**
+     * Paper details
+     */
+    200: {
+        id: string;
+        metadata: {
+            title: string;
+            authors: Array<string>;
+            year: string;
+            abstract: string;
+            source: string;
+            pages: number;
+            arxivId?: string;
+        };
+        fdsSpec: {
+            paper?: {
+                title: string;
+                arxivId?: string;
+                source: string;
+            };
+            classification?: {
+                paperType?: "forecasting" | "trading_strategy" | "hybrid";
+                modelOutputType?: "forecast" | "signal" | "position_weight";
+                optimizationLevel?: "pointwise" | "portfolio";
+            };
+            dataRequirements?: {
+                source?: string;
+                dateRange?: {
+                    start: string;
+                    end: string;
+                };
+                assets?: string;
+                features?: Array<string>;
+                universeFilters?: {
+                    [key: string]: unknown;
+                };
+            };
+            preprocessing?: {
+                standardization?: string;
+                outlierHandling?: string;
+                lookbackWindow?: number;
+                missingData?: string;
+            };
+            modelArchitecture?: {
+                type?: string;
+                layers?: Array<string>;
+                lossFunction?: string;
+                hyperparameters?: {
+                    [key: string]: unknown;
+                };
+            };
+            signalGeneration?: {
+                method?: string;
+                threshold?: string;
+                tradingRules?: {
+                    [key: string]: unknown;
+                };
+            };
+            instrumentMechanics?: {
+                type?: "futures" | "equity" | "fx" | "crypto" | "options";
+                rollRules?: {
+                    method?: string;
+                    rollWindow?: number;
+                };
+                contractMultiplier?: number;
+                currency?: string;
+            };
+            positionMapping?: {
+                type?: "linear" | "sign" | "nonlinear";
+                leverageBounds?: [number, number];
+            };
+            portfolioConstruction?: {
+                crossAssetWeighting?: "equal" | "inverse_vol" | "risk_parity";
+                rebalanceFrequency?: "daily" | "weekly" | "monthly";
+                grossExposureTarget?: number;
+            };
+            reestimationPolicy?: {
+                type?: "fixed" | "expanding" | "rolling";
+                retrainFrequency?: string;
+                initialTrainWindow?: string;
+            };
+            transactionCosts?: {
+                commissionBps?: number;
+                slippageBps?: number;
+                marketImpactModel?: string;
+            };
+            backtestConfig?: {
+                methodology?: string;
+                metrics?: Array<string>;
+                trainTestSplit?: string;
+                bootstrapMethod?: string;
+                nSamples?: number;
+            };
+        } | null;
+        currentPhase: "setup" | "data" | "preprocess" | "model" | "signal" | "backtest" | "validate" | "report";
+        fullMarkdown: string;
+        implementationStatus: {
+            completedPhases: Array<"setup" | "data" | "preprocess" | "model" | "signal" | "backtest" | "validate" | "report">;
+            currentPhaseStatus: string;
+        };
+        classification?: {
+            paperType: "forecasting" | "trading_strategy" | "hybrid";
+            confidence: "high" | "medium" | "low";
+            recommendedGuide: "nixtla" | "trading" | "both";
+            reasoning: string;
+        };
+    };
+};
+export type FdsPaperGetResponse = FdsPaperGetResponses[keyof FdsPaperGetResponses];
+export type FdsPaperListData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/fds/paper";
+};
+export type FdsPaperListResponses = {
+    /**
+     * List of papers
+     */
+    200: Array<{
+        id: string;
+        title: string;
+        pages: number;
+        source: string;
+        arxivId?: string;
+        currentPhase: "setup" | "data" | "preprocess" | "model" | "signal" | "backtest" | "validate" | "report";
+    }>;
+};
+export type FdsPaperListResponse = FdsPaperListResponses[keyof FdsPaperListResponses];
+export type FdsPaperPhaseData = {
+    body?: {
+        phase: "setup" | "data" | "preprocess" | "model" | "signal" | "backtest" | "validate" | "report";
+    };
+    path: {
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/fds/paper/{id}/phase";
+};
+export type FdsPaperPhaseResponses = {
+    /**
+     * Phase updated
+     */
+    200: {
+        success: boolean;
+    };
+};
+export type FdsPaperPhaseResponse = FdsPaperPhaseResponses[keyof FdsPaperPhaseResponses];
+export type FdsPaperSpecSetData = {
+    body?: {
+        paper?: {
+            title: string;
+            arxivId?: string;
+            source: string;
+        };
+        classification?: {
+            paperType?: "forecasting" | "trading_strategy" | "hybrid";
+            modelOutputType?: "forecast" | "signal" | "position_weight";
+            optimizationLevel?: "pointwise" | "portfolio";
+        };
+        dataRequirements?: {
+            source?: string;
+            dateRange?: {
+                start: string;
+                end: string;
+            };
+            assets?: string;
+            features?: Array<string>;
+            universeFilters?: {
+                [key: string]: unknown;
+            };
+        };
+        preprocessing?: {
+            standardization?: string;
+            outlierHandling?: string;
+            lookbackWindow?: number;
+            missingData?: string;
+        };
+        modelArchitecture?: {
+            type?: string;
+            layers?: Array<string>;
+            lossFunction?: string;
+            hyperparameters?: {
+                [key: string]: unknown;
+            };
+        };
+        signalGeneration?: {
+            method?: string;
+            threshold?: string;
+            tradingRules?: {
+                [key: string]: unknown;
+            };
+        };
+        instrumentMechanics?: {
+            type?: "futures" | "equity" | "fx" | "crypto" | "options";
+            rollRules?: {
+                method?: string;
+                rollWindow?: number;
+            };
+            contractMultiplier?: number;
+            currency?: string;
+        };
+        positionMapping?: {
+            type?: "linear" | "sign" | "nonlinear";
+            leverageBounds?: [number, number];
+        };
+        portfolioConstruction?: {
+            crossAssetWeighting?: "equal" | "inverse_vol" | "risk_parity";
+            rebalanceFrequency?: "daily" | "weekly" | "monthly";
+            grossExposureTarget?: number;
+        };
+        reestimationPolicy?: {
+            type?: "fixed" | "expanding" | "rolling";
+            retrainFrequency?: string;
+            initialTrainWindow?: string;
+        };
+        transactionCosts?: {
+            commissionBps?: number;
+            slippageBps?: number;
+            marketImpactModel?: string;
+        };
+        backtestConfig?: {
+            methodology?: string;
+            metrics?: Array<string>;
+            trainTestSplit?: string;
+            bootstrapMethod?: string;
+            nSamples?: number;
+        };
+    };
+    path: {
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/fds/paper/{id}/spec";
+};
+export type FdsPaperSpecSetResponses = {
+    /**
+     * Spec set
+     */
+    200: {
+        success: boolean;
+    };
+};
+export type FdsPaperSpecSetResponse = FdsPaperSpecSetResponses[keyof FdsPaperSpecSetResponses];
+export type ConfigGetData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/config";
+};
+export type ConfigGetResponses = {
+    /**
+     * Get config info
+     */
+    200: Config;
+};
+export type ConfigGetResponse = ConfigGetResponses[keyof ConfigGetResponses];
+export type ConfigUpdateData = {
+    body?: Config;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/config";
+};
+export type ConfigUpdateErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+};
+export type ConfigUpdateError = ConfigUpdateErrors[keyof ConfigUpdateErrors];
+export type ConfigUpdateResponses = {
+    /**
+     * Successfully updated config
+     */
+    200: Config;
+};
+export type ConfigUpdateResponse = ConfigUpdateResponses[keyof ConfigUpdateResponses];
+export type ToolIdsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/experimental/tool/ids";
+};
+export type ToolIdsErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+};
+export type ToolIdsError = ToolIdsErrors[keyof ToolIdsErrors];
+export type ToolIdsResponses = {
+    /**
+     * Tool IDs
+     */
+    200: ToolIds;
+};
+export type ToolIdsResponse = ToolIdsResponses[keyof ToolIdsResponses];
+export type ToolListData = {
+    body?: never;
+    path?: never;
+    query: {
+        directory?: string;
+        provider: string;
+        model: string;
+    };
+    url: "/experimental/tool";
+};
+export type ToolListErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+};
+export type ToolListError = ToolListErrors[keyof ToolListErrors];
+export type ToolListResponses = {
+    /**
+     * Tools
+     */
+    200: ToolList;
+};
+export type ToolListResponse = ToolListResponses[keyof ToolListResponses];
+export type PathGetData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/path";
+};
+export type PathGetResponses = {
+    /**
+     * Path
+     */
+    200: Path;
+};
+export type PathGetResponse = PathGetResponses[keyof PathGetResponses];
+export type SessionListData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/session";
+};
+export type SessionListResponses = {
+    /**
+     * List of sessions
+     */
+    200: Array<Session>;
+};
+export type SessionListResponse = SessionListResponses[keyof SessionListResponses];
+export type SessionCreateData = {
+    body?: {
+        parentID?: string;
+        title?: string;
+    };
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/session";
+};
+export type SessionCreateErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+};
+export type SessionCreateError = SessionCreateErrors[keyof SessionCreateErrors];
+export type SessionCreateResponses = {
+    /**
+     * Successfully created session
+     */
+    200: Session;
+};
+export type SessionCreateResponse = SessionCreateResponses[keyof SessionCreateResponses];
+export type SessionDeleteData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}";
+};
+export type SessionDeleteErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionDeleteError = SessionDeleteErrors[keyof SessionDeleteErrors];
+export type SessionDeleteResponses = {
+    /**
+     * Successfully deleted session
+     */
+    200: boolean;
+};
+export type SessionDeleteResponse = SessionDeleteResponses[keyof SessionDeleteResponses];
+export type SessionGetData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}";
+};
+export type SessionGetErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionGetError = SessionGetErrors[keyof SessionGetErrors];
+export type SessionGetResponses = {
+    /**
+     * Get session
+     */
+    200: Session;
+};
+export type SessionGetResponse = SessionGetResponses[keyof SessionGetResponses];
+export type SessionUpdateData = {
+    body?: {
+        title?: string;
+    };
+    path: {
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}";
+};
+export type SessionUpdateErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionUpdateError = SessionUpdateErrors[keyof SessionUpdateErrors];
+export type SessionUpdateResponses = {
+    /**
+     * Successfully updated session
+     */
+    200: Session;
+};
+export type SessionUpdateResponse = SessionUpdateResponses[keyof SessionUpdateResponses];
+export type SessionChildrenData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}/children";
+};
+export type SessionChildrenErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionChildrenError = SessionChildrenErrors[keyof SessionChildrenErrors];
+export type SessionChildrenResponses = {
+    /**
+     * List of children
+     */
+    200: Array<Session>;
+};
+export type SessionChildrenResponse = SessionChildrenResponses[keyof SessionChildrenResponses];
+export type SessionTodoData = {
+    body?: never;
+    path: {
+        /**
+         * Session ID
+         */
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}/todo";
+};
+export type SessionTodoErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionTodoError = SessionTodoErrors[keyof SessionTodoErrors];
+export type SessionTodoResponses = {
+    /**
+     * Todo list
+     */
+    200: Array<Todo>;
+};
+export type SessionTodoResponse = SessionTodoResponses[keyof SessionTodoResponses];
+export type SessionInitData = {
+    body?: {
+        modelID: string;
+        providerID: string;
+        messageID: string;
+    };
+    path: {
+        /**
+         * Session ID
+         */
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}/init";
+};
+export type SessionInitErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionInitError = SessionInitErrors[keyof SessionInitErrors];
+export type SessionInitResponses = {
+    /**
+     * 200
+     */
+    200: boolean;
+};
+export type SessionInitResponse = SessionInitResponses[keyof SessionInitResponses];
+export type SessionForkData = {
+    body?: {
+        messageID?: string;
+    };
+    path: {
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}/fork";
+};
+export type SessionForkResponses = {
+    /**
+     * 200
+     */
+    200: Session;
+};
+export type SessionForkResponse = SessionForkResponses[keyof SessionForkResponses];
+export type SessionAbortData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}/abort";
+};
+export type SessionAbortErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionAbortError = SessionAbortErrors[keyof SessionAbortErrors];
+export type SessionAbortResponses = {
+    /**
+     * Aborted session
+     */
+    200: boolean;
+};
+export type SessionAbortResponse = SessionAbortResponses[keyof SessionAbortResponses];
+export type SessionTogglePermissionData = {
+    body?: {
+        enabled: boolean;
+    };
+    path: {
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}/permission";
+};
+export type SessionTogglePermissionErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionTogglePermissionError = SessionTogglePermissionErrors[keyof SessionTogglePermissionErrors];
+export type SessionTogglePermissionResponses = {
+    /**
+     * Permission mode updated successfully
+     */
+    200: {
+        enabled: boolean;
+    };
+};
+export type SessionTogglePermissionResponse = SessionTogglePermissionResponses[keyof SessionTogglePermissionResponses];
+export type SessionUnshareData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}/share";
+};
+export type SessionUnshareErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionUnshareError = SessionUnshareErrors[keyof SessionUnshareErrors];
+export type SessionUnshareResponses = {
+    /**
+     * Successfully unshared session
+     */
+    200: Session;
+};
+export type SessionUnshareResponse = SessionUnshareResponses[keyof SessionUnshareResponses];
+export type SessionShareData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}/share";
+};
+export type SessionShareErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionShareError = SessionShareErrors[keyof SessionShareErrors];
+export type SessionShareResponses = {
+    /**
+     * Successfully shared session
+     */
+    200: Session;
+};
+export type SessionShareResponse = SessionShareResponses[keyof SessionShareResponses];
+export type SessionDiffData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: {
+        directory?: string;
+        messageID?: string;
+    };
+    url: "/session/{id}/diff";
+};
+export type SessionDiffResponses = {
+    /**
+     * Successfully retrieved diff
+     */
+    200: Array<FileDiff>;
+};
+export type SessionDiffResponse = SessionDiffResponses[keyof SessionDiffResponses];
+export type SessionSummarizeData = {
+    body?: {
+        providerID: string;
+        modelID: string;
+    };
+    path: {
+        /**
+         * Session ID
+         */
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}/summarize";
+};
+export type SessionSummarizeErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionSummarizeError = SessionSummarizeErrors[keyof SessionSummarizeErrors];
+export type SessionSummarizeResponses = {
+    /**
+     * Summarized session
+     */
+    200: boolean;
+};
+export type SessionSummarizeResponse = SessionSummarizeResponses[keyof SessionSummarizeResponses];
+export type SessionMessagesData = {
+    body?: never;
+    path: {
+        /**
+         * Session ID
+         */
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}/message";
+};
+export type SessionMessagesErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionMessagesError = SessionMessagesErrors[keyof SessionMessagesErrors];
+export type SessionMessagesResponses = {
+    /**
+     * List of messages
+     */
+    200: Array<{
+        info: Message;
+        parts: Array<Part>;
+    }>;
+};
+export type SessionMessagesResponse = SessionMessagesResponses[keyof SessionMessagesResponses];
+export type SessionPromptData = {
+    body?: {
+        messageID?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+        agent?: string;
+        noReply?: boolean;
+        system?: string;
+        tools?: {
+            [key: string]: boolean;
+        };
+        parts: Array<TextPartInput | FilePartInput | AgentPartInput>;
+    };
+    path: {
+        /**
+         * Session ID
+         */
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}/message";
+};
+export type SessionPromptErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionPromptError = SessionPromptErrors[keyof SessionPromptErrors];
+export type SessionPromptResponses = {
+    /**
+     * Created message
+     */
+    200: {
+        info: AssistantMessage;
+        parts: Array<Part>;
+    };
+};
+export type SessionPromptResponse = SessionPromptResponses[keyof SessionPromptResponses];
+export type SessionMessageData = {
+    body?: never;
+    path: {
+        /**
+         * Session ID
+         */
+        id: string;
+        /**
+         * Message ID
+         */
+        messageID: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}/message/{messageID}";
+};
+export type SessionMessageErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionMessageError = SessionMessageErrors[keyof SessionMessageErrors];
+export type SessionMessageResponses = {
+    /**
+     * Message
+     */
+    200: {
+        info: Message;
+        parts: Array<Part>;
+    };
+};
+export type SessionMessageResponse = SessionMessageResponses[keyof SessionMessageResponses];
+export type SessionCommandData = {
+    body?: {
+        messageID?: string;
+        agent?: string;
+        model?: string;
+        arguments: string;
+        command: string;
+    };
+    path: {
+        /**
+         * Session ID
+         */
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}/command";
+};
+export type SessionCommandErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionCommandError = SessionCommandErrors[keyof SessionCommandErrors];
+export type SessionCommandResponses = {
+    /**
+     * Created message
+     */
+    200: {
+        info: AssistantMessage;
+        parts: Array<Part>;
+    };
+};
+export type SessionCommandResponse = SessionCommandResponses[keyof SessionCommandResponses];
+export type SessionShellData = {
+    body?: {
+        agent: string;
+        command: string;
+    };
+    path: {
+        /**
+         * Session ID
+         */
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}/shell";
+};
+export type SessionShellErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionShellError = SessionShellErrors[keyof SessionShellErrors];
+export type SessionShellResponses = {
+    /**
+     * Created message
+     */
+    200: AssistantMessage;
+};
+export type SessionShellResponse = SessionShellResponses[keyof SessionShellResponses];
+export type SessionRevertData = {
+    body?: {
+        messageID: string;
+        partID?: string;
+    };
+    path: {
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}/revert";
+};
+export type SessionRevertErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionRevertError = SessionRevertErrors[keyof SessionRevertErrors];
+export type SessionRevertResponses = {
+    /**
+     * Updated session
+     */
+    200: Session;
+};
+export type SessionRevertResponse = SessionRevertResponses[keyof SessionRevertResponses];
+export type SessionUnrevertData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}/unrevert";
+};
+export type SessionUnrevertErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type SessionUnrevertError = SessionUnrevertErrors[keyof SessionUnrevertErrors];
+export type SessionUnrevertResponses = {
+    /**
+     * Updated session
+     */
+    200: Session;
+};
+export type SessionUnrevertResponse = SessionUnrevertResponses[keyof SessionUnrevertResponses];
+export type PostSessionIdPermissionsPermissionIdData = {
+    body?: {
+        response: "once" | "always" | "reject";
+    };
+    path: {
+        id: string;
+        permissionID: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/session/{id}/permissions/{permissionID}";
+};
+export type PostSessionIdPermissionsPermissionIdErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type PostSessionIdPermissionsPermissionIdError = PostSessionIdPermissionsPermissionIdErrors[keyof PostSessionIdPermissionsPermissionIdErrors];
+export type PostSessionIdPermissionsPermissionIdResponses = {
+    /**
+     * Permission processed successfully
+     */
+    200: boolean;
+};
+export type PostSessionIdPermissionsPermissionIdResponse = PostSessionIdPermissionsPermissionIdResponses[keyof PostSessionIdPermissionsPermissionIdResponses];
+export type CommandListData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/command";
+};
+export type CommandListResponses = {
+    /**
+     * List of commands
+     */
+    200: Array<Command>;
+};
+export type CommandListResponse = CommandListResponses[keyof CommandListResponses];
+export type ConfigProvidersData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/config/providers";
+};
+export type ConfigProvidersResponses = {
+    /**
+     * List of providers
+     */
+    200: {
+        providers: Array<Provider>;
+        default: {
+            [key: string]: string;
+        };
+    };
+};
+export type ConfigProvidersResponse = ConfigProvidersResponses[keyof ConfigProvidersResponses];
+export type FindTextData = {
+    body?: never;
+    path?: never;
+    query: {
+        directory?: string;
+        pattern: string;
+    };
+    url: "/find";
+};
+export type FindTextResponses = {
+    /**
+     * Matches
+     */
+    200: Array<{
+        path: {
+            text: string;
+        };
+        lines: {
+            text: string;
+        };
+        line_number: number;
+        absolute_offset: number;
+        submatches: Array<{
+            match: {
+                text: string;
+            };
+            start: number;
+            end: number;
+        }>;
+    }>;
+};
+export type FindTextResponse = FindTextResponses[keyof FindTextResponses];
+export type FindFilesData = {
+    body?: never;
+    path?: never;
+    query: {
+        directory?: string;
+        query: string;
+    };
+    url: "/find/file";
+};
+export type FindFilesResponses = {
+    /**
+     * File paths
+     */
+    200: Array<string>;
+};
+export type FindFilesResponse = FindFilesResponses[keyof FindFilesResponses];
+export type FindSymbolsData = {
+    body?: never;
+    path?: never;
+    query: {
+        directory?: string;
+        query: string;
+    };
+    url: "/find/symbol";
+};
+export type FindSymbolsResponses = {
+    /**
+     * Symbols
+     */
+    200: Array<Symbol>;
+};
+export type FindSymbolsResponse = FindSymbolsResponses[keyof FindSymbolsResponses];
+export type FileListData = {
+    body?: never;
+    path?: never;
+    query: {
+        directory?: string;
+        path: string;
+    };
+    url: "/file";
+};
+export type FileListResponses = {
+    /**
+     * Files and directories
+     */
+    200: Array<FileNode>;
+};
+export type FileListResponse = FileListResponses[keyof FileListResponses];
+export type FileReadData = {
+    body?: never;
+    path?: never;
+    query: {
+        directory?: string;
+        path: string;
+    };
+    url: "/file/content";
+};
+export type FileReadResponses = {
+    /**
+     * File content
+     */
+    200: FileContent;
+};
+export type FileReadResponse = FileReadResponses[keyof FileReadResponses];
+export type FileStatusData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/file/status";
+};
+export type FileStatusResponses = {
+    /**
+     * File status
+     */
+    200: Array<File>;
+};
+export type FileStatusResponse = FileStatusResponses[keyof FileStatusResponses];
+export type AppLogData = {
+    body?: {
+        /**
+         * Service name for the log entry
+         */
+        service: string;
+        /**
+         * Log level
+         */
+        level: "debug" | "info" | "error" | "warn";
+        /**
+         * Log message
+         */
+        message: string;
+        /**
+         * Additional metadata for the log entry
+         */
+        extra?: {
+            [key: string]: unknown;
+        };
+    };
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/log";
+};
+export type AppLogErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+};
+export type AppLogError = AppLogErrors[keyof AppLogErrors];
+export type AppLogResponses = {
+    /**
+     * Log entry written successfully
+     */
+    200: boolean;
+};
+export type AppLogResponse = AppLogResponses[keyof AppLogResponses];
+export type AppAgentsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/agent";
+};
+export type AppAgentsResponses = {
+    /**
+     * List of agents
+     */
+    200: Array<Agent>;
+};
+export type AppAgentsResponse = AppAgentsResponses[keyof AppAgentsResponses];
+export type AgentUpdatePermissionData = {
+    body?: {
+        edit?: "ask" | "allow" | "deny";
+        bash?: {
+            [key: string]: "ask" | "allow" | "deny";
+        };
+        webfetch?: "ask" | "allow" | "deny";
+    };
+    path: {
+        name: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/agent/{name}/permission";
+};
+export type AgentUpdatePermissionErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+    /**
+     * Not found
+     */
+    404: NotFoundError;
+};
+export type AgentUpdatePermissionError = AgentUpdatePermissionErrors[keyof AgentUpdatePermissionErrors];
+export type AgentUpdatePermissionResponses = {
+    /**
+     * Permission updated successfully
+     */
+    200: Agent;
+};
+export type AgentUpdatePermissionResponse = AgentUpdatePermissionResponses[keyof AgentUpdatePermissionResponses];
+export type McpStatusData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/mcp";
+};
+export type McpStatusResponses = {
+    /**
+     * MCP server status
+     */
+    200: unknown;
+};
+export type McpRefreshData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/mcp/refresh";
+};
+export type McpRefreshResponses = {
+    /**
+     * MCP servers refreshed
+     */
+    200: unknown;
+};
+export type McpEnableData = {
+    body?: never;
+    path: {
+        name: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/mcp/{name}/enable";
+};
+export type McpEnableResponses = {
+    /**
+     * MCP server enabled
+     */
+    200: unknown;
+};
+export type McpDisableData = {
+    body?: never;
+    path: {
+        name: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/mcp/{name}/disable";
+};
+export type McpDisableResponses = {
+    /**
+     * MCP server disabled
+     */
+    200: unknown;
+};
+export type TuiAppendPromptData = {
+    body?: {
+        text: string;
+    };
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/tui/append-prompt";
+};
+export type TuiAppendPromptErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+};
+export type TuiAppendPromptError = TuiAppendPromptErrors[keyof TuiAppendPromptErrors];
+export type TuiAppendPromptResponses = {
+    /**
+     * Prompt processed successfully
+     */
+    200: boolean;
+};
+export type TuiAppendPromptResponse = TuiAppendPromptResponses[keyof TuiAppendPromptResponses];
+export type TuiOpenHelpData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/tui/open-help";
+};
+export type TuiOpenHelpResponses = {
+    /**
+     * Help dialog opened successfully
+     */
+    200: boolean;
+};
+export type TuiOpenHelpResponse = TuiOpenHelpResponses[keyof TuiOpenHelpResponses];
+export type TuiOpenSessionsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/tui/open-sessions";
+};
+export type TuiOpenSessionsResponses = {
+    /**
+     * Session dialog opened successfully
+     */
+    200: boolean;
+};
+export type TuiOpenSessionsResponse = TuiOpenSessionsResponses[keyof TuiOpenSessionsResponses];
+export type TuiOpenThemesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/tui/open-themes";
+};
+export type TuiOpenThemesResponses = {
+    /**
+     * Theme dialog opened successfully
+     */
+    200: boolean;
+};
+export type TuiOpenThemesResponse = TuiOpenThemesResponses[keyof TuiOpenThemesResponses];
+export type TuiOpenModelsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/tui/open-models";
+};
+export type TuiOpenModelsResponses = {
+    /**
+     * Model dialog opened successfully
+     */
+    200: boolean;
+};
+export type TuiOpenModelsResponse = TuiOpenModelsResponses[keyof TuiOpenModelsResponses];
+export type TuiSubmitPromptData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/tui/submit-prompt";
+};
+export type TuiSubmitPromptResponses = {
+    /**
+     * Prompt submitted successfully
+     */
+    200: boolean;
+};
+export type TuiSubmitPromptResponse = TuiSubmitPromptResponses[keyof TuiSubmitPromptResponses];
+export type TuiClearPromptData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/tui/clear-prompt";
+};
+export type TuiClearPromptResponses = {
+    /**
+     * Prompt cleared successfully
+     */
+    200: boolean;
+};
+export type TuiClearPromptResponse = TuiClearPromptResponses[keyof TuiClearPromptResponses];
+export type TuiExecuteCommandData = {
+    body?: {
+        command: string;
+    };
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/tui/execute-command";
+};
+export type TuiExecuteCommandErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+};
+export type TuiExecuteCommandError = TuiExecuteCommandErrors[keyof TuiExecuteCommandErrors];
+export type TuiExecuteCommandResponses = {
+    /**
+     * Command executed successfully
+     */
+    200: boolean;
+};
+export type TuiExecuteCommandResponse = TuiExecuteCommandResponses[keyof TuiExecuteCommandResponses];
+export type TuiShowToastData = {
+    body?: {
+        title?: string;
+        message: string;
+        variant: "info" | "success" | "warning" | "error";
+    };
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/tui/show-toast";
+};
+export type TuiShowToastResponses = {
+    /**
+     * Toast notification shown successfully
+     */
+    200: boolean;
+};
+export type TuiShowToastResponse = TuiShowToastResponses[keyof TuiShowToastResponses];
+export type AuthSetData = {
+    body?: Auth;
+    path: {
+        id: string;
+    };
+    query?: {
+        directory?: string;
+    };
+    url: "/auth/{id}";
+};
+export type AuthSetErrors = {
+    /**
+     * Bad request
+     */
+    400: BadRequestError;
+};
+export type AuthSetError = AuthSetErrors[keyof AuthSetErrors];
+export type AuthSetResponses = {
+    /**
+     * Successfully set authentication credentials
+     */
+    200: boolean;
+};
+export type AuthSetResponse = AuthSetResponses[keyof AuthSetResponses];
+export type EventSubscribeData = {
+    body?: never;
+    path?: never;
+    query?: {
+        directory?: string;
+    };
+    url: "/event";
+};
+export type EventSubscribeResponses = {
+    /**
+     * Event stream
+     */
+    200: Event;
+};
+export type EventSubscribeResponse = EventSubscribeResponses[keyof EventSubscribeResponses];
+export type ClientOptions = {
+    baseUrl: `${string}://${string}` | (string & {});
+};