@dexto/client-sdk 1.2.4 → 1.2.6

package/dist/client.d.ts

@@ -0,0 +1,3022 @@
+import type { ClientConfig } from './types.js';
+/**
+ * Create a type-safe Dexto client using Hono's typed client
+ *
+ * @example
+ * ```typescript
+ * import { createDextoClient } from '@dexto/client-sdk';
+ *
+ * const client = createDextoClient({
+ *   baseUrl: 'http://localhost:3001',
+ *   apiKey: 'optional-api-key'
+ * });
+ *
+ * // Create a session
+ * const session = await client.api.sessions.$post({
+ *   json: { sessionId: 'my-session' }
+ * });
+ *
+ * // Send a synchronous message
+ * const response = await client.api['message-sync'].$post({
+ *   json: { message: 'Hello!', sessionId: 'my-session' }
+ * });
+ * const { response: text } = await response.json();
+ *
+ * // Search messages
+ * const searchResults = await client.api.search.messages.$get({
+ *   query: { q: 'hello', limit: 10 }
+ * });
+ *
+ * // Streaming responses with SSE
+ * import { createMessageStream } from '@dexto/client-sdk';
+ *
+ * const streamPromise = client.api['message-stream'].$post({
+ *   json: { message: 'Tell me a story', sessionId: 'my-session' }
+ * });
+ *
+ * // Parse SSE events using createMessageStream
+ * const stream = createMessageStream(streamPromise);
+ * for await (const event of stream) {
+ *   if (event.type === 'llm:chunk') {
+ *     process.stdout.write(event.content);
+ *   }
+ * }
+ * ```
+ */
+export declare function createDextoClient(config: ClientConfig): {
+    health: import("hono/client").ClientRequest<{
+        $get: {
+            input: {};
+            output: string;
+            outputFormat: "text";
+            status: 200;
+        };
+    }>;
+} & {
+    api: {
+        agents: import("hono/client").ClientRequest<{
+            $get: {
+                input: {};
+                output: {
+                    installed: {
+                        description: string;
+                        type: "custom" | "builtin";
+                        id: string;
+                        name: string;
+                        tags?: string[] | undefined;
+                        author?: string | undefined;
+                    }[];
+                    available: {
+                        description: string;
+                        type: "custom" | "builtin";
+                        id: string;
+                        name: string;
+                        tags?: string[] | undefined;
+                        author?: string | undefined;
+                    }[];
+                    current: {
+                        id: string | null;
+                        name: string | null;
+                    };
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        }>;
+    };
+} & {
+    api: {
+        agents: {
+            current: import("hono/client").ClientRequest<{
+                $get: {
+                    input: {};
+                    output: {
+                        id: string | null;
+                        name: string | null;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        agents: {
+            install: import("hono/client").ClientRequest<{
+                $post: {
+                    input: {
+                        json: {
+                            id: string;
+                            path?: string | undefined;
+                        } | {
+                            id: string;
+                            metadata: {
+                                tags: string[];
+                                description: string;
+                                author: string;
+                                main?: string | undefined;
+                            };
+                            sourcePath: string;
+                            name?: string | undefined;
+                            injectPreferences?: boolean | undefined;
+                        };
+                    };
+                    output: {
+                        type: "custom" | "builtin";
+                        id: string;
+                        name: string;
+                        installed: true;
+                    };
+                    outputFormat: "json";
+                    status: 201;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        agents: {
+            switch: import("hono/client").ClientRequest<{
+                $post: {
+                    input: {
+                        json: {
+                            id: string;
+                            path?: string | undefined;
+                        };
+                    };
+                    output: {
+                        id: string;
+                        name: string;
+                        switched: true;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        agents: {
+            "validate-name": import("hono/client").ClientRequest<{
+                $post: {
+                    input: {
+                        json: {
+                            id: string;
+                            path?: string | undefined;
+                        };
+                    };
+                    output: {
+                        valid: boolean;
+                        message?: string | undefined;
+                        conflict?: string | undefined;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        agents: {
+            uninstall: import("hono/client").ClientRequest<{
+                $post: {
+                    input: {
+                        json: {
+                            id: string;
+                            force?: boolean | undefined;
+                        };
+                    };
+                    output: {
+                        id: string;
+                        uninstalled: true;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        agents: {
+            custom: {
+                create: import("hono/client").ClientRequest<{
+                    $post: {
+                        input: {
+                            json: {
+                                description: string;
+                                config: {
+                                    llm: {
+                                        apiKey: string;
+                                        model: string;
+                                        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+                                        router?: "vercel" | "in-built" | undefined;
+                                        maxIterations?: number | undefined;
+                                        baseURL?: string | undefined;
+                                        maxInputTokens?: number | undefined;
+                                        maxOutputTokens?: number | undefined;
+                                        temperature?: number | undefined;
+                                        allowedMediaTypes?: string[] | undefined;
+                                    };
+                                    systemPrompt: string | {
+                                        contributors?: ({
+                                            type: "static";
+                                            content: string;
+                                            id: string;
+                                            priority: number;
+                                            enabled?: boolean | undefined;
+                                        } | {
+                                            type: "dynamic";
+                                            id: string;
+                                            source: "resources" | "dateTime";
+                                            priority: number;
+                                            enabled?: boolean | undefined;
+                                        } | {
+                                            type: "file";
+                                            id: string;
+                                            priority: number;
+                                            files: string[];
+                                            options?: {
+                                                includeFilenames?: boolean | undefined;
+                                                separator?: string | undefined;
+                                                errorHandling?: "error" | "skip" | undefined;
+                                                maxFileSize?: number | undefined;
+                                                includeMetadata?: boolean | undefined;
+                                            } | undefined;
+                                            enabled?: boolean | undefined;
+                                        })[] | undefined;
+                                    };
+                                    storage?: {
+                                        database: {
+                                            type: "in-memory";
+                                            options?: Record<string, any> | undefined;
+                                            maxConnections?: number | undefined;
+                                            idleTimeoutMillis?: number | undefined;
+                                            connectionTimeoutMillis?: number | undefined;
+                                        } | {
+                                            path: string;
+                                            type: "sqlite";
+                                            options?: Record<string, any> | undefined;
+                                            maxConnections?: number | undefined;
+                                            idleTimeoutMillis?: number | undefined;
+                                            connectionTimeoutMillis?: number | undefined;
+                                        } | {
+                                            type: "postgres";
+                                            password?: string | undefined;
+                                            options?: Record<string, any> | undefined;
+                                            url?: string | undefined;
+                                            maxConnections?: number | undefined;
+                                            idleTimeoutMillis?: number | undefined;
+                                            connectionTimeoutMillis?: number | undefined;
+                                            host?: string | undefined;
+                                            port?: number | undefined;
+                                            database?: string | undefined;
+                                            connectionString?: string | undefined;
+                                        };
+                                        cache: {
+                                            type: "in-memory";
+                                            options?: Record<string, any> | undefined;
+                                            maxConnections?: number | undefined;
+                                            idleTimeoutMillis?: number | undefined;
+                                            connectionTimeoutMillis?: number | undefined;
+                                        } | {
+                                            type: "redis";
+                                            password?: string | undefined;
+                                            options?: Record<string, any> | undefined;
+                                            url?: string | undefined;
+                                            maxConnections?: number | undefined;
+                                            idleTimeoutMillis?: number | undefined;
+                                            connectionTimeoutMillis?: number | undefined;
+                                            host?: string | undefined;
+                                            port?: number | undefined;
+                                            database?: number | undefined;
+                                        };
+                                        blob: {
+                                            type: "in-memory";
+                                            maxBlobSize?: number | undefined;
+                                            maxTotalSize?: number | undefined;
+                                        } | {
+                                            type: "local";
+                                            storePath: string;
+                                            maxBlobSize?: number | undefined;
+                                            maxTotalSize?: number | undefined;
+                                            cleanupAfterDays?: number | undefined;
+                                        };
+                                    } | undefined;
+                                    telemetry?: {
+                                        enabled?: boolean | undefined;
+                                        serviceName?: string | undefined;
+                                        tracerName?: string | undefined;
+                                        export?: {
+                                            type: "otlp";
+                                            headers?: Record<string, string> | undefined;
+                                            protocol?: "http" | "grpc" | undefined;
+                                            endpoint?: string | undefined;
+                                        } | {
+                                            type: "console";
+                                        } | undefined;
+                                    } | undefined;
+                                    logger?: {
+                                        level?: "debug" | "info" | "warn" | "error" | "silly" | undefined;
+                                        transports?: ({
+                                            type: "console";
+                                            colorize?: boolean | undefined;
+                                        } | {
+                                            path: string;
+                                            type: "file";
+                                            maxFiles?: number | undefined;
+                                            maxSize?: number | undefined;
+                                        } | {
+                                            token: string;
+                                            type: "upstash";
+                                            url: string;
+                                            listName?: string | undefined;
+                                            maxListLength?: number | undefined;
+                                            batchSize?: number | undefined;
+                                        })[] | undefined;
+                                    } | undefined;
+                                    elicitation?: {
+                                        timeout?: number | undefined;
+                                        enabled?: boolean | undefined;
+                                    } | undefined;
+                                    prompts?: ({
+                                        prompt: string;
+                                        type: "inline";
+                                        id: string;
+                                        description?: string | undefined;
+                                        title?: string | undefined;
+                                        priority?: number | undefined;
+                                        category?: string | undefined;
+                                        showInStarters?: boolean | undefined;
+                                    } | {
+                                        file: string;
+                                        type: "file";
+                                        showInStarters?: boolean | undefined;
+                                    })[] | undefined;
+                                    agentId?: string | undefined;
+                                    agentCard?: {
+                                        description: string;
+                                        url: string;
+                                        name: string;
+                                        version: string;
+                                        metadata?: import("zod").objectInputType<{
+                                            dexto: import("zod").ZodOptional<import("zod").ZodObject<{
+                                                authentication: import("zod").ZodOptional<import("zod").ZodObject<{
+                                                    schemes: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                                                    credentials: import("zod").ZodOptional<import("zod").ZodString>;
+                                                }, "strict", import("zod").ZodTypeAny, {
+                                                    schemes: string[];
+                                                    credentials?: string | undefined;
+                                                }, {
+                                                    schemes?: string[] | undefined;
+                                                    credentials?: string | undefined;
+                                                }>>;
+                                                delegation: import("zod").ZodOptional<import("zod").ZodObject<{
+                                                    protocol: import("zod").ZodEnum<["dexto-v1", "http-simple", "a2a-jsonrpc", "mcp-http"]>;
+                                                    endpoint: import("zod").ZodString;
+                                                    supportsSession: import("zod").ZodBoolean;
+                                                    supportsStreaming: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                                                }, "strict", import("zod").ZodTypeAny, {
+                                                    protocol: "dexto-v1" | "http-simple" | "a2a-jsonrpc" | "mcp-http";
+                                                    endpoint: string;
+                                                    supportsSession: boolean;
+                                                    supportsStreaming?: boolean | undefined;
+                                                }, {
+                                                    protocol: "dexto-v1" | "http-simple" | "a2a-jsonrpc" | "mcp-http";
+                                                    endpoint: string;
+                                                    supportsSession: boolean;
+                                                    supportsStreaming?: boolean | undefined;
+                                                }>>;
+                                                owner: import("zod").ZodOptional<import("zod").ZodObject<{
+                                                    userId: import("zod").ZodString;
+                                                    username: import("zod").ZodString;
+                                                    email: import("zod").ZodOptional<import("zod").ZodString>;
+                                                }, "strict", import("zod").ZodTypeAny, {
+                                                    userId: string;
+                                                    username: string;
+                                                    email?: string | undefined;
+                                                }, {
+                                                    userId: string;
+                                                    username: string;
+                                                    email?: string | undefined;
+                                                }>>;
+                                            }, "strict", import("zod").ZodTypeAny, {
+                                                authentication?: {
+                                                    schemes: string[];
+                                                    credentials?: string | undefined;
+                                                } | undefined;
+                                                delegation?: {
+                                                    protocol: "dexto-v1" | "http-simple" | "a2a-jsonrpc" | "mcp-http";
+                                                    endpoint: string;
+                                                    supportsSession: boolean;
+                                                    supportsStreaming?: boolean | undefined;
+                                                } | undefined;
+                                                owner?: {
+                                                    userId: string;
+                                                    username: string;
+                                                    email?: string | undefined;
+                                                } | undefined;
+                                            }, {
+                                                authentication?: {
+                                                    schemes?: string[] | undefined;
+                                                    credentials?: string | undefined;
+                                                } | undefined;
+                                                delegation?: {
+                                                    protocol: "dexto-v1" | "http-simple" | "a2a-jsonrpc" | "mcp-http";
+                                                    endpoint: string;
+                                                    supportsSession: boolean;
+                                                    supportsStreaming?: boolean | undefined;
+                                                } | undefined;
+                                                owner?: {
+                                                    userId: string;
+                                                    username: string;
+                                                    email?: string | undefined;
+                                                } | undefined;
+                                            }>>;
+                                        }, import("zod").ZodTypeAny, "passthrough"> | undefined;
+                                        capabilities?: {
+                                            streaming?: boolean | undefined;
+                                            pushNotifications?: boolean | undefined;
+                                            stateTransitionHistory?: boolean | undefined;
+                                        } | undefined;
+                                        provider?: {
+                                            url: string;
+                                            organization: string;
+                                        } | undefined;
+                                        protocolVersion?: string | undefined;
+                                        preferredTransport?: "JSONRPC" | "GRPC" | "HTTP+JSON" | undefined;
+                                        defaultInputModes?: string[] | undefined;
+                                        defaultOutputModes?: string[] | undefined;
+                                        skills?: {
+                                            description: string;
+                                            name: string;
+                                            id: string;
+                                            tags: string[];
+                                            examples?: string[] | undefined;
+                                            inputModes?: string[] | undefined;
+                                            outputModes?: string[] | undefined;
+                                        }[] | undefined;
+                                        iconUrl?: string | undefined;
+                                        documentationUrl?: string | undefined;
+                                        additionalInterfaces?: {
+                                            url: string;
+                                            transport: "JSONRPC" | "GRPC" | "HTTP+JSON";
+                                        }[] | undefined;
+                                        securitySchemes?: Record<string, {
+                                            type: "apiKey";
+                                            name: string;
+                                            in: "query" | "header" | "cookie";
+                                            description?: string | undefined;
+                                        } | {
+                                            type: "http";
+                                            scheme: string;
+                                            description?: string | undefined;
+                                            bearerFormat?: string | undefined;
+                                        } | {
+                                            type: "oauth2";
+                                            flows: {
+                                                password?: {
+                                                    scopes: Record<string, string>;
+                                                    authorizationUrl?: string | undefined;
+                                                    tokenUrl?: string | undefined;
+                                                    refreshUrl?: string | undefined;
+                                                } | undefined;
+                                                implicit?: {
+                                                    scopes: Record<string, string>;
+                                                    authorizationUrl?: string | undefined;
+                                                    tokenUrl?: string | undefined;
+                                                    refreshUrl?: string | undefined;
+                                                } | undefined;
+                                                clientCredentials?: {
+                                                    scopes: Record<string, string>;
+                                                    authorizationUrl?: string | undefined;
+                                                    tokenUrl?: string | undefined;
+                                                    refreshUrl?: string | undefined;
+                                                } | undefined;
+                                                authorizationCode?: {
+                                                    scopes: Record<string, string>;
+                                                    authorizationUrl?: string | undefined;
+                                                    tokenUrl?: string | undefined;
+                                                    refreshUrl?: string | undefined;
+                                                } | undefined;
+                                            };
+                                            description?: string | undefined;
+                                        } | {
+                                            type: "openIdConnect";
+                                            openIdConnectUrl: string;
+                                            description?: string | undefined;
+                                        } | {
+                                            type: "mutualTLS";
+                                            description?: string | undefined;
+                                        }> | undefined;
+                                        security?: Record<string, string[]>[] | undefined;
+                                        supportsAuthenticatedExtendedCard?: boolean | undefined;
+                                        signatures?: {
+                                            protected: string;
+                                            signature: string;
+                                        }[] | undefined;
+                                    } | undefined;
+                                    greeting?: string | undefined;
+                                    memories?: {
+                                        enabled?: boolean | undefined;
+                                        limit?: number | undefined;
+                                        priority?: number | undefined;
+                                        includeTimestamps?: boolean | undefined;
+                                        includeTags?: boolean | undefined;
+                                        pinnedOnly?: boolean | undefined;
+                                    } | undefined;
+                                    mcpServers?: Record<string, {
+                                        type: "stdio";
+                                        command: string;
+                                        timeout?: number | undefined;
+                                        args?: string[] | undefined;
+                                        env?: Record<string, string> | undefined;
+                                        connectionMode?: "strict" | "lenient" | undefined;
+                                    } | {
+                                        type: "sse";
+                                        url: string;
+                                        timeout?: number | undefined;
+                                        connectionMode?: "strict" | "lenient" | undefined;
+                                        headers?: Record<string, string> | undefined;
+                                    } | {
+                                        type: "http";
+                                        url: string;
+                                        timeout?: number | undefined;
+                                        connectionMode?: "strict" | "lenient" | undefined;
+                                        headers?: Record<string, string> | undefined;
+                                    }> | undefined;
+                                    internalTools?: ("search_history" | "ask_user" | "read_file" | "glob_files" | "grep_content" | "write_file" | "edit_file" | "bash_exec" | "bash_output" | "kill_process" | "delegate_to_url")[] | undefined;
+                                    sessions?: {
+                                        maxSessions?: number | undefined;
+                                        sessionTTL?: number | undefined;
+                                    } | undefined;
+                                    toolConfirmation?: {
+                                        timeout?: number | undefined;
+                                        mode?: "manual" | "auto-approve" | "auto-deny" | undefined;
+                                        allowedToolsStorage?: "storage" | "memory" | undefined;
+                                        toolPolicies?: {
+                                            alwaysAllow?: string[] | undefined;
+                                            alwaysDeny?: string[] | undefined;
+                                        } | undefined;
+                                    } | undefined;
+                                    internalResources?: ({
+                                        type: "filesystem";
+                                        paths: string[];
+                                        maxFiles?: number | undefined;
+                                        maxDepth?: number | undefined;
+                                        includeHidden?: boolean | undefined;
+                                        includeExtensions?: string[] | undefined;
+                                    } | {
+                                        type: "blob";
+                                    })[] | {
+                                        enabled?: boolean | undefined;
+                                        resources?: ({
+                                            type: "filesystem";
+                                            paths: string[];
+                                            maxFiles?: number | undefined;
+                                            maxDepth?: number | undefined;
+                                            includeHidden?: boolean | undefined;
+                                            includeExtensions?: string[] | undefined;
+                                        } | {
+                                            type: "blob";
+                                        })[] | undefined;
+                                    } | undefined;
+                                    plugins?: {
+                                        custom?: {
+                                            name: string;
+                                            priority: number;
+                                            module: string;
+                                            blocking: boolean;
+                                            config?: Record<string, any> | undefined;
+                                            enabled?: boolean | undefined;
+                                        }[] | undefined;
+                                        contentPolicy?: import("zod").objectInputType<{
+                                            priority: import("zod").ZodNumber;
+                                            blocking: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                                            enabled: import("zod").ZodDefault<import("zod").ZodBoolean>;
+                                        }, import("zod").ZodTypeAny, "passthrough"> | undefined;
+                                        responseSanitizer?: import("zod").objectInputType<{
+                                            priority: import("zod").ZodNumber;
+                                            blocking: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                                            enabled: import("zod").ZodDefault<import("zod").ZodBoolean>;
+                                        }, import("zod").ZodTypeAny, "passthrough"> | undefined;
+                                    } | undefined;
+                                };
+                                id: string;
+                                name: string;
+                                tags?: string[] | undefined;
+                                author?: string | undefined;
+                            };
+                        };
+                        output: {
+                            id: string;
+                            name: string;
+                            created: true;
+                        };
+                        outputFormat: "json";
+                        status: 201;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    api: {
+        agent: {
+            path: import("hono/client").ClientRequest<{
+                $get: {
+                    input: {};
+                    output: {
+                        path: string;
+                        name: string;
+                        relativePath: string;
+                        isDefault: boolean;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        agent: {
+            config: import("hono/client").ClientRequest<{
+                $get: {
+                    input: {};
+                    output: {
+                        path: string;
+                        lastModified: string;
+                        yaml: string;
+                        relativePath: string;
+                        warnings: string[];
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+                $post: {
+                    input: {
+                        json: {
+                            yaml: string;
+                        };
+                    };
+                    output: {
+                        path: string;
+                        message: string;
+                        ok: true;
+                        restarted: boolean;
+                        reloaded: boolean;
+                        changesApplied: string[];
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        agent: {
+            validate: import("hono/client").ClientRequest<{
+                $post: {
+                    input: {
+                        json: {
+                            yaml: string;
+                        };
+                    };
+                    output: {
+                        valid: boolean;
+                        warnings: {
+                            path: string;
+                            code: string;
+                            message: string;
+                        }[];
+                        errors: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                            code: string;
+                            message: string;
+                            path?: string | undefined;
+                            line?: number | undefined;
+                            column?: number | undefined;
+                        }[];
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        agent: {
+            config: {
+                export: import("hono/client").ClientRequest<{
+                    $get: {
+                        input: {
+                            query: {
+                                sessionId?: string | undefined;
+                            };
+                        };
+                        output: Response;
+                        outputFormat: "json";
+                        status: import("hono/utils/http-status").StatusCode;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    api: {
+        approvals: {
+            ":approvalId": import("hono/client").ClientRequest<{
+                $post: {
+                    input: {
+                        param: {
+                            approvalId: string;
+                        };
+                    } & {
+                        header: {
+                            "Idempotency-Key"?: string | undefined;
+                        };
+                    } & {
+                        json: {
+                            status: import("@dexto/core").ApprovalStatus.APPROVED | import("@dexto/core").ApprovalStatus.DENIED;
+                            formData?: Record<string, unknown> | undefined;
+                            rememberChoice?: boolean | undefined;
+                        };
+                    };
+                    output: {};
+                    outputFormat: string;
+                    status: 400;
+                } | {
+                    input: {
+                        param: {
+                            approvalId: string;
+                        };
+                    } & {
+                        header: {
+                            "Idempotency-Key"?: string | undefined;
+                        };
+                    } & {
+                        json: {
+                            status: import("@dexto/core").ApprovalStatus.APPROVED | import("@dexto/core").ApprovalStatus.DENIED;
+                            formData?: Record<string, unknown> | undefined;
+                            rememberChoice?: boolean | undefined;
+                        };
+                    };
+                    output: {};
+                    outputFormat: string;
+                    status: 404;
+                } | {
+                    input: {
+                        param: {
+                            approvalId: string;
+                        };
+                    } & {
+                        header: {
+                            "Idempotency-Key"?: string | undefined;
+                        };
+                    } & {
+                        json: {
+                            status: import("@dexto/core").ApprovalStatus.APPROVED | import("@dexto/core").ApprovalStatus.DENIED;
+                            formData?: Record<string, unknown> | undefined;
+                            rememberChoice?: boolean | undefined;
+                        };
+                    };
+                    output: {};
+                    outputFormat: string;
+                    status: 503;
+                } | {
+                    input: {
+                        param: {
+                            approvalId: string;
+                        };
+                    } & {
+                        header: {
+                            "Idempotency-Key"?: string | undefined;
+                        };
+                    } & {
+                        json: {
+                            status: import("@dexto/core").ApprovalStatus.APPROVED | import("@dexto/core").ApprovalStatus.DENIED;
+                            formData?: Record<string, unknown> | undefined;
+                            rememberChoice?: boolean | undefined;
+                        };
+                    };
+                    output: {
+                        status: import("@dexto/core").ApprovalStatus.APPROVED | import("@dexto/core").ApprovalStatus.DENIED;
+                        ok: boolean;
+                        approvalId: string;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        memory: import("hono/client").ClientRequest<{
+            $post: {
+                input: {
+                    json: {
+                        content: string;
+                        metadata?: import("zod").objectInputType<{
+                            source: import("zod").ZodOptional<import("zod").ZodEnum<["user", "system"]>>;
+                            pinned: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                        }, import("zod").ZodTypeAny, "passthrough"> | undefined;
+                        tags?: string[] | undefined;
+                    };
+                };
+                output: {
+                    ok: true;
+                    memory: {
+                        content: string;
+                        id: string;
+                        createdAt: number;
+                        updatedAt: number;
+                        metadata?: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                            source?: "system" | "user" | undefined;
+                            pinned?: boolean | undefined;
+                        } | undefined;
+                        tags?: string[] | undefined | undefined;
+                    };
+                };
+                outputFormat: "json";
+                status: 201;
+            };
+            $get: {
+                input: {
+                    query: {
+                        tags?: string | undefined;
+                        source?: "system" | "user" | undefined;
+                        limit?: string | undefined;
+                        offset?: string | undefined;
+                        pinned?: string | undefined;
+                    };
+                };
+                output: {
+                    memories: {
+                        content: string;
+                        id: string;
+                        createdAt: number;
+                        updatedAt: number;
+                        metadata?: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                            source?: "system" | "user" | undefined;
+                            pinned?: boolean | undefined;
+                        } | undefined;
+                        tags?: string[] | undefined | undefined;
+                    }[];
+                    ok: true;
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        }>;
+    };
+} & {
+    api: {
+        memory: {
+            ":id": import("hono/client").ClientRequest<{
+                $get: {
+                    input: {
+                        param: {
+                            id: string;
+                        };
+                    };
+                    output: {
+                        ok: true;
+                        memory: {
+                            content: string;
+                            id: string;
+                            createdAt: number;
+                            updatedAt: number;
+                            metadata?: {
+                                [x: string]: import("hono/utils/types").JSONValue;
+                                source?: "system" | "user" | undefined;
+                                pinned?: boolean | undefined;
+                            } | undefined;
+                            tags?: string[] | undefined | undefined;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+                $put: {
+                    input: {
+                        param: {
+                            id: string;
+                        };
+                    } & {
+                        json: {
+                            metadata?: import("zod").objectInputType<{
+                                source: import("zod").ZodOptional<import("zod").ZodEnum<["user", "system"]>>;
+                                pinned: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                            }, import("zod").ZodTypeAny, "passthrough"> | undefined;
+                            content?: string | undefined;
+                            tags?: string[] | undefined;
+                        };
+                    };
+                    output: {
+                        ok: true;
+                        memory: {
+                            content: string;
+                            id: string;
+                            createdAt: number;
+                            updatedAt: number;
+                            metadata?: {
+                                [x: string]: import("hono/utils/types").JSONValue;
+                                source?: "system" | "user" | undefined;
+                                pinned?: boolean | undefined;
+                            } | undefined;
+                            tags?: string[] | undefined | undefined;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+                $delete: {
+                    input: {
+                        param: {
+                            id: string;
+                        };
+                    };
+                    output: {
+                        message: string;
+                        ok: true;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        resources: import("hono/client").ClientRequest<{
+            $get: {
+                input: {};
+                output: {
+                    ok: true;
+                    resources: {
+                        uri: string;
+                        source: "mcp" | "internal";
+                        description?: string | undefined;
+                        mimeType?: string | undefined;
+                        name?: string | undefined;
+                        metadata?: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | undefined;
+                        serverName?: string | undefined;
+                        size?: number | undefined;
+                        lastModified?: string | undefined;
+                    }[];
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        }>;
+    };
+} & {
+    api: {
+        resources: {
+            ":resourceId": {
+                content: import("hono/client").ClientRequest<{
+                    $get: {
+                        input: {
+                            param: {
+                                resourceId: string;
+                            };
+                        };
+                        output: {
+                            content: {
+                                contents: {
+                                    uri: string;
+                                    text?: string | undefined;
+                                    mimeType?: string | undefined;
+                                    blob?: string | undefined;
+                                }[];
+                                _meta?: {
+                                    [x: string]: any;
+                                } | undefined;
+                            };
+                            ok: true;
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    api: {
+        resources: {
+            ":resourceId": import("hono/client").ClientRequest<{
+                $head: {
+                    input: {
+                        param: {
+                            resourceId: string;
+                        };
+                    };
+                    output: {};
+                    outputFormat: string;
+                    status: 200;
+                } | {
+                    input: {
+                        param: {
+                            resourceId: string;
+                        };
+                    };
+                    output: {};
+                    outputFormat: string;
+                    status: 404;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        prompts: import("hono/client").ClientRequest<{
+            $get: {
+                input: {};
+                output: {
+                    prompts: {
+                        name: string;
+                        source: "config" | "custom" | "mcp";
+                        description?: string | undefined;
+                        title?: string | undefined;
+                        arguments?: {
+                            name: string;
+                            description?: string | undefined;
+                            required?: boolean | undefined;
+                        }[] | undefined;
+                        metadata?: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | undefined;
+                    }[];
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        }>;
+    };
+} & {
+    api: {
+        prompts: {
+            custom: import("hono/client").ClientRequest<{
+                $post: {
+                    input: {
+                        json: {
+                            content: string;
+                            name: string;
+                            description?: string | undefined;
+                            title?: string | undefined;
+                            arguments?: {
+                                name: string;
+                                description?: string | undefined;
+                                required?: boolean | undefined;
+                            }[] | undefined;
+                            resource?: {
+                                mimeType: string;
+                                base64: string;
+                                filename?: string | undefined;
+                            } | undefined;
+                        };
+                    };
+                    output: {
+                        prompt: {
+                            name: string;
+                            source: "config" | "custom" | "mcp";
+                            description?: string | undefined;
+                            title?: string | undefined;
+                            arguments?: {
+                                name: string;
+                                description?: string | undefined;
+                                required?: boolean | undefined;
+                            }[] | undefined;
+                            metadata?: {
+                                [x: string]: import("hono/utils/types").JSONValue;
+                            } | undefined;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 201;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        prompts: {
+            custom: {
+                ":name": import("hono/client").ClientRequest<{
+                    $delete: {
+                        input: {
+                            param: {
+                                name: string;
+                            };
+                        };
+                        output: {};
+                        outputFormat: string;
+                        status: 204;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    api: {
+        prompts: {
+            ":name": import("hono/client").ClientRequest<{
+                $get: {
+                    input: {
+                        param: {
+                            name: string;
+                        };
+                    };
+                    output: {};
+                    outputFormat: string;
+                    status: 404;
+                } | {
+                    input: {
+                        param: {
+                            name: string;
+                        };
+                    };
+                    output: {
+                        definition: {
+                            name: string;
+                            description?: string | undefined;
+                            title?: string | undefined;
+                            arguments?: {
+                                name: string;
+                                description?: string | undefined;
+                                required?: boolean | undefined;
+                            }[] | undefined;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        prompts: {
+            ":name": {
+                resolve: import("hono/client").ClientRequest<{
+                    $get: {
+                        input: {
+                            param: {
+                                name: string;
+                            };
+                        } & {
+                            query: {
+                                context?: string | undefined;
+                                args?: string | undefined;
+                            };
+                        };
+                        output: {};
+                        outputFormat: string;
+                        status: 404;
+                    } | {
+                        input: {
+                            param: {
+                                name: string;
+                            };
+                        } & {
+                            query: {
+                                context?: string | undefined;
+                                args?: string | undefined;
+                            };
+                        };
+                        output: {
+                            text: string;
+                            resources: string[];
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    api: {
+        webhooks: import("hono/client").ClientRequest<{
+            $post: {
+                input: {
+                    json: {
+                        url: string;
+                        description?: string | undefined;
+                        secret?: string | undefined;
+                    };
+                };
+                output: {
+                    webhook: {
+                        id: string;
+                        createdAt: string | number;
+                        url: string;
+                        description?: string | undefined;
+                    };
+                };
+                outputFormat: "json";
+                status: 201;
+            };
+            $get: {
+                input: {};
+                output: {
+                    webhooks: {
+                        id: string;
+                        createdAt: string | number;
+                        url: string;
+                        description?: string | undefined;
+                    }[];
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        }>;
+    };
+} & {
+    api: {
+        webhooks: {
+            ":webhookId": import("hono/client").ClientRequest<{
+                $get: {
+                    input: {
+                        param: {
+                            webhookId: string;
+                        };
+                    };
+                    output: {};
+                    outputFormat: string;
+                    status: 404;
+                } | {
+                    input: {
+                        param: {
+                            webhookId: string;
+                        };
+                    };
+                    output: {
+                        webhook: {
+                            id: string;
+                            createdAt: string | number;
+                            url: string;
+                            description?: string | undefined;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+                $delete: {
+                    input: {
+                        param: {
+                            webhookId: string;
+                        };
+                    };
+                    output: {};
+                    outputFormat: string;
+                    status: 404;
+                } | {
+                    input: {
+                        param: {
+                            webhookId: string;
+                        };
+                    };
+                    output: {
+                        status: "removed";
+                        webhookId: string;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        webhooks: {
+            ":webhookId": {
+                test: import("hono/client").ClientRequest<{
+                    $post: {
+                        input: {
+                            param: {
+                                webhookId: string;
+                            };
+                        };
+                        output: {};
+                        outputFormat: string;
+                        status: 404;
+                    } | {
+                        input: {
+                            param: {
+                                webhookId: string;
+                            };
+                        };
+                        output: {
+                            result: {
+                                success: boolean;
+                                error?: string | undefined;
+                                responseTime?: number | undefined;
+                                statusCode?: number | undefined;
+                            };
+                            test: "completed";
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    api: {
+        mcp: {
+            servers: import("hono/client").ClientRequest<{
+                $post: {
+                    input: {
+                        json: {
+                            config: {
+                                type: "stdio";
+                                command: string;
+                                timeout?: number | undefined;
+                                args?: string[] | undefined;
+                                env?: Record<string, string> | undefined;
+                                connectionMode?: "strict" | "lenient" | undefined;
+                            } | {
+                                type: "sse";
+                                url: string;
+                                timeout?: number | undefined;
+                                connectionMode?: "strict" | "lenient" | undefined;
+                                headers?: Record<string, string> | undefined;
+                            } | {
+                                type: "http";
+                                url: string;
+                                timeout?: number | undefined;
+                                connectionMode?: "strict" | "lenient" | undefined;
+                                headers?: Record<string, string> | undefined;
+                            };
+                            name: string;
+                            persistToAgent?: boolean | undefined;
+                        };
+                    };
+                    output: {
+                        status: string;
+                        name: string;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+                $get: {
+                    input: {};
+                    output: {
+                        servers: {
+                            status: "error" | "connected" | "disconnected";
+                            id: string;
+                            name: string;
+                        }[];
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        mcp: {
+            servers: {
+                ":serverId": {
+                    tools: import("hono/client").ClientRequest<{
+                        $get: {
+                            input: {
+                                param: {
+                                    serverId: string;
+                                };
+                            };
+                            output: {};
+                            outputFormat: string;
+                            status: 404;
+                        } | {
+                            input: {
+                                param: {
+                                    serverId: string;
+                                };
+                            };
+                            output: {
+                                tools: {
+                                    description: string;
+                                    id: string;
+                                    name: string;
+                                    inputSchema?: {
+                                        [x: string]: import("hono/utils/types").JSONValue;
+                                        type?: "object" | undefined;
+                                        properties?: {
+                                            [x: string]: {
+                                                [x: string]: import("hono/utils/types").JSONValue;
+                                                description?: string | undefined;
+                                                default?: any;
+                                                type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | undefined;
+                                                enum?: (string | number | boolean)[] | undefined;
+                                            };
+                                        } | undefined;
+                                        required?: string[] | undefined;
+                                    } | undefined;
+                                }[];
+                            };
+                            outputFormat: "json";
+                            status: 200;
+                        };
+                    }>;
+                };
+            };
+        };
+    };
+} & {
+    api: {
+        mcp: {
+            servers: {
+                ":serverId": import("hono/client").ClientRequest<{
+                    $delete: {
+                        input: {
+                            param: {
+                                serverId: string;
+                            };
+                        };
+                        output: {};
+                        outputFormat: string;
+                        status: 404;
+                    } | {
+                        input: {
+                            param: {
+                                serverId: string;
+                            };
+                        };
+                        output: {
+                            status: "disconnected";
+                            id: string;
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    api: {
+        mcp: {
+            servers: {
+                ":serverId": {
+                    restart: import("hono/client").ClientRequest<{
+                        $post: {
+                            input: {
+                                param: {
+                                    serverId: string;
+                                };
+                            };
+                            output: {};
+                            outputFormat: string;
+                            status: 404;
+                        } | {
+                            input: {
+                                param: {
+                                    serverId: string;
+                                };
+                            };
+                            output: {
+                                status: "restarted";
+                                id: string;
+                            };
+                            outputFormat: "json";
+                            status: 200;
+                        };
+                    }>;
+                };
+            };
+        };
+    };
+} & {
+    api: {
+        mcp: {
+            servers: {
+                ":serverId": {
+                    tools: {
+                        ":toolName": {
+                            execute: import("hono/client").ClientRequest<{
+                                $post: {
+                                    input: {
+                                        param: {
+                                            serverId: string;
+                                            toolName: string;
+                                        };
+                                    } & {
+                                        json: Record<string, unknown>;
+                                    };
+                                    output: {};
+                                    outputFormat: string;
+                                    status: 404;
+                                } | {
+                                    input: {
+                                        param: {
+                                            serverId: string;
+                                            toolName: string;
+                                        };
+                                    } & {
+                                        json: Record<string, unknown>;
+                                    };
+                                    output: {
+                                        success: boolean;
+                                        data?: any;
+                                        error?: string | undefined;
+                                    };
+                                    outputFormat: "json";
+                                    status: 200;
+                                };
+                            }>;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    api: {
+        mcp: {
+            servers: {
+                ":serverId": {
+                    resources: import("hono/client").ClientRequest<{
+                        $get: {
+                            input: {
+                                param: {
+                                    serverId: string;
+                                };
+                            };
+                            output: {};
+                            outputFormat: string;
+                            status: 404;
+                        } | {
+                            input: {
+                                param: {
+                                    serverId: string;
+                                };
+                            };
+                            output: {
+                                success: boolean;
+                                resources: {
+                                    uri: string;
+                                    source: "mcp" | "internal";
+                                    description?: string | undefined;
+                                    mimeType?: string | undefined;
+                                    name?: string | undefined;
+                                    metadata?: {
+                                        [x: string]: import("hono/utils/types").JSONValue;
+                                    } | undefined;
+                                    serverName?: string | undefined;
+                                    size?: number | undefined;
+                                    lastModified?: string | undefined;
+                                }[];
+                            };
+                            outputFormat: "json";
+                            status: 200;
+                        };
+                    }>;
+                };
+            };
+        };
+    };
+} & {
+    api: {
+        mcp: {
+            servers: {
+                ":serverId": {
+                    resources: {
+                        ":resourceId": {
+                            content: import("hono/client").ClientRequest<{
+                                $get: {
+                                    input: {
+                                        param: {
+                                            serverId: string;
+                                            resourceId: string;
+                                        };
+                                    };
+                                    output: {};
+                                    outputFormat: string;
+                                    status: 404;
+                                } | {
+                                    input: {
+                                        param: {
+                                            serverId: string;
+                                            resourceId: string;
+                                        };
+                                    };
+                                    output: {
+                                        data: {
+                                            content?: any;
+                                        };
+                                        success: boolean;
+                                    };
+                                    outputFormat: "json";
+                                    status: 200;
+                                };
+                            }>;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    api: {
+        search: {
+            messages: import("hono/client").ClientRequest<{
+                $get: {
+                    input: {
+                        query: {
+                            q: string;
+                            sessionId?: string | undefined;
+                            role?: "system" | "user" | "assistant" | "tool" | undefined;
+                            limit?: number | undefined;
+                            offset?: number | undefined;
+                        };
+                    };
+                    output: {
+                        query: string;
+                        results: {
+                            message: {
+                                content: string | ({
+                                    type: "text";
+                                    text: string;
+                                } | {
+                                    type: "image";
+                                    image?: import("hono/utils/types").JSONValue;
+                                    mimeType?: string | undefined;
+                                } | {
+                                    type: "file";
+                                    mimeType: string;
+                                    data?: import("hono/utils/types").JSONValue;
+                                    filename?: string | undefined;
+                                })[] | null;
+                                role: "system" | "user" | "assistant" | "tool";
+                                provider?: string | undefined;
+                                model?: string | undefined;
+                                router?: string | undefined;
+                                name?: string | undefined;
+                                timestamp?: number | undefined;
+                                reasoning?: string | undefined;
+                                tokenUsage?: {
+                                    inputTokens?: number | undefined;
+                                    outputTokens?: number | undefined;
+                                    reasoningTokens?: number | undefined;
+                                    totalTokens?: number | undefined;
+                                } | undefined;
+                                toolCalls?: {
+                                    function: {
+                                        name: string;
+                                        arguments: string;
+                                    };
+                                    type: "function";
+                                    id: string;
+                                }[] | undefined;
+                                toolCallId?: string | undefined;
+                            };
+                            sessionId: string;
+                            matchedText: string;
+                            context: string;
+                            messageIndex: number;
+                        }[];
+                        total: number;
+                        hasMore: boolean;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        search: {
+            sessions: import("hono/client").ClientRequest<{
+                $get: {
+                    input: {
+                        query: {
+                            q: string;
+                        };
+                    };
+                    output: {
+                        query: string;
+                        results: {
+                            sessionId: string;
+                            matchCount: number;
+                            firstMatch: {
+                                message: {
+                                    content: string | ({
+                                        type: "text";
+                                        text: string;
+                                    } | {
+                                        type: "image";
+                                        image?: import("hono/utils/types").JSONValue;
+                                        mimeType?: string | undefined;
+                                    } | {
+                                        type: "file";
+                                        mimeType: string;
+                                        data?: import("hono/utils/types").JSONValue;
+                                        filename?: string | undefined;
+                                    })[] | null;
+                                    role: "system" | "user" | "assistant" | "tool";
+                                    provider?: string | undefined;
+                                    model?: string | undefined;
+                                    router?: string | undefined;
+                                    name?: string | undefined;
+                                    timestamp?: number | undefined;
+                                    reasoning?: string | undefined;
+                                    tokenUsage?: {
+                                        inputTokens?: number | undefined;
+                                        outputTokens?: number | undefined;
+                                        reasoningTokens?: number | undefined;
+                                        totalTokens?: number | undefined;
+                                    } | undefined;
+                                    toolCalls?: {
+                                        function: {
+                                            name: string;
+                                            arguments: string;
+                                        };
+                                        type: "function";
+                                        id: string;
+                                    }[] | undefined;
+                                    toolCallId?: string | undefined;
+                                };
+                                sessionId: string;
+                                matchedText: string;
+                                context: string;
+                                messageIndex: number;
+                            };
+                            metadata: {
+                                createdAt: number;
+                                lastActivity: number;
+                                messageCount: number;
+                            };
+                        }[];
+                        total: number;
+                        hasMore: boolean;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        sessions: import("hono/client").ClientRequest<{
+            $get: {
+                input: {};
+                output: {
+                    sessions: {
+                        id: string;
+                        createdAt: number | null;
+                        lastActivity: number | null;
+                        messageCount: number;
+                        title?: string | null | undefined;
+                    }[];
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+            $post: {
+                input: {
+                    json: {
+                        sessionId?: string | undefined;
+                    };
+                };
+                output: {
+                    session: {
+                        id: string;
+                        createdAt: number | null;
+                        lastActivity: number | null;
+                        messageCount: number;
+                        title?: string | null | undefined;
+                    };
+                };
+                outputFormat: "json";
+                status: 201;
+            };
+        }>;
+    };
+} & {
+    api: {
+        sessions: {
+            ":sessionId": import("hono/client").ClientRequest<{
+                $get: {
+                    input: {
+                        param: {
+                            sessionId: string;
+                        };
+                    };
+                    output: {
+                        session: {
+                            id: string;
+                            createdAt: number | null;
+                            lastActivity: number | null;
+                            messageCount: number;
+                            history: number;
+                            title?: string | null | undefined;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+                $delete: {
+                    input: {
+                        param: {
+                            sessionId: string;
+                        };
+                    };
+                    output: {
+                        status: "deleted";
+                        sessionId: string;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+                $patch: {
+                    input: {
+                        param: {
+                            sessionId: string;
+                        };
+                    } & {
+                        json: {
+                            title: string;
+                        };
+                    };
+                    output: {
+                        session: {
+                            id: string;
+                            createdAt: number | null;
+                            lastActivity: number | null;
+                            messageCount: number;
+                            title?: string | null | undefined;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        sessions: {
+            ":sessionId": {
+                history: import("hono/client").ClientRequest<{
+                    $get: {
+                        input: {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            history: {
+                                content: string | ({
+                                    type: "text";
+                                    text: string;
+                                } | {
+                                    type: "image";
+                                    image?: import("hono/utils/types").JSONValue;
+                                    mimeType?: string | undefined;
+                                } | {
+                                    type: "file";
+                                    mimeType: string;
+                                    data?: import("hono/utils/types").JSONValue;
+                                    filename?: string | undefined;
+                                })[] | null;
+                                role: "system" | "user" | "assistant" | "tool";
+                                provider?: string | undefined;
+                                model?: string | undefined;
+                                router?: string | undefined;
+                                name?: string | undefined;
+                                timestamp?: number | undefined;
+                                reasoning?: string | undefined;
+                                tokenUsage?: {
+                                    inputTokens?: number | undefined;
+                                    outputTokens?: number | undefined;
+                                    reasoningTokens?: number | undefined;
+                                    totalTokens?: number | undefined;
+                                } | undefined;
+                                toolCalls?: {
+                                    function: {
+                                        name: string;
+                                        arguments: string;
+                                    };
+                                    type: "function";
+                                    id: string;
+                                }[] | undefined;
+                                toolCallId?: string | undefined;
+                            }[];
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    api: {
+        sessions: {
+            ":sessionId": {
+                cancel: import("hono/client").ClientRequest<{
+                    $post: {
+                        input: {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            sessionId: string;
+                            cancelled: boolean;
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    api: {
+        sessions: {
+            ":sessionId": {
+                load: import("hono/client").ClientRequest<{
+                    $get: {
+                        input: {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            session: {
+                                id: string;
+                                createdAt: number | null;
+                                lastActivity: number | null;
+                                messageCount: number;
+                                title?: string | null | undefined;
+                            };
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    } | {
+                        input: {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            error: string;
+                        };
+                        outputFormat: "json";
+                        status: 404;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    api: {
+        sessions: {
+            ":sessionId": {
+                "generate-title": import("hono/client").ClientRequest<{
+                    $post: {
+                        input: {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {};
+                        outputFormat: string;
+                        status: 404;
+                    } | {
+                        input: {
+                            param: {
+                                sessionId: string;
+                            };
+                        };
+                        output: {
+                            title: string | null;
+                            sessionId: string;
+                        };
+                        outputFormat: "json";
+                        status: 200;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    api: {
+        llm: {
+            current: import("hono/client").ClientRequest<{
+                $get: {
+                    input: {
+                        query: {
+                            sessionId?: string | undefined;
+                        };
+                    };
+                    output: {
+                        config: {
+                            provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+                            model: string;
+                            maxIterations?: number | undefined;
+                            router?: "vercel" | "in-built" | undefined;
+                            baseURL?: string | undefined;
+                            maxInputTokens?: number | undefined;
+                            maxOutputTokens?: number | undefined;
+                            temperature?: number | undefined;
+                            allowedMediaTypes?: string[] | undefined;
+                            hasApiKey?: boolean | undefined;
+                            displayName?: string | undefined;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        llm: {
+            catalog: import("hono/client").ClientRequest<{
+                $get: {
+                    input: {
+                        query: {
+                            provider?: string | string[] | undefined;
+                            router?: "vercel" | "in-built" | undefined;
+                            hasKey?: "0" | "1" | "true" | "false" | undefined;
+                            fileType?: "image" | "audio" | "pdf" | undefined;
+                            defaultOnly?: "0" | "1" | "true" | "false" | undefined;
+                            mode?: "flat" | "grouped" | undefined;
+                        };
+                    };
+                    output: {
+                        providers: {
+                            openai?: {
+                                hasApiKey: boolean;
+                                name: string;
+                                supportedFileTypes: ("image" | "audio" | "pdf")[];
+                                supportedRouters: ("vercel" | "in-built")[];
+                                primaryEnvVar: string;
+                                supportsBaseURL: boolean;
+                                models: {
+                                    maxInputTokens: number;
+                                    name: string;
+                                    supportedFileTypes: ("image" | "audio" | "pdf")[];
+                                    default?: boolean | undefined;
+                                    supportedRouters?: ("vercel" | "in-built")[] | undefined;
+                                    displayName?: string | undefined;
+                                    pricing?: {
+                                        inputPerM: number;
+                                        outputPerM: number;
+                                        cacheReadPerM?: number | undefined;
+                                        cacheWritePerM?: number | undefined;
+                                        currency?: "USD" | undefined;
+                                        unit?: "per_million_tokens" | undefined;
+                                    } | undefined;
+                                }[];
+                            } | undefined;
+                            "openai-compatible"?: {
+                                hasApiKey: boolean;
+                                name: string;
+                                supportedFileTypes: ("image" | "audio" | "pdf")[];
+                                supportedRouters: ("vercel" | "in-built")[];
+                                primaryEnvVar: string;
+                                supportsBaseURL: boolean;
+                                models: {
+                                    maxInputTokens: number;
+                                    name: string;
+                                    supportedFileTypes: ("image" | "audio" | "pdf")[];
+                                    default?: boolean | undefined;
+                                    supportedRouters?: ("vercel" | "in-built")[] | undefined;
+                                    displayName?: string | undefined;
+                                    pricing?: {
+                                        inputPerM: number;
+                                        outputPerM: number;
+                                        cacheReadPerM?: number | undefined;
+                                        cacheWritePerM?: number | undefined;
+                                        currency?: "USD" | undefined;
+                                        unit?: "per_million_tokens" | undefined;
+                                    } | undefined;
+                                }[];
+                            } | undefined;
+                            anthropic?: {
+                                hasApiKey: boolean;
+                                name: string;
+                                supportedFileTypes: ("image" | "audio" | "pdf")[];
+                                supportedRouters: ("vercel" | "in-built")[];
+                                primaryEnvVar: string;
+                                supportsBaseURL: boolean;
+                                models: {
+                                    maxInputTokens: number;
+                                    name: string;
+                                    supportedFileTypes: ("image" | "audio" | "pdf")[];
+                                    default?: boolean | undefined;
+                                    supportedRouters?: ("vercel" | "in-built")[] | undefined;
+                                    displayName?: string | undefined;
+                                    pricing?: {
+                                        inputPerM: number;
+                                        outputPerM: number;
+                                        cacheReadPerM?: number | undefined;
+                                        cacheWritePerM?: number | undefined;
+                                        currency?: "USD" | undefined;
+                                        unit?: "per_million_tokens" | undefined;
+                                    } | undefined;
+                                }[];
+                            } | undefined;
+                            google?: {
+                                hasApiKey: boolean;
+                                name: string;
+                                supportedFileTypes: ("image" | "audio" | "pdf")[];
+                                supportedRouters: ("vercel" | "in-built")[];
+                                primaryEnvVar: string;
+                                supportsBaseURL: boolean;
+                                models: {
+                                    maxInputTokens: number;
+                                    name: string;
+                                    supportedFileTypes: ("image" | "audio" | "pdf")[];
+                                    default?: boolean | undefined;
+                                    supportedRouters?: ("vercel" | "in-built")[] | undefined;
+                                    displayName?: string | undefined;
+                                    pricing?: {
+                                        inputPerM: number;
+                                        outputPerM: number;
+                                        cacheReadPerM?: number | undefined;
+                                        cacheWritePerM?: number | undefined;
+                                        currency?: "USD" | undefined;
+                                        unit?: "per_million_tokens" | undefined;
+                                    } | undefined;
+                                }[];
+                            } | undefined;
+                            groq?: {
+                                hasApiKey: boolean;
+                                name: string;
+                                supportedFileTypes: ("image" | "audio" | "pdf")[];
+                                supportedRouters: ("vercel" | "in-built")[];
+                                primaryEnvVar: string;
+                                supportsBaseURL: boolean;
+                                models: {
+                                    maxInputTokens: number;
+                                    name: string;
+                                    supportedFileTypes: ("image" | "audio" | "pdf")[];
+                                    default?: boolean | undefined;
+                                    supportedRouters?: ("vercel" | "in-built")[] | undefined;
+                                    displayName?: string | undefined;
+                                    pricing?: {
+                                        inputPerM: number;
+                                        outputPerM: number;
+                                        cacheReadPerM?: number | undefined;
+                                        cacheWritePerM?: number | undefined;
+                                        currency?: "USD" | undefined;
+                                        unit?: "per_million_tokens" | undefined;
+                                    } | undefined;
+                                }[];
+                            } | undefined;
+                            xai?: {
+                                hasApiKey: boolean;
+                                name: string;
+                                supportedFileTypes: ("image" | "audio" | "pdf")[];
+                                supportedRouters: ("vercel" | "in-built")[];
+                                primaryEnvVar: string;
+                                supportsBaseURL: boolean;
+                                models: {
+                                    maxInputTokens: number;
+                                    name: string;
+                                    supportedFileTypes: ("image" | "audio" | "pdf")[];
+                                    default?: boolean | undefined;
+                                    supportedRouters?: ("vercel" | "in-built")[] | undefined;
+                                    displayName?: string | undefined;
+                                    pricing?: {
+                                        inputPerM: number;
+                                        outputPerM: number;
+                                        cacheReadPerM?: number | undefined;
+                                        cacheWritePerM?: number | undefined;
+                                        currency?: "USD" | undefined;
+                                        unit?: "per_million_tokens" | undefined;
+                                    } | undefined;
+                                }[];
+                            } | undefined;
+                            cohere?: {
+                                hasApiKey: boolean;
+                                name: string;
+                                supportedFileTypes: ("image" | "audio" | "pdf")[];
+                                supportedRouters: ("vercel" | "in-built")[];
+                                primaryEnvVar: string;
+                                supportsBaseURL: boolean;
+                                models: {
+                                    maxInputTokens: number;
+                                    name: string;
+                                    supportedFileTypes: ("image" | "audio" | "pdf")[];
+                                    default?: boolean | undefined;
+                                    supportedRouters?: ("vercel" | "in-built")[] | undefined;
+                                    displayName?: string | undefined;
+                                    pricing?: {
+                                        inputPerM: number;
+                                        outputPerM: number;
+                                        cacheReadPerM?: number | undefined;
+                                        cacheWritePerM?: number | undefined;
+                                        currency?: "USD" | undefined;
+                                        unit?: "per_million_tokens" | undefined;
+                                    } | undefined;
+                                }[];
+                            } | undefined;
+                        };
+                    } | {
+                        models: {
+                            provider: string;
+                            maxInputTokens: number;
+                            name: string;
+                            supportedFileTypes: ("image" | "audio" | "pdf")[];
+                            default?: boolean | undefined;
+                            supportedRouters?: ("vercel" | "in-built")[] | undefined;
+                            displayName?: string | undefined;
+                            pricing?: {
+                                inputPerM: number;
+                                outputPerM: number;
+                                cacheReadPerM?: number | undefined;
+                                cacheWritePerM?: number | undefined;
+                                currency?: "USD" | undefined;
+                                unit?: "per_million_tokens" | undefined;
+                            } | undefined;
+                        }[];
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        llm: {
+            key: import("hono/client").ClientRequest<{
+                $post: {
+                    input: {
+                        json: {
+                            provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+                            apiKey: string;
+                        };
+                    };
+                    output: {
+                        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+                        ok: true;
+                        envVar: string;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        llm: {
+            switch: import("hono/client").ClientRequest<{
+                $post: {
+                    input: {
+                        json: {
+                            apiKey?: string | undefined;
+                            model?: string | undefined;
+                            provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+                            router?: "vercel" | "in-built" | undefined;
+                            maxIterations?: number | undefined;
+                            baseURL?: string | undefined;
+                            maxInputTokens?: number | undefined;
+                            maxOutputTokens?: number | undefined;
+                            temperature?: number | undefined;
+                            allowedMediaTypes?: string[] | undefined;
+                        } & {
+                            sessionId?: string | undefined;
+                        };
+                    };
+                    output: {
+                        config: {
+                            provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+                            model: string;
+                            maxIterations: number;
+                            router: "vercel" | "in-built";
+                            baseURL?: string | undefined;
+                            maxInputTokens?: number | undefined;
+                            maxOutputTokens?: number | undefined;
+                            temperature?: number | undefined;
+                            allowedMediaTypes?: string[] | undefined;
+                            hasApiKey?: boolean | undefined;
+                        };
+                        sessionId?: string | undefined;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    api: {
+        message: import("hono/client").ClientRequest<{
+            $post: {
+                input: {
+                    json: {
+                        sessionId: string;
+                        message?: string | undefined;
+                        imageData?: {
+                            mimeType: string;
+                            base64: string;
+                        } | undefined;
+                        fileData?: {
+                            mimeType: string;
+                            base64: string;
+                            filename?: string | undefined;
+                        } | undefined;
+                    };
+                };
+                output: {
+                    sessionId: string;
+                    accepted: true;
+                };
+                outputFormat: "json";
+                status: 202;
+            } | {
+                input: {
+                    json: {
+                        sessionId: string;
+                        message?: string | undefined;
+                        imageData?: {
+                            mimeType: string;
+                            base64: string;
+                        } | undefined;
+                        fileData?: {
+                            mimeType: string;
+                            base64: string;
+                            filename?: string | undefined;
+                        } | undefined;
+                    };
+                };
+                output: {};
+                outputFormat: string;
+                status: 400;
+            };
+        }>;
+    };
+} & {
+    api: {
+        "message-sync": import("hono/client").ClientRequest<{
+            $post: {
+                input: {
+                    json: {
+                        sessionId: string;
+                        message?: string | undefined;
+                        imageData?: {
+                            mimeType: string;
+                            base64: string;
+                        } | undefined;
+                        fileData?: {
+                            mimeType: string;
+                            base64: string;
+                            filename?: string | undefined;
+                        } | undefined;
+                    };
+                };
+                output: {};
+                outputFormat: string;
+                status: 400;
+            } | {
+                input: {
+                    json: {
+                        sessionId: string;
+                        message?: string | undefined;
+                        imageData?: {
+                            mimeType: string;
+                            base64: string;
+                        } | undefined;
+                        fileData?: {
+                            mimeType: string;
+                            base64: string;
+                            filename?: string | undefined;
+                        } | undefined;
+                    };
+                };
+                output: {
+                    sessionId: string;
+                    response: string;
+                    provider?: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere" | undefined;
+                    model?: string | undefined;
+                    router?: "vercel" | "in-built" | undefined;
+                    reasoning?: string | undefined;
+                    tokenUsage?: {
+                        inputTokens?: number | undefined;
+                        outputTokens?: number | undefined;
+                        reasoningTokens?: number | undefined;
+                        totalTokens?: number | undefined;
+                    } | undefined;
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        }>;
+    };
+} & {
+    api: {
+        reset: import("hono/client").ClientRequest<{
+            $post: {
+                input: {
+                    json: {
+                        sessionId: string;
+                    };
+                };
+                output: {
+                    status: string;
+                    sessionId: string;
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        }>;
+    };
+} & {
+    api: {
+        "message-stream": import("hono/client").ClientRequest<{
+            $post: {
+                input: {
+                    json: {
+                        sessionId: string;
+                        message?: string | undefined;
+                        imageData?: {
+                            mimeType: string;
+                            base64: string;
+                        } | undefined;
+                        fileData?: {
+                            mimeType: string;
+                            base64: string;
+                            filename?: string | undefined;
+                        } | undefined;
+                    };
+                };
+                output: Response;
+                outputFormat: "json";
+                status: import("hono/utils/http-status").StatusCode;
+            } | {
+                input: {
+                    json: {
+                        sessionId: string;
+                        message?: string | undefined;
+                        imageData?: {
+                            mimeType: string;
+                            base64: string;
+                        } | undefined;
+                        fileData?: {
+                            mimeType: string;
+                            base64: string;
+                            filename?: string | undefined;
+                        } | undefined;
+                    };
+                };
+                output: {};
+                outputFormat: string;
+                status: 400;
+            };
+        }>;
+    };
+} & {
+    api: {
+        greeting: import("hono/client").ClientRequest<{
+            $get: {
+                input: {
+                    query: {
+                        sessionId?: string | undefined;
+                    };
+                };
+                output: {
+                    greeting?: string | undefined;
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        }>;
+    };
+} & {
+    v1: {
+        "message:send": import("hono/client").ClientRequest<{
+            $post: {
+                input: {
+                    json: {
+                        message: {
+                            role: "user" | "agent";
+                            kind: "message";
+                            parts: ({
+                                text: string;
+                                kind: "text";
+                                metadata?: Record<string, any> | undefined;
+                            } | {
+                                file: {
+                                    bytes: string;
+                                    mimeType?: string | undefined;
+                                    name?: string | undefined;
+                                } | {
+                                    uri: string;
+                                    mimeType?: string | undefined;
+                                    name?: string | undefined;
+                                };
+                                kind: "file";
+                                metadata?: Record<string, any> | undefined;
+                            } | {
+                                data: Record<string, any>;
+                                kind: "data";
+                                metadata?: Record<string, any> | undefined;
+                            })[];
+                            messageId: string;
+                            metadata?: Record<string, any> | undefined;
+                            contextId?: string | undefined;
+                            taskId?: string | undefined;
+                            extensions?: string[] | undefined;
+                            referenceTaskIds?: string[] | undefined;
+                        };
+                        metadata?: Record<string, any> | undefined;
+                        configuration?: {
+                            blocking?: boolean | undefined;
+                            acceptedOutputModes?: string[] | undefined;
+                            historyLength?: number | undefined;
+                            pushNotificationConfig?: {
+                                url: string;
+                                headers?: Record<string, string> | undefined;
+                            } | undefined;
+                        } | undefined;
+                    };
+                };
+                output: {
+                    status: {
+                        state: "unknown" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "rejected" | "auth-required";
+                        message?: {
+                            role: "user" | "agent";
+                            kind: "message";
+                            parts: ({
+                                text: string;
+                                kind: "text";
+                                metadata?: {
+                                    [x: string]: any;
+                                } | undefined;
+                            } | {
+                                file: {
+                                    bytes: string;
+                                    mimeType?: string | undefined;
+                                    name?: string | undefined;
+                                } | {
+                                    uri: string;
+                                    mimeType?: string | undefined;
+                                    name?: string | undefined;
+                                };
+                                kind: "file";
+                                metadata?: {
+                                    [x: string]: any;
+                                } | undefined;
+                            } | {
+                                data: {
+                                    [x: string]: any;
+                                };
+                                kind: "data";
+                                metadata?: {
+                                    [x: string]: any;
+                                } | undefined;
+                            })[];
+                            messageId: string;
+                            metadata?: {
+                                [x: string]: any;
+                            } | undefined;
+                            contextId?: string | undefined;
+                            taskId?: string | undefined;
+                            extensions?: string[] | undefined;
+                            referenceTaskIds?: string[] | undefined;
+                        } | undefined;
+                        timestamp?: string | undefined;
+                    };
+                    id: string;
+                    kind: "task";
+                    contextId: string;
+                    metadata?: {
+                        [x: string]: any;
+                    } | undefined;
+                    history?: {
+                        role: "user" | "agent";
+                        kind: "message";
+                        parts: ({
+                            text: string;
+                            kind: "text";
+                            metadata?: {
+                                [x: string]: any;
+                            } | undefined;
+                        } | {
+                            file: {
+                                bytes: string;
+                                mimeType?: string | undefined;
+                                name?: string | undefined;
+                            } | {
+                                uri: string;
+                                mimeType?: string | undefined;
+                                name?: string | undefined;
+                            };
+                            kind: "file";
+                            metadata?: {
+                                [x: string]: any;
+                            } | undefined;
+                        } | {
+                            data: {
+                                [x: string]: any;
+                            };
+                            kind: "data";
+                            metadata?: {
+                                [x: string]: any;
+                            } | undefined;
+                        })[];
+                        messageId: string;
+                        metadata?: {
+                            [x: string]: any;
+                        } | undefined;
+                        contextId?: string | undefined;
+                        taskId?: string | undefined;
+                        extensions?: string[] | undefined;
+                        referenceTaskIds?: string[] | undefined;
+                    }[] | undefined;
+                    artifacts?: any[] | undefined;
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        }>;
+    };
+} & {
+    v1: {
+        tasks: import("hono/client").ClientRequest<{
+            $get: {
+                input: {
+                    query: {
+                        status?: "unknown" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "rejected" | "auth-required" | undefined;
+                        contextId?: string | undefined;
+                        pageSize?: string | undefined;
+                        historyLength?: string | undefined;
+                        pageToken?: string | undefined;
+                        lastUpdatedAfter?: string | undefined;
+                        includeArtifacts?: string | undefined;
+                    };
+                };
+                output: {
+                    tasks: {
+                        status: {
+                            state: "unknown" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "rejected" | "auth-required";
+                            message?: {
+                                role: "user" | "agent";
+                                kind: "message";
+                                parts: ({
+                                    text: string;
+                                    kind: "text";
+                                    metadata?: {
+                                        [x: string]: any;
+                                    } | undefined;
+                                } | {
+                                    file: {
+                                        bytes: string;
+                                        mimeType?: string | undefined;
+                                        name?: string | undefined;
+                                    } | {
+                                        uri: string;
+                                        mimeType?: string | undefined;
+                                        name?: string | undefined;
+                                    };
+                                    kind: "file";
+                                    metadata?: {
+                                        [x: string]: any;
+                                    } | undefined;
+                                } | {
+                                    data: {
+                                        [x: string]: any;
+                                    };
+                                    kind: "data";
+                                    metadata?: {
+                                        [x: string]: any;
+                                    } | undefined;
+                                })[];
+                                messageId: string;
+                                metadata?: {
+                                    [x: string]: any;
+                                } | undefined;
+                                contextId?: string | undefined;
+                                taskId?: string | undefined;
+                                extensions?: string[] | undefined;
+                                referenceTaskIds?: string[] | undefined;
+                            } | undefined;
+                            timestamp?: string | undefined;
+                        };
+                        id: string;
+                        kind: "task";
+                        contextId: string;
+                        metadata?: {
+                            [x: string]: any;
+                        } | undefined;
+                        history?: {
+                            role: "user" | "agent";
+                            kind: "message";
+                            parts: ({
+                                text: string;
+                                kind: "text";
+                                metadata?: {
+                                    [x: string]: any;
+                                } | undefined;
+                            } | {
+                                file: {
+                                    bytes: string;
+                                    mimeType?: string | undefined;
+                                    name?: string | undefined;
+                                } | {
+                                    uri: string;
+                                    mimeType?: string | undefined;
+                                    name?: string | undefined;
+                                };
+                                kind: "file";
+                                metadata?: {
+                                    [x: string]: any;
+                                } | undefined;
+                            } | {
+                                data: {
+                                    [x: string]: any;
+                                };
+                                kind: "data";
+                                metadata?: {
+                                    [x: string]: any;
+                                } | undefined;
+                            })[];
+                            messageId: string;
+                            metadata?: {
+                                [x: string]: any;
+                            } | undefined;
+                            contextId?: string | undefined;
+                            taskId?: string | undefined;
+                            extensions?: string[] | undefined;
+                            referenceTaskIds?: string[] | undefined;
+                        }[] | undefined;
+                        artifacts?: any[] | undefined;
+                    }[];
+                    totalSize: number;
+                    pageSize: number;
+                    nextPageToken: string;
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+        }>;
+    };
+} & {
+    v1: {
+        tasks: {
+            ":id": import("hono/client").ClientRequest<{
+                $get: {
+                    input: {
+                        param: {
+                            id: string;
+                        };
+                    };
+                    output: {};
+                    outputFormat: string;
+                    status: 404;
+                } | {
+                    input: {
+                        param: {
+                            id: string;
+                        };
+                    };
+                    output: {
+                        status: {
+                            state: "unknown" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "rejected" | "auth-required";
+                            message?: {
+                                role: "user" | "agent";
+                                kind: "message";
+                                parts: ({
+                                    text: string;
+                                    kind: "text";
+                                    metadata?: {
+                                        [x: string]: any;
+                                    } | undefined;
+                                } | {
+                                    file: {
+                                        bytes: string;
+                                        mimeType?: string | undefined;
+                                        name?: string | undefined;
+                                    } | {
+                                        uri: string;
+                                        mimeType?: string | undefined;
+                                        name?: string | undefined;
+                                    };
+                                    kind: "file";
+                                    metadata?: {
+                                        [x: string]: any;
+                                    } | undefined;
+                                } | {
+                                    data: {
+                                        [x: string]: any;
+                                    };
+                                    kind: "data";
+                                    metadata?: {
+                                        [x: string]: any;
+                                    } | undefined;
+                                })[];
+                                messageId: string;
+                                metadata?: {
+                                    [x: string]: any;
+                                } | undefined;
+                                contextId?: string | undefined;
+                                taskId?: string | undefined;
+                                extensions?: string[] | undefined;
+                                referenceTaskIds?: string[] | undefined;
+                            } | undefined;
+                            timestamp?: string | undefined;
+                        };
+                        id: string;
+                        kind: "task";
+                        contextId: string;
+                        metadata?: {
+                            [x: string]: any;
+                        } | undefined;
+                        history?: {
+                            role: "user" | "agent";
+                            kind: "message";
+                            parts: ({
+                                text: string;
+                                kind: "text";
+                                metadata?: {
+                                    [x: string]: any;
+                                } | undefined;
+                            } | {
+                                file: {
+                                    bytes: string;
+                                    mimeType?: string | undefined;
+                                    name?: string | undefined;
+                                } | {
+                                    uri: string;
+                                    mimeType?: string | undefined;
+                                    name?: string | undefined;
+                                };
+                                kind: "file";
+                                metadata?: {
+                                    [x: string]: any;
+                                } | undefined;
+                            } | {
+                                data: {
+                                    [x: string]: any;
+                                };
+                                kind: "data";
+                                metadata?: {
+                                    [x: string]: any;
+                                } | undefined;
+                            })[];
+                            messageId: string;
+                            metadata?: {
+                                [x: string]: any;
+                            } | undefined;
+                            contextId?: string | undefined;
+                            taskId?: string | undefined;
+                            extensions?: string[] | undefined;
+                            referenceTaskIds?: string[] | undefined;
+                        }[] | undefined;
+                        artifacts?: any[] | undefined;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        tasks: {
+            ":id:cancel": import("hono/client").ClientRequest<{
+                $post: {
+                    input: {
+                        param: {
+                            id: string;
+                        };
+                    };
+                    output: {};
+                    outputFormat: string;
+                    status: 404;
+                } | {
+                    input: {
+                        param: {
+                            id: string;
+                        };
+                    };
+                    output: {
+                        status: {
+                            state: "unknown" | "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "rejected" | "auth-required";
+                            message?: {
+                                role: "user" | "agent";
+                                kind: "message";
+                                parts: ({
+                                    text: string;
+                                    kind: "text";
+                                    metadata?: {
+                                        [x: string]: any;
+                                    } | undefined;
+                                } | {
+                                    file: {
+                                        bytes: string;
+                                        mimeType?: string | undefined;
+                                        name?: string | undefined;
+                                    } | {
+                                        uri: string;
+                                        mimeType?: string | undefined;
+                                        name?: string | undefined;
+                                    };
+                                    kind: "file";
+                                    metadata?: {
+                                        [x: string]: any;
+                                    } | undefined;
+                                } | {
+                                    data: {
+                                        [x: string]: any;
+                                    };
+                                    kind: "data";
+                                    metadata?: {
+                                        [x: string]: any;
+                                    } | undefined;
+                                })[];
+                                messageId: string;
+                                metadata?: {
+                                    [x: string]: any;
+                                } | undefined;
+                                contextId?: string | undefined;
+                                taskId?: string | undefined;
+                                extensions?: string[] | undefined;
+                                referenceTaskIds?: string[] | undefined;
+                            } | undefined;
+                            timestamp?: string | undefined;
+                        };
+                        id: string;
+                        kind: "task";
+                        contextId: string;
+                        metadata?: {
+                            [x: string]: any;
+                        } | undefined;
+                        history?: {
+                            role: "user" | "agent";
+                            kind: "message";
+                            parts: ({
+                                text: string;
+                                kind: "text";
+                                metadata?: {
+                                    [x: string]: any;
+                                } | undefined;
+                            } | {
+                                file: {
+                                    bytes: string;
+                                    mimeType?: string | undefined;
+                                    name?: string | undefined;
+                                } | {
+                                    uri: string;
+                                    mimeType?: string | undefined;
+                                    name?: string | undefined;
+                                };
+                                kind: "file";
+                                metadata?: {
+                                    [x: string]: any;
+                                } | undefined;
+                            } | {
+                                data: {
+                                    [x: string]: any;
+                                };
+                                kind: "data";
+                                metadata?: {
+                                    [x: string]: any;
+                                } | undefined;
+                            })[];
+                            messageId: string;
+                            metadata?: {
+                                [x: string]: any;
+                            } | undefined;
+                            contextId?: string | undefined;
+                            taskId?: string | undefined;
+                            extensions?: string[] | undefined;
+                            referenceTaskIds?: string[] | undefined;
+                        }[] | undefined;
+                        artifacts?: any[] | undefined;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+            }>;
+        };
+    };
+};
+export * from './streaming.js';
+//# sourceMappingURL=client.d.ts.map