@dexto/server 1.2.5

package/dist/hono/index.d.ts

@@ -0,0 +1,2783 @@
+import { OpenAPIHono } from '@hono/zod-openapi';
+import type { DextoAgent, AgentCard } from '@dexto/core';
+import { type AgentsRouterContext } from './routes/agents.js';
+import { WebhookEventSubscriber } from '../events/webhook-subscriber.js';
+import { A2ASseEventSubscriber } from '../events/a2a-sse-subscriber.js';
+import { ApprovalCoordinator } from '../approval/approval-coordinator.js';
+export type CreateDextoAppOptions = {
+    apiPrefix?: string;
+    getAgent: () => DextoAgent;
+    getAgentCard: () => AgentCard;
+    approvalCoordinator: ApprovalCoordinator;
+    webhookSubscriber: WebhookEventSubscriber;
+    sseSubscriber: A2ASseEventSubscriber;
+    agentsContext?: AgentsRouterContext;
+};
+export declare function createDextoApp(options: CreateDextoAppOptions): OpenAPIHono<import("hono").Env, import("hono/types").MergeSchemaPath<{
+    "/agents": {
+        $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;
+        };
+    };
+} & {
+    "/agents/current": {
+        $get: {
+            input: {};
+            output: {
+                id: string | null;
+                name: string | null;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/agents/install": {
+        $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;
+        };
+    };
+} & {
+    "/agents/switch": {
+        $post: {
+            input: {
+                json: {
+                    id: string;
+                    path?: string | undefined;
+                };
+            };
+            output: {
+                id: string;
+                name: string;
+                switched: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/agents/validate-name": {
+        $post: {
+            input: {
+                json: {
+                    id: string;
+                    path?: string | undefined;
+                };
+            };
+            output: {
+                valid: boolean;
+                message?: string | undefined;
+                conflict?: string | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/agents/uninstall": {
+        $post: {
+            input: {
+                json: {
+                    id: string;
+                    force?: boolean | undefined;
+                };
+            };
+            output: {
+                id: string;
+                uninstalled: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/agents/custom/create": {
+        $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;
+                                priority: number;
+                                source: "resources" | "dateTime" | "memorySummary";
+                                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;
+                            } | {
+                                type: "memory";
+                                id: string;
+                                priority: number;
+                                options?: {
+                                    includeTimestamps?: boolean | undefined;
+                                    includeTags?: boolean | undefined;
+                                    limit?: number | undefined;
+                                    pinnedOnly?: 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;
+                        agentId?: string | undefined;
+                        starterPrompts?: {
+                            prompt: string;
+                            id: string;
+                            description?: string | undefined;
+                            title?: string | undefined;
+                            priority?: number | undefined;
+                            category?: string | undefined;
+                        }[] | 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;
+                        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;
+        };
+    };
+} & {
+    "/agent/path": {
+        $get: {
+            input: {};
+            output: {
+                path: string;
+                name: string;
+                relativePath: string;
+                isDefault: boolean;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/agent/config": {
+        $get: {
+            input: {};
+            output: {
+                path: string;
+                lastModified: string;
+                yaml: string;
+                relativePath: string;
+                warnings: string[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/agent/validate": {
+        $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;
+        };
+    };
+} & {
+    "/agent/config": {
+        $post: {
+            input: {
+                json: {
+                    yaml: string;
+                };
+            };
+            output: {
+                path: string;
+                message: string;
+                ok: true;
+                restarted: boolean;
+                reloaded: boolean;
+                changesApplied: string[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/agent/config/export": {
+        $get: {
+            input: {
+                query: {
+                    sessionId?: string | undefined;
+                };
+            };
+            output: Response;
+            outputFormat: "json";
+            status: import("hono/utils/http-status").StatusCode;
+        };
+    };
+}, "/api"> & import("hono/types").MergeSchemaPath<{
+    "/approvals/:approvalId": {
+        $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"> & import("hono/types").MergeSchemaPath<{
+    "/memory": {
+        $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;
+        };
+    };
+} & {
+    "/memory": {
+        $get: {
+            input: {
+                query: {
+                    tags?: string | undefined;
+                    source?: "system" | "user" | undefined;
+                    limit?: string | undefined;
+                    offset?: string | undefined;
+                    pinned?: string | undefined;
+                };
+            };
+            output: {
+                ok: true;
+                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;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/memory/:id": {
+        $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;
+        };
+    };
+} & {
+    "/memory/:id": {
+        $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;
+        };
+    };
+} & {
+    "/memory/:id": {
+        $delete: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                message: string;
+                ok: true;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/api"> & import("hono/types").MergeSchemaPath<{
+    "/resources": {
+        $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;
+        };
+    };
+} & {
+    "/resources/:resourceId/content": {
+        $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;
+        };
+    };
+} & {
+    "/resources/:resourceId": {
+        $head: {
+            input: {
+                param: {
+                    resourceId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 200;
+        } | {
+            input: {
+                param: {
+                    resourceId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        };
+    };
+}, "/api"> & import("hono/types").MergeSchemaPath<{
+    "/prompts": {
+        $get: {
+            input: {};
+            output: {
+                prompts: {
+                    name: string;
+                    source: "file" | "custom" | "mcp" | "starter";
+                    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;
+        };
+    };
+} & {
+    "/prompts/custom": {
+        $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: "file" | "custom" | "mcp" | "starter";
+                    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;
+        };
+    };
+} & {
+    "/prompts/custom/:name": {
+        $delete: {
+            input: {
+                param: {
+                    name: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 204;
+        };
+    };
+} & {
+    "/prompts/:name": {
+        $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;
+        };
+    };
+} & {
+    "/prompts/:name/resolve": {
+        $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"> & import("hono/types").MergeSchemaPath<{
+    "/webhooks": {
+        $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;
+        };
+    };
+} & {
+    "/webhooks": {
+        $get: {
+            input: {};
+            output: {
+                webhooks: {
+                    id: string;
+                    createdAt: string | number;
+                    url: string;
+                    description?: string | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/webhooks/:webhookId": {
+        $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;
+        };
+    };
+} & {
+    "/webhooks/:webhookId": {
+        $delete: {
+            input: {
+                param: {
+                    webhookId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    webhookId: string;
+                };
+            };
+            output: {
+                status: "removed";
+                webhookId: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/webhooks/:webhookId/test": {
+        $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"> & import("hono/types").MergeSchemaPath<{
+    "/mcp/servers": {
+        $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;
+        };
+    };
+} & {
+    "/mcp/servers": {
+        $get: {
+            input: {};
+            output: {
+                servers: {
+                    status: "error" | "connected" | "disconnected";
+                    id: string;
+                    name: string;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/mcp/servers/:serverId/tools": {
+        $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;
+        };
+    };
+} & {
+    "/mcp/servers/:serverId": {
+        $delete: {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            };
+            output: {
+                status: "disconnected";
+                id: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/mcp/servers/:serverId/restart": {
+        $post: {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    serverId: string;
+                };
+            };
+            output: {
+                status: "restarted";
+                id: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/mcp/servers/:serverId/tools/:toolName/execute": {
+        $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;
+        };
+    };
+} & {
+    "/mcp/servers/:serverId/resources": {
+        $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;
+        };
+    };
+} & {
+    "/mcp/servers/:serverId/resources/:resourceId/content": {
+        $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"> & import("hono/types").MergeSchemaPath<{
+    "/search/messages": {
+        $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;
+        };
+    };
+} & {
+    "/search/sessions": {
+        $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"> & import("hono/types").MergeSchemaPath<{
+    "/sessions": {
+        $get: {
+            input: {};
+            output: {
+                sessions: {
+                    id: string;
+                    createdAt: number | null;
+                    lastActivity: number | null;
+                    messageCount: number;
+                    title?: string | null | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/sessions": {
+        $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;
+        };
+    };
+} & {
+    "/sessions/:sessionId": {
+        $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;
+        };
+    };
+} & {
+    "/sessions/:sessionId/history": {
+        $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;
+        };
+    };
+} & {
+    "/sessions/:sessionId": {
+        $delete: {
+            input: {
+                param: {
+                    sessionId: string;
+                };
+            };
+            output: {
+                status: "deleted";
+                sessionId: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/sessions/:sessionId/cancel": {
+        $post: {
+            input: {
+                param: {
+                    sessionId: string;
+                };
+            };
+            output: {
+                sessionId: string;
+                cancelled: boolean;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/sessions/:sessionId/load": {
+        $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;
+        };
+    };
+} & {
+    "/sessions/:sessionId": {
+        $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;
+        };
+    };
+} & {
+    "/sessions/:sessionId/generate-title": {
+        $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"> & import("hono/types").MergeSchemaPath<{
+    "/llm/current": {
+        $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;
+        };
+    };
+} & {
+    "/llm/catalog": {
+        $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;
+        };
+    };
+} & {
+    "/llm/key": {
+        $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;
+        };
+    };
+} & {
+    "/llm/switch": {
+        $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"> & import("hono/types").MergeSchemaPath<{
+    "/message": {
+        $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;
+        };
+    };
+} & {
+    "/message-sync": {
+        $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;
+        };
+    };
+} & {
+    "/reset": {
+        $post: {
+            input: {
+                json: {
+                    sessionId: string;
+                };
+            };
+            output: {
+                status: string;
+                sessionId: string;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/message-stream": {
+        $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"> & import("hono/types").MergeSchemaPath<{
+    "/greeting": {
+        $get: {
+            input: {
+                query: {
+                    sessionId?: string | undefined;
+                };
+            };
+            output: {
+                greeting?: string | undefined;
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+}, "/api"> & import("hono/types").MergeSchemaPath<{
+    "/v1/message:send": {
+        $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": {
+        $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": {
+        $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": {
+        $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;
+        };
+    };
+}, "/"> & import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema, "/"> & import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {};
+            output: string;
+            outputFormat: "text";
+            status: 200;
+        };
+    };
+}, "/health">, "/">;
+export type AppType = ReturnType<typeof createDextoApp>;
+//# sourceMappingURL=index.d.ts.map