@cogitator-ai/tetsu 0.1.0

package/dist/controller.d.ts

@@ -0,0 +1,804 @@
+import type { Message } from '@cogitator-ai/types';
+import type { z } from 'zod';
+import type { CogitatorDeps } from './types.js';
+/**
+ * The Cogitator HTTP API as a Tetsu controller.
+ *
+ * Mount it like any controller, usually under a group:
+ *
+ * @example
+ * ```ts
+ * const app = createApp({
+ *   routes: [
+ *     group('/cogitator', { children: [cogitatorController({ cogitator, agents: { chat } })] }),
+ *     docs({ info: { title: 'Agents', version: '1.0.0' } }),
+ *   ],
+ * });
+ *
+ * Bun.serve({ ...app, port: 3000 });
+ * ```
+ */
+export declare const cogitatorController: (deps: CogitatorDeps) => {
+    socket?: import("@tetsujs/core").WsDef<`/${string}`, {
+        readonly message: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"ping">;
+            id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"stop">;
+            id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"run">;
+            id: z.ZodOptional<z.ZodString>;
+            payload: z.ZodObject<{
+                type: z.ZodEnum<{
+                    agent: "agent";
+                    workflow: "workflow";
+                    swarm: "swarm";
+                }>;
+                name: z.ZodString;
+                input: z.ZodString;
+                context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                threadId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "type">;
+    }, {
+        readonly beforeParse: readonly [import("@tetsujs/core").Hook<"beforeParse", import("@tetsujs/core").BaseCtx & {
+            readonly params: {
+                [x: string]: string;
+            };
+        }, Pick<import("./auth.js").CallerFields, "cogitatorAuth">>];
+    }> | undefined;
+    health: import("@tetsujs/core").RouteDef<"/health", {
+        readonly response: z.ZodObject<{
+            status: z.ZodLiteral<"ok">;
+            uptime: z.ZodNumber;
+            timestamp: z.ZodNumber;
+        }, z.core.$strip>;
+    }, {
+        readonly onError: readonly [import("@tetsujs/core").Hook<"onError", import("@tetsujs/core").BaseCtx & {
+            readonly error: unknown;
+        }, unknown>];
+    }, undefined, "GET", {
+        status: "ok";
+        uptime: number;
+        timestamp: number;
+    }, false>;
+    ready: import("@tetsujs/core").RouteDef<"/ready", {
+        readonly response: z.ZodObject<{
+            status: z.ZodLiteral<"ok">;
+        }, z.core.$strip>;
+    }, {
+        readonly onError: readonly [import("@tetsujs/core").Hook<"onError", import("@tetsujs/core").BaseCtx & {
+            readonly error: unknown;
+        }, unknown>];
+    }, undefined, "GET", {
+        status: "ok";
+    }, false>;
+    listAgents: import("@tetsujs/core").RouteDef<"/agents", {
+        readonly response: z.ZodObject<{
+            agents: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                tools: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, {
+        readonly beforeParse: readonly [import("@tetsujs/core").Hook<"beforeParse", import("@tetsujs/core").BaseCtx & {
+            readonly params: {
+                [x: string]: string;
+            };
+        }, Pick<import("./auth.js").CallerFields, "cogitatorAuth">>];
+        readonly onError: readonly [import("@tetsujs/core").Hook<"onError", import("@tetsujs/core").BaseCtx & {
+            readonly error: unknown;
+        }, unknown>];
+    }, undefined, "GET", {
+        agents: {
+            name: string;
+            tools: string[];
+            description?: string | undefined;
+        }[];
+    }, false>;
+    runAgent: import("@tetsujs/core").RouteDef<"/agents/:name/run", {
+        readonly params: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        readonly body: z.ZodObject<{
+            input: z.ZodString;
+            context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            threadId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly response: {
+            readonly 200: z.ZodObject<{
+                output: z.ZodString;
+                structured: z.ZodOptional<z.ZodUnknown>;
+                threadId: z.ZodString;
+                usage: z.ZodObject<{
+                    inputTokens: z.ZodNumber;
+                    outputTokens: z.ZodNumber;
+                    totalTokens: z.ZodNumber;
+                }, z.core.$strip>;
+                toolCalls: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    name: z.ZodString;
+                    arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            readonly 403: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodLiteral<"THREAD_FORBIDDEN">;
+            }, z.core.$strip>;
+            readonly 404: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 400: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 409: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 429: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 500: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 502: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 503: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 504: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 507: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+        };
+    }, {
+        readonly beforeParse: readonly [import("@tetsujs/core").Hook<"beforeParse", import("@tetsujs/core").BaseCtx & {
+            readonly params: {
+                [x: string]: string;
+            };
+        }, Pick<import("./auth.js").CallerFields, "cogitatorAuth">>];
+        readonly onError: readonly [import("@tetsujs/core").Hook<"onError", import("@tetsujs/core").BaseCtx & {
+            readonly error: unknown;
+        }, unknown>];
+    }, undefined, "POST", Promise<{
+        output: string;
+        threadId: string;
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+        };
+        toolCalls: {
+            id: string;
+            name: string;
+            arguments: Record<string, unknown>;
+        }[];
+        structured?: unknown;
+    }>, false>;
+    streamAgent: import("@tetsujs/core").RouteDef<"/agents/:name/stream", {
+        readonly params: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        readonly body: z.ZodObject<{
+            input: z.ZodString;
+            context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            threadId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly response: {
+            readonly 403: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodLiteral<"THREAD_FORBIDDEN">;
+            }, z.core.$strip>;
+            readonly 404: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodLiteral<"AGENT_NOT_FOUND">;
+            }, z.core.$strip>;
+        };
+    }, {
+        readonly beforeParse: readonly [import("@tetsujs/core").Hook<"beforeParse", import("@tetsujs/core").BaseCtx & {
+            readonly params: {
+                [x: string]: string;
+            };
+        }, Pick<import("./auth.js").CallerFields, "cogitatorAuth">>];
+        readonly onError: readonly [import("@tetsujs/core").Hook<"onError", import("@tetsujs/core").BaseCtx & {
+            readonly error: unknown;
+        }, unknown>];
+    }, undefined, "POST", Promise<Response>, false>;
+    getThread: import("@tetsujs/core").RouteDef<"/threads/:id", {
+        readonly params: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        readonly response: {
+            readonly 200: z.ZodObject<{
+                id: z.ZodString;
+                messages: z.ZodArray<z.ZodObject<{
+                    role: z.ZodEnum<{
+                        user: "user";
+                        assistant: "assistant";
+                        system: "system";
+                        tool: "tool";
+                    }>;
+                    content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                        type: z.ZodLiteral<"text">;
+                        text: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"image_url">;
+                        image_url: z.ZodObject<{
+                            url: z.ZodString;
+                            detail: z.ZodOptional<z.ZodEnum<{
+                                auto: "auto";
+                                low: "low";
+                                high: "high";
+                            }>>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"image_base64">;
+                        image_base64: z.ZodObject<{
+                            data: z.ZodString;
+                            media_type: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>]>>]>;
+                    name: z.ZodOptional<z.ZodString>;
+                    toolCallId: z.ZodOptional<z.ZodString>;
+                    toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        name: z.ZodString;
+                        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+            }, z.core.$strip>;
+            readonly 403: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodLiteral<"THREAD_FORBIDDEN">;
+            }, z.core.$strip>;
+            readonly 503: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodLiteral<"MEMORY_NOT_CONFIGURED">;
+            }, z.core.$strip>;
+        };
+    }, {
+        readonly beforeParse: readonly [import("@tetsujs/core").Hook<"beforeParse", import("@tetsujs/core").BaseCtx & {
+            readonly params: {
+                [x: string]: string;
+            };
+        }, Pick<import("./auth.js").CallerFields, "cogitatorAuth">>];
+        readonly onError: readonly [import("@tetsujs/core").Hook<"onError", import("@tetsujs/core").BaseCtx & {
+            readonly error: unknown;
+        }, unknown>];
+    }, undefined, "GET", Promise<{
+        id: string;
+        messages: Message[];
+        createdAt: number;
+        updatedAt: number;
+    }>, false>;
+    addThreadMessage: import("@tetsujs/core").RouteDef<"/threads/:id/messages", {
+        readonly params: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        readonly body: z.ZodObject<{
+            role: z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+                system: "system";
+            }>;
+            content: z.ZodString;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+        readonly response: {
+            readonly 201: z.ZodObject<{
+                success: z.ZodLiteral<true>;
+            }, z.core.$strip>;
+            readonly 403: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodLiteral<"THREAD_FORBIDDEN">;
+            }, z.core.$strip>;
+            readonly 503: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodLiteral<"MEMORY_NOT_CONFIGURED">;
+            }, z.core.$strip>;
+        };
+    }, {
+        readonly beforeParse: readonly [import("@tetsujs/core").Hook<"beforeParse", import("@tetsujs/core").BaseCtx & {
+            readonly params: {
+                [x: string]: string;
+            };
+        }, Pick<import("./auth.js").CallerFields, "cogitatorAuth">>];
+        readonly onError: readonly [import("@tetsujs/core").Hook<"onError", import("@tetsujs/core").BaseCtx & {
+            readonly error: unknown;
+        }, unknown>];
+    }, undefined, "POST", Promise<{
+        success: true;
+    }>, false>;
+    deleteThread: import("@tetsujs/core").RouteDef<"/threads/:id", {
+        readonly params: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>;
+        readonly response: {
+            readonly 204: null;
+            readonly 403: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodLiteral<"THREAD_FORBIDDEN">;
+            }, z.core.$strip>;
+            readonly 503: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodLiteral<"MEMORY_NOT_CONFIGURED">;
+            }, z.core.$strip>;
+        };
+    }, {
+        readonly beforeParse: readonly [import("@tetsujs/core").Hook<"beforeParse", import("@tetsujs/core").BaseCtx & {
+            readonly params: {
+                [x: string]: string;
+            };
+        }, Pick<import("./auth.js").CallerFields, "cogitatorAuth">>];
+        readonly onError: readonly [import("@tetsujs/core").Hook<"onError", import("@tetsujs/core").BaseCtx & {
+            readonly error: unknown;
+        }, unknown>];
+    }, undefined, "DELETE", Promise<void>, false>;
+    listTools: import("@tetsujs/core").RouteDef<"/tools", {
+        readonly response: z.ZodObject<{
+            tools: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, {
+        readonly beforeParse: readonly [import("@tetsujs/core").Hook<"beforeParse", import("@tetsujs/core").BaseCtx & {
+            readonly params: {
+                [x: string]: string;
+            };
+        }, Pick<import("./auth.js").CallerFields, "cogitatorAuth">>];
+        readonly onError: readonly [import("@tetsujs/core").Hook<"onError", import("@tetsujs/core").BaseCtx & {
+            readonly error: unknown;
+        }, unknown>];
+    }, undefined, "GET", {
+        tools: {
+            name: string;
+            parameters: Record<string, unknown>;
+            description?: string | undefined;
+        }[];
+    }, false>;
+    listWorkflows: import("@tetsujs/core").RouteDef<"/workflows", {
+        readonly response: z.ZodObject<{
+            workflows: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                entryPoint: z.ZodString;
+                nodes: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, {
+        readonly beforeParse: readonly [import("@tetsujs/core").Hook<"beforeParse", import("@tetsujs/core").BaseCtx & {
+            readonly params: {
+                [x: string]: string;
+            };
+        }, Pick<import("./auth.js").CallerFields, "cogitatorAuth">>];
+        readonly onError: readonly [import("@tetsujs/core").Hook<"onError", import("@tetsujs/core").BaseCtx & {
+            readonly error: unknown;
+        }, unknown>];
+    }, undefined, "GET", {
+        workflows: {
+            name: string;
+            entryPoint: string;
+            nodes: string[];
+        }[];
+    }, false>;
+    runWorkflow: import("@tetsujs/core").RouteDef<"/workflows/:name/run", {
+        readonly params: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        readonly body: z.ZodObject<{
+            input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            options: z.ZodOptional<z.ZodObject<{
+                maxConcurrency: z.ZodOptional<z.ZodNumber>;
+                maxIterations: z.ZodOptional<z.ZodNumber>;
+                checkpoint: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        readonly response: {
+            readonly 200: z.ZodObject<{
+                workflowId: z.ZodString;
+                workflowName: z.ZodString;
+                state: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                duration: z.ZodNumber;
+                nodeResults: z.ZodRecord<z.ZodString, z.ZodObject<{
+                    output: z.ZodUnknown;
+                    duration: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            readonly 404: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 501: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 400: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 409: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 429: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 500: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 502: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 503: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 504: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 507: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+        };
+    }, {
+        readonly beforeParse: readonly [import("@tetsujs/core").Hook<"beforeParse", import("@tetsujs/core").BaseCtx & {
+            readonly params: {
+                [x: string]: string;
+            };
+        }, Pick<import("./auth.js").CallerFields, "cogitatorAuth">>];
+        readonly onError: readonly [import("@tetsujs/core").Hook<"onError", import("@tetsujs/core").BaseCtx & {
+            readonly error: unknown;
+        }, unknown>];
+    }, undefined, "POST", Promise<{
+        workflowId: string;
+        workflowName: string;
+        state: Record<string, unknown>;
+        duration: number;
+        nodeResults: Record<string, {
+            output: unknown;
+            duration: number;
+        }>;
+    }>, false>;
+    streamWorkflow: import("@tetsujs/core").RouteDef<"/workflows/:name/stream", {
+        readonly params: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        readonly body: z.ZodObject<{
+            input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            options: z.ZodOptional<z.ZodObject<{
+                maxConcurrency: z.ZodOptional<z.ZodNumber>;
+                maxIterations: z.ZodOptional<z.ZodNumber>;
+                checkpoint: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        readonly response: {
+            readonly 404: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodLiteral<"WORKFLOW_NOT_FOUND">;
+            }, z.core.$strip>;
+        };
+    }, {
+        readonly beforeParse: readonly [import("@tetsujs/core").Hook<"beforeParse", import("@tetsujs/core").BaseCtx & {
+            readonly params: {
+                [x: string]: string;
+            };
+        }, Pick<import("./auth.js").CallerFields, "cogitatorAuth">>];
+        readonly onError: readonly [import("@tetsujs/core").Hook<"onError", import("@tetsujs/core").BaseCtx & {
+            readonly error: unknown;
+        }, unknown>];
+    }, undefined, "POST", Response, false>;
+    listSwarms: import("@tetsujs/core").RouteDef<"/swarms", {
+        readonly response: z.ZodObject<{
+            swarms: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                strategy: z.ZodString;
+                agents: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, {
+        readonly beforeParse: readonly [import("@tetsujs/core").Hook<"beforeParse", import("@tetsujs/core").BaseCtx & {
+            readonly params: {
+                [x: string]: string;
+            };
+        }, Pick<import("./auth.js").CallerFields, "cogitatorAuth">>];
+        readonly onError: readonly [import("@tetsujs/core").Hook<"onError", import("@tetsujs/core").BaseCtx & {
+            readonly error: unknown;
+        }, unknown>];
+    }, undefined, "GET", {
+        swarms: {
+            name: string;
+            strategy: string;
+            agents: string[];
+        }[];
+    }, false>;
+    runSwarm: import("@tetsujs/core").RouteDef<"/swarms/:name/run", {
+        readonly params: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        readonly body: z.ZodObject<{
+            input: z.ZodString;
+            context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            threadId: z.ZodOptional<z.ZodString>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        readonly response: {
+            readonly 200: z.ZodObject<{
+                swarmId: z.ZodString;
+                swarmName: z.ZodString;
+                strategy: z.ZodString;
+                output: z.ZodUnknown;
+                agentResults: z.ZodRecord<z.ZodString, z.ZodObject<{
+                    output: z.ZodString;
+                    usage: z.ZodObject<{
+                        inputTokens: z.ZodNumber;
+                        outputTokens: z.ZodNumber;
+                        totalTokens: z.ZodNumber;
+                        cost: z.ZodNumber;
+                        duration: z.ZodNumber;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>;
+                usage: z.ZodObject<{
+                    totalTokens: z.ZodNumber;
+                    totalCost: z.ZodNumber;
+                    elapsedTime: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            readonly 403: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodLiteral<"THREAD_FORBIDDEN">;
+            }, z.core.$strip>;
+            readonly 404: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 501: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 400: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 409: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 429: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 500: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 502: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 503: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 504: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+            readonly 507: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodEnum<{
+                    [x: string]: string;
+                }>;
+            }, z.core.$strip>;
+        };
+    }, {
+        readonly beforeParse: readonly [import("@tetsujs/core").Hook<"beforeParse", import("@tetsujs/core").BaseCtx & {
+            readonly params: {
+                [x: string]: string;
+            };
+        }, Pick<import("./auth.js").CallerFields, "cogitatorAuth">>];
+        readonly onError: readonly [import("@tetsujs/core").Hook<"onError", import("@tetsujs/core").BaseCtx & {
+            readonly error: unknown;
+        }, unknown>];
+    }, undefined, "POST", Promise<{
+        swarmId: string;
+        swarmName: string;
+        strategy: string;
+        output: unknown;
+        agentResults: Record<string, {
+            output: string;
+            usage: {
+                inputTokens: number;
+                outputTokens: number;
+                totalTokens: number;
+                cost: number;
+                duration: number;
+            };
+        }>;
+        usage: {
+            totalTokens: number;
+            totalCost: number;
+            elapsedTime: number;
+        };
+    }>, false>;
+    streamSwarm: import("@tetsujs/core").RouteDef<"/swarms/:name/stream", {
+        readonly params: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        readonly body: z.ZodObject<{
+            input: z.ZodString;
+            context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            threadId: z.ZodOptional<z.ZodString>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        readonly response: {
+            readonly 403: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodLiteral<"THREAD_FORBIDDEN">;
+            }, z.core.$strip>;
+            readonly 404: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodLiteral<"SWARM_NOT_FOUND">;
+            }, z.core.$strip>;
+        };
+    }, {
+        readonly beforeParse: readonly [import("@tetsujs/core").Hook<"beforeParse", import("@tetsujs/core").BaseCtx & {
+            readonly params: {
+                [x: string]: string;
+            };
+        }, Pick<import("./auth.js").CallerFields, "cogitatorAuth">>];
+        readonly onError: readonly [import("@tetsujs/core").Hook<"onError", import("@tetsujs/core").BaseCtx & {
+            readonly error: unknown;
+        }, unknown>];
+    }, undefined, "POST", Promise<Response>, false>;
+    getBlackboard: import("@tetsujs/core").RouteDef<"/swarms/:name/blackboard", {
+        readonly params: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        readonly response: {
+            readonly 200: z.ZodObject<{
+                sections: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>;
+            readonly 404: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodLiteral<"SWARM_NOT_FOUND">;
+            }, z.core.$strip>;
+            readonly 409: z.ZodObject<{
+                status: z.ZodNumber;
+                message: z.ZodString;
+                error: z.ZodLiteral<"BLACKBOARD_DISABLED">;
+            }, z.core.$strip>;
+        };
+    }, {
+        readonly beforeParse: readonly [import("@tetsujs/core").Hook<"beforeParse", import("@tetsujs/core").BaseCtx & {
+            readonly params: {
+                [x: string]: string;
+            };
+        }, Pick<import("./auth.js").CallerFields, "cogitatorAuth">>];
+        readonly onError: readonly [import("@tetsujs/core").Hook<"onError", import("@tetsujs/core").BaseCtx & {
+            readonly error: unknown;
+        }, unknown>];
+    }, undefined, "GET", {
+        sections: Record<string, unknown>;
+    }, false>;
+};
+//# sourceMappingURL=controller.d.ts.map