@squadrules/mcp 4.8.6

package/dist/tools/tool-registry.d.ts

@@ -0,0 +1,496 @@
+/**
+ * Canonical KAIROS MCP tool registry — the single source of truth for the tool
+ * surface. MCP `tools/list` registration, the HTTP `/api/<tool>` routes, and the
+ * CLI commands all derive from the same Zod schemas referenced here.
+ *
+ * Kept in its own module (rather than inline in server.ts) so that tests and the
+ * cross-surface parity gates can import the canonical list without pulling in the
+ * full server (no Qdrant/OpenAI side effects at import).
+ */
+export declare const KAIROS_TOOL_REGISTRY: readonly [{
+    readonly name: "activate";
+    readonly title: "Activate the best adapter";
+    readonly uiMeta: {
+        readonly ui: {
+            readonly resourceUri: "ui://kairos/activate-result";
+            readonly visibility: readonly ["model", "app"];
+        };
+        readonly "ui/resourceUri": "ui://kairos/activate-result";
+    };
+    readonly description: string;
+    readonly strictInputSchema: import("zod").ZodObject<{
+        query: import("zod").ZodString;
+        execution_id: import("zod").ZodOptional<import("zod").ZodString>;
+        space: import("zod").ZodOptional<import("zod").ZodString>;
+        space_id: import("zod").ZodOptional<import("zod").ZodString>;
+        max_choices: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>;
+    readonly outputSchema: import("zod").ZodObject<{
+        must_obey: import("zod").ZodBoolean;
+        message: import("zod").ZodString;
+        next_action: import("zod").ZodString;
+        execution_id: import("zod").ZodOptional<import("zod").ZodString>;
+        query: import("zod").ZodString;
+        choices: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            uri: import("zod").ZodString;
+            label: import("zod").ZodString;
+            adapter_name: import("zod").ZodNullable<import("zod").ZodString>;
+            activation_score: import("zod").ZodNullable<import("zod").ZodNumber>;
+            tags: import("zod").ZodArray<import("zod").ZodString>;
+            next_action: import("zod").ZodString;
+            adapter_version: import("zod").ZodNullable<import("zod").ZodString>;
+            activation_patterns: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            space_name: import("zod").ZodNullable<import("zod").ZodString>;
+            slug: import("zod").ZodNullable<import("zod").ZodString>;
+            role: import("zod").ZodLiteral<"match">;
+            forward_first_call: import("zod").ZodObject<{
+                uri: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            linked_artifacts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                slug: import("zod").ZodString;
+                filename: import("zod").ZodString;
+                relative_path: import("zod").ZodNullable<import("zod").ZodString>;
+                download_url: import("zod").ZodString;
+                sha256: import("zod").ZodString;
+                content_type: import("zod").ZodString;
+                materialize: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>>>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            uri: import("zod").ZodString;
+            label: import("zod").ZodString;
+            adapter_name: import("zod").ZodNullable<import("zod").ZodString>;
+            activation_score: import("zod").ZodNullable<import("zod").ZodNumber>;
+            tags: import("zod").ZodArray<import("zod").ZodString>;
+            next_action: import("zod").ZodString;
+            adapter_version: import("zod").ZodNullable<import("zod").ZodString>;
+            activation_patterns: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            space_name: import("zod").ZodNullable<import("zod").ZodString>;
+            slug: import("zod").ZodNullable<import("zod").ZodString>;
+            role: import("zod").ZodLiteral<"refine">;
+            forward_first_call: import("zod").ZodObject<{
+                uri: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            uri: import("zod").ZodString;
+            label: import("zod").ZodString;
+            adapter_name: import("zod").ZodNullable<import("zod").ZodString>;
+            activation_score: import("zod").ZodNullable<import("zod").ZodNumber>;
+            tags: import("zod").ZodArray<import("zod").ZodString>;
+            next_action: import("zod").ZodString;
+            adapter_version: import("zod").ZodNullable<import("zod").ZodString>;
+            activation_patterns: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            space_name: import("zod").ZodNullable<import("zod").ZodString>;
+            slug: import("zod").ZodNullable<import("zod").ZodString>;
+            role: import("zod").ZodLiteral<"create">;
+            forward_first_call: import("zod").ZodNull;
+        }, import("zod/v4/core").$strip>], "role">>;
+        kairos_local_artifact_dir: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        squadrules_local_artifact_dir: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strict>;
+}, {
+    readonly name: "forward";
+    readonly title: "Run adapter forward pass";
+    readonly uiMeta: {
+        readonly ui: {
+            readonly resourceUri: "ui://kairos/forward-result";
+            readonly visibility: readonly ["model", "app"];
+        };
+        readonly "ui/resourceUri": "ui://kairos/forward-result";
+    };
+    readonly description: string;
+    readonly strictInputSchema: import("zod").ZodObject<{
+        uri: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodString]>;
+        solution: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodObject<{
+            type: import("zod").ZodEnum<{
+                tensor: "tensor";
+                shell: "shell";
+                mcp: "mcp";
+                user_input: "user_input";
+                comment: "comment";
+            }>;
+            outcome: import("zod").ZodOptional<import("zod").ZodEnum<{
+                success: "success";
+                failure: "failure";
+                skipped: "skipped";
+            }>>;
+            evidence: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            nonce: import("zod").ZodOptional<import("zod").ZodString>;
+            proof_hash: import("zod").ZodOptional<import("zod").ZodString>;
+            tensor: import("zod").ZodOptional<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                value: import("zod").ZodAny;
+            }, import("zod/v4/core").$strip>>;
+            shell: import("zod").ZodOptional<import("zod").ZodObject<{
+                exit_code: import("zod").ZodNumber;
+                stdout: import("zod").ZodOptional<import("zod").ZodString>;
+                stderr: import("zod").ZodOptional<import("zod").ZodString>;
+                duration_seconds: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
+            mcp: import("zod").ZodOptional<import("zod").ZodObject<{
+                tool_name: import("zod").ZodString;
+                arguments: import("zod").ZodOptional<import("zod").ZodAny>;
+                result: import("zod").ZodAny;
+                success: import("zod").ZodBoolean;
+            }, import("zod/v4/core").$strip>>;
+            user_input: import("zod").ZodOptional<import("zod").ZodObject<{
+                confirmation: import("zod").ZodString;
+                timestamp: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+            comment: import("zod").ZodOptional<import("zod").ZodObject<{
+                text: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>;
+            trace: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>, unknown>>;
+    }, import("zod/v4/core").$strip>;
+    readonly outputSchema: import("zod").ZodObject<{
+        must_obey: import("zod").ZodBoolean;
+        current_layer: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodObject<{
+            uri: import("zod").ZodString;
+            content: import("zod").ZodString;
+            mimeType: import("zod").ZodLiteral<"text/markdown">;
+        }, import("zod/v4/core").$strip>>>;
+        contract: import("zod").ZodObject<{
+            type: import("zod").ZodEnum<{
+                tensor: "tensor";
+                shell: "shell";
+                mcp: "mcp";
+                user_input: "user_input";
+                comment: "comment";
+            }>;
+            required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            nonce: import("zod").ZodOptional<import("zod").ZodString>;
+            proof_hash: import("zod").ZodOptional<import("zod").ZodString>;
+            tensor: import("zod").ZodOptional<import("zod").ZodObject<{
+                required_inputs: import("zod").ZodArray<import("zod").ZodString>;
+                output: import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    type: import("zod").ZodString;
+                    min_length: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    max_length: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    min_items: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    max_items: import("zod").ZodOptional<import("zod").ZodNumber>;
+                }, import("zod/v4/core").$strip>;
+                merge: import("zod").ZodOptional<import("zod").ZodString>;
+                condition: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+            shell: import("zod").ZodOptional<import("zod").ZodObject<{
+                cmd: import("zod").ZodString;
+                timeout_seconds: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+            mcp: import("zod").ZodOptional<import("zod").ZodObject<{
+                tool_name: import("zod").ZodString;
+                arguments: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                expected_result: import("zod").ZodOptional<import("zod").ZodAny>;
+            }, import("zod/v4/core").$strip>>;
+            user_input: import("zod").ZodOptional<import("zod").ZodObject<{
+                prompt: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+            comment: import("zod").ZodOptional<import("zod").ZodObject<{
+                min_length: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+        tensor_in: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        next_action: import("zod").ZodString;
+        proof_hash: import("zod").ZodOptional<import("zod").ZodString>;
+        execution_id: import("zod").ZodOptional<import("zod").ZodString>;
+        message: import("zod").ZodOptional<import("zod").ZodString>;
+        error_code: import("zod").ZodOptional<import("zod").ZodString>;
+        retry_count: import("zod").ZodOptional<import("zod").ZodNumber>;
+        slug_disambiguation_note: import("zod").ZodOptional<import("zod").ZodString>;
+        next_call: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"forward">;
+            args: import("zod").ZodObject<{
+                uri: import("zod").ZodString;
+                solution_template: import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<{
+                        tensor: "tensor";
+                        shell: "shell";
+                        mcp: "mcp";
+                        user_input: "user_input";
+                        comment: "comment";
+                    }>;
+                    outcome: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        success: "success";
+                        failure: "failure";
+                        skipped: "skipped";
+                    }>>;
+                    evidence: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                    tensor: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                    shell: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                    mcp: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                    user_input: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                    comment: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"reward">;
+            args: import("zod").ZodObject<{
+                uri: import("zod").ZodString;
+                outcome_template: import("zod").ZodObject<{
+                    outcome: import("zod").ZodLiteral<"success">;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strip>], "kind">;
+        activation_space_name: import("zod").ZodOptional<import("zod").ZodString>;
+        context_adapter_name: import("zod").ZodOptional<import("zod").ZodString>;
+        current_layer_label: import("zod").ZodOptional<import("zod").ZodString>;
+        adapter_layer_index: import("zod").ZodOptional<import("zod").ZodNumber>;
+        adapter_layer_count: import("zod").ZodOptional<import("zod").ZodNumber>;
+        kairos_local_artifact_dir: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        squadrules_local_artifact_dir: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strict>;
+}, {
+    readonly name: "train";
+    readonly title: "Register a new adapter";
+    readonly description: string;
+    readonly strictInputSchema: import("zod").ZodObject<{
+        content: import("zod").ZodOptional<import("zod").ZodString>;
+        llm_model_id: import("zod").ZodString;
+        force_update: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        protocol_version: import("zod").ZodOptional<import("zod").ZodString>;
+        space: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"personal">, import("zod").ZodString]>>;
+        source_adapter_uri: import("zod").ZodOptional<import("zod").ZodString>;
+        mime: import("zod").ZodOptional<import("zod").ZodString>;
+        artifact_name: import("zod").ZodOptional<import("zod").ZodString>;
+        adapter_uri: import("zod").ZodOptional<import("zod").ZodString>;
+        relative_path: import("zod").ZodOptional<import("zod").ZodString>;
+        review_evidence: import("zod").ZodOptional<import("zod").ZodObject<{
+            verdict_file: import("zod").ZodString;
+            exit_code: import("zod").ZodNumber;
+            stdout: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+    readonly outputSchema: import("zod").ZodObject<{
+        items: import("zod").ZodArray<import("zod").ZodObject<{
+            uri: import("zod").ZodString;
+            layer_uuid: import("zod").ZodOptional<import("zod").ZodString>;
+            artifact_uuid: import("zod").ZodOptional<import("zod").ZodString>;
+            adapter_uri: import("zod").ZodOptional<import("zod").ZodString>;
+            label: import("zod").ZodString;
+            tags: import("zod").ZodArray<import("zod").ZodString>;
+            content_type: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        status: import("zod").ZodLiteral<"stored">;
+    }, import("zod/v4/core").$strict>;
+}, {
+    readonly name: "reward";
+    readonly title: "Record adapter reward";
+    readonly description: string;
+    readonly strictInputSchema: import("zod").ZodObject<{
+        uri: import("zod").ZodString;
+        outcome: import("zod").ZodEnum<{
+            success: "success";
+            failure: "failure";
+        }>;
+        score: import("zod").ZodOptional<import("zod").ZodNumber>;
+        feedback: import("zod").ZodOptional<import("zod").ZodString>;
+        rater: import("zod").ZodOptional<import("zod").ZodString>;
+        rubric_version: import("zod").ZodOptional<import("zod").ZodString>;
+        llm_model_id: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>;
+    readonly outputSchema: import("zod").ZodObject<{
+        results: import("zod").ZodArray<import("zod").ZodObject<{
+            uri: import("zod").ZodString;
+            outcome: import("zod").ZodEnum<{
+                success: "success";
+                failure: "failure";
+            }>;
+            score: import("zod").ZodNullable<import("zod").ZodNumber>;
+            feedback: import("zod").ZodNullable<import("zod").ZodString>;
+            rater: import("zod").ZodNullable<import("zod").ZodString>;
+            rubric_version: import("zod").ZodNullable<import("zod").ZodString>;
+            llm_model_id: import("zod").ZodNullable<import("zod").ZodString>;
+            grader_kind: import("zod").ZodEnum<{
+                unknown: "unknown";
+                human: "human";
+                model: "model";
+            }>;
+            evaluation_label: import("zod").ZodEnum<{
+                gold: "gold";
+                silver: "silver";
+                bronze: "bronze";
+                rejected: "rejected";
+            }>;
+            exportable_for_sft: import("zod").ZodBoolean;
+            exportable_for_preference: import("zod").ZodBoolean;
+            sft_blockers: import("zod").ZodArray<import("zod").ZodEnum<{
+                missing_rubric_version: "missing_rubric_version";
+                missing_evaluator_identity: "missing_evaluator_identity";
+                outcome_not_success: "outcome_not_success";
+                score_below_sft_threshold: "score_below_sft_threshold";
+                score_below_preference_threshold: "score_below_preference_threshold";
+            }>>;
+            preference_blockers: import("zod").ZodArray<import("zod").ZodEnum<{
+                missing_rubric_version: "missing_rubric_version";
+                missing_evaluator_identity: "missing_evaluator_identity";
+                outcome_not_success: "outcome_not_success";
+                score_below_sft_threshold: "score_below_sft_threshold";
+                score_below_preference_threshold: "score_below_preference_threshold";
+            }>>;
+            rated_at: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+        total_rated: import("zod").ZodNumber;
+        total_failed: import("zod").ZodNumber;
+        next_call: import("zod").ZodNull;
+    }, import("zod/v4/core").$strict>;
+}, {
+    readonly name: "tune";
+    readonly title: "Update adapter content";
+    readonly description: string;
+    readonly strictInputSchema: import("zod").ZodObject<{
+        uris: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodString]>>;
+        content: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        updates: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+        space: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"personal">, import("zod").ZodString]>>;
+        review_evidence: import("zod").ZodOptional<import("zod").ZodObject<{
+            verdict_file: import("zod").ZodString;
+            exit_code: import("zod").ZodNumber;
+            stdout: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+    readonly outputSchema: import("zod").ZodObject<{
+        results: import("zod").ZodArray<import("zod").ZodObject<{
+            uri: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodString]>;
+            status: import("zod").ZodEnum<{
+                error: "error";
+                updated: "updated";
+            }>;
+            message: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+        total_updated: import("zod").ZodNumber;
+        total_failed: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strict>;
+}, {
+    readonly name: "delete";
+    readonly title: "Delete KAIROS adapter resource";
+    readonly description: string;
+    readonly strictInputSchema: import("zod").ZodObject<{
+        uris: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodString]>>;
+    }, import("zod/v4/core").$strip>;
+    readonly outputSchema: import("zod").ZodObject<{
+        results: import("zod").ZodArray<import("zod").ZodObject<{
+            uri: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodString]>;
+            status: import("zod").ZodEnum<{
+                error: "error";
+                deleted: "deleted";
+            }>;
+            message: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+        total_deleted: import("zod").ZodNumber;
+        total_failed: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strict>;
+}, {
+    readonly name: "export";
+    readonly title: "Export adapter or training data";
+    readonly description: string;
+    readonly strictInputSchema: import("zod").ZodObject<{
+        uri: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodString, import("zod").ZodString]>>;
+        adapters: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        all_adapters: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        space_name: import("zod").ZodOptional<import("zod").ZodString>;
+        format: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<{
+            skill_zip: "skill_zip";
+            markdown: "markdown";
+            trace_jsonl: "trace_jsonl";
+            reward_jsonl: "reward_jsonl";
+            sft_jsonl: "sft_jsonl";
+            preference_jsonl: "preference_jsonl";
+            source: "source";
+            skill_tree: "skill_tree";
+        }>>>;
+        delivery: import("zod").ZodOptional<import("zod").ZodEnum<{
+            download_ref: "download_ref";
+            inline_base64: "inline_base64";
+        }>>;
+        include_reward: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    }, import("zod/v4/core").$strip>;
+    readonly outputSchema: import("zod").ZodObject<{
+        uri: import("zod").ZodString;
+        format: import("zod").ZodEnum<{
+            skill_zip: "skill_zip";
+            markdown: "markdown";
+            trace_jsonl: "trace_jsonl";
+            reward_jsonl: "reward_jsonl";
+            sft_jsonl: "sft_jsonl";
+            preference_jsonl: "preference_jsonl";
+            source: "source";
+            skill_tree: "skill_tree";
+        }>;
+        content_type: import("zod").ZodString;
+        content: import("zod").ZodString;
+        item_count: import("zod").ZodOptional<import("zod").ZodNumber>;
+        adapter_name: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        adapter_version: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        space_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        space_name: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        space_type: import("zod").ZodOptional<import("zod").ZodEnum<{
+            personal: "personal";
+            group: "group";
+            app: "app";
+            other: "other";
+        }>>;
+        content_encoding: import("zod").ZodOptional<import("zod").ZodEnum<{
+            base64: "base64";
+        }>>;
+        bundle_sha256: import("zod").ZodOptional<import("zod").ZodString>;
+        export_adapter_count: import("zod").ZodOptional<import("zod").ZodNumber>;
+        skill_bundle_manifest: import("zod").ZodOptional<import("zod").ZodString>;
+        download_ref: import("zod").ZodOptional<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            expires_at: import("zod").ZodString;
+            filename: import("zod").ZodOptional<import("zod").ZodString>;
+            content_type: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+}, {
+    readonly name: "spaces";
+    readonly title: "List spaces and adapter counts";
+    readonly uiMeta: {
+        readonly ui: {
+            readonly resourceUri: "ui://kairos/spaces-result";
+            readonly visibility: readonly ["model", "app"];
+        };
+        readonly "ui/resourceUri": "ui://kairos/spaces-result";
+    };
+    readonly description: string;
+    readonly strictInputSchema: import("zod").ZodObject<{
+        include_adapter_titles: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        include_widget_html: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        include_artifacts: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    }, import("zod/v4/core").$strip>;
+    readonly outputSchema: import("zod").ZodObject<{
+        spaces: import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            space_id: import("zod").ZodString;
+            type: import("zod").ZodEnum<{
+                personal: "personal";
+                group: "group";
+                app: "app";
+                other: "other";
+            }>;
+            adapter_count: import("zod").ZodNumber;
+            adapters: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                adapter_id: import("zod").ZodString;
+                title: import("zod").ZodString;
+                layer_count: import("zod").ZodNumber;
+                slug: import("zod").ZodNullable<import("zod").ZodString>;
+                uri: import("zod").ZodString;
+                artifacts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    slug: import("zod").ZodString;
+                    uri: import("zod").ZodString;
+                    uuid_uri: import("zod").ZodString;
+                    content_type: import("zod").ZodString;
+                    sha256: import("zod").ZodString;
+                    relative_path: import("zod").ZodNullable<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>>;
+            }, import("zod/v4/core").$strip>>>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strict>;
+}];
+/** Union of the canonical MCP tool names. */
+export type KairosToolName = (typeof KAIROS_TOOL_REGISTRY)[number]['name'];
+/** Canonical MCP tool names in registration order. */
+export declare const KAIROS_TOOL_NAMES: readonly KairosToolName[];
+//# sourceMappingURL=tool-registry.d.ts.map

package/dist/tools/tool-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-registry.d.ts","sourceRoot":"","sources":["../../src/tools/tool-registry.ts"],"names":[],"mappings":"AAeA;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkEvB,CAAC;AAEX,6CAA6C;AAC7C,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAE3E,sDAAsD;AACtD,eAAO,MAAM,iBAAiB,EAAE,SAAS,cAAc,EAEtD,CAAC"}

package/dist/tools/tool-registry.js

@@ -0,0 +1,86 @@
+import { activateInputSchema, activateOutputSchema } from './activate_schema.js';
+import { deleteInputSchema, deleteOutputSchema } from './delete_schema.js';
+import { exportInputSchema, exportOutputSchema } from './export_schema.js';
+import { forwardInputSchema, forwardOutputSchema } from './forward_schema.js';
+import { rewardInputSchema, rewardOutputSchema } from './reward_schema.js';
+import { spacesInputSchema, spacesOutputSchema } from './spaces_schema.js';
+import { trainInputSchema, trainOutputSchema } from './train_schema.js';
+import { tuneInputSchema, tuneOutputSchema } from './tune_schema.js';
+import { resolveToolDoc } from '../utils/mcp-tool-doc-runtime.js';
+import { KAIROS_ACTIVATE_TOOL_UI_META, KAIROS_FORWARD_TOOL_UI_META, KAIROS_SPACES_TOOL_UI_META } from '../mcp-apps/kairos-ui-constants.js';
+/**
+ * Canonical KAIROS MCP tool registry — the single source of truth for the tool
+ * surface. MCP `tools/list` registration, the HTTP `/api/<tool>` routes, and the
+ * CLI commands all derive from the same Zod schemas referenced here.
+ *
+ * Kept in its own module (rather than inline in server.ts) so that tests and the
+ * cross-surface parity gates can import the canonical list without pulling in the
+ * full server (no Qdrant/OpenAI side effects at import).
+ */
+export const KAIROS_TOOL_REGISTRY = [
+    {
+        name: 'activate',
+        title: 'Activate the best adapter',
+        uiMeta: KAIROS_ACTIVATE_TOOL_UI_META,
+        description: resolveToolDoc('activate') ||
+            'Find the best adapter for the current input and return ranked activation choices.',
+        strictInputSchema: activateInputSchema,
+        outputSchema: activateOutputSchema
+    },
+    {
+        name: 'forward',
+        title: 'Run adapter forward pass',
+        uiMeta: KAIROS_FORWARD_TOOL_UI_META,
+        description: resolveToolDoc('forward') ||
+            'Run the first or next adapter layer. Omit `solution` on the first call in a run.',
+        strictInputSchema: forwardInputSchema,
+        outputSchema: forwardOutputSchema
+    },
+    {
+        name: 'train',
+        title: 'Register a new adapter',
+        description: resolveToolDoc('train') || 'Store a new adapter from markdown.',
+        strictInputSchema: trainInputSchema,
+        outputSchema: trainOutputSchema
+    },
+    {
+        name: 'reward',
+        title: 'Record adapter reward',
+        description: resolveToolDoc('reward') || 'Attach a reward signal after adapter execution completes.',
+        strictInputSchema: rewardInputSchema,
+        outputSchema: rewardOutputSchema
+    },
+    {
+        name: 'tune',
+        title: 'Update adapter content',
+        description: resolveToolDoc('tune') || 'Update adapter layer content.',
+        strictInputSchema: tuneInputSchema,
+        outputSchema: tuneOutputSchema
+    },
+    {
+        name: 'delete',
+        title: 'Delete KAIROS adapter resource',
+        description: resolveToolDoc('delete') || 'Delete an adapter or layer by URI.',
+        strictInputSchema: deleteInputSchema,
+        outputSchema: deleteOutputSchema
+    },
+    {
+        name: 'export',
+        title: 'Export adapter or training data',
+        description: resolveToolDoc('export') || 'Export adapter markdown or training datasets.',
+        strictInputSchema: exportInputSchema,
+        outputSchema: exportOutputSchema
+    },
+    {
+        name: 'spaces',
+        title: 'List spaces and adapter counts',
+        uiMeta: KAIROS_SPACES_TOOL_UI_META,
+        description: resolveToolDoc('spaces') ??
+            "List the agent's available spaces with human-readable names and adapter counts. Optionally include adapter titles and layer counts per space.",
+        strictInputSchema: spacesInputSchema,
+        outputSchema: spacesOutputSchema
+    }
+];
+/** Canonical MCP tool names in registration order. */
+export const KAIROS_TOOL_NAMES = KAIROS_TOOL_REGISTRY.map((tool) => tool.name);
+//# sourceMappingURL=tool-registry.js.map

package/dist/tools/tool-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-registry.js","sourceRoot":"","sources":["../../src/tools/tool-registry.ts"],"names":[],"mappings":"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"}

package/dist/tools/train-artifact-adapter-uri.d.ts

@@ -0,0 +1,3 @@
+import type { QdrantService } from '../services/qdrant/service.js';
+export declare function resolveCanonicalAdapterUriForArtifact(inputAdapterUri: string | undefined, qdrantService: QdrantService | undefined): Promise<string | undefined>;
+//# sourceMappingURL=train-artifact-adapter-uri.d.ts.map

package/dist/tools/train-artifact-adapter-uri.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"train-artifact-adapter-uri.d.ts","sourceRoot":"","sources":["../../src/tools/train-artifact-adapter-uri.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAInE,wBAAsB,qCAAqC,CACzD,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,aAAa,EAAE,aAAa,GAAG,SAAS,GACvC,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CA4B7B"}

package/dist/tools/train-artifact-adapter-uri.js

@@ -0,0 +1,27 @@
+import { assertWireAdapterUri, buildAdapterUri, parseKairosUri } from './kairos-uri.js';
+import { TrainError } from './train-store.js';
+export async function resolveCanonicalAdapterUriForArtifact(inputAdapterUri, qdrantService) {
+    const raw = typeof inputAdapterUri === 'string' ? inputAdapterUri.trim() : '';
+    if (!raw)
+        return undefined;
+    let parsed;
+    try {
+        parsed = parseKairosUri(assertWireAdapterUri(raw));
+    }
+    catch {
+        throw new TrainError('INVALID_ADAPTER_URI', 'adapter_uri must be kairos://adapter/{slug}', {
+            must_obey: true
+        });
+    }
+    if (!qdrantService) {
+        throw new TrainError('ADAPTER_LOOKUP_UNAVAILABLE', 'adapter_uri slug resolution requires adapter storage service availability.', { must_obey: true });
+    }
+    const resolved = await qdrantService.findFirstStepMemoryUuidBySlug(parsed.id);
+    if (!resolved.layerUuid) {
+        throw new TrainError('ADAPTER_NOT_FOUND', `adapter_uri adapter slug "${parsed.id}" was not found.`, {
+            must_obey: true
+        });
+    }
+    return buildAdapterUri(resolved.layerUuid);
+}
+//# sourceMappingURL=train-artifact-adapter-uri.js.map

package/dist/tools/train-artifact-adapter-uri.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"train-artifact-adapter-uri.js","sourceRoot":"","sources":["../../src/tools/train-artifact-adapter-uri.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACxF,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,MAAM,CAAC,KAAK,UAAU,qCAAqC,CACzD,eAAmC,EACnC,aAAwC;IAExC,MAAM,GAAG,GAAG,OAAO,eAAe,KAAK,QAAQ,CAAC,CAAC,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAC9E,IAAI,CAAC,GAAG;QAAE,OAAO,SAAS,CAAC;IAE3B,IAAI,MAAyC,CAAC;IAC9C,IAAI,CAAC;QACH,MAAM,GAAG,cAAc,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC,CAAC;IACrD,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,UAAU,CAAC,qBAAqB,EAAE,6CAA6C,EAAE;YACzF,SAAS,EAAE,IAAI;SAChB,CAAC,CAAC;IACL,CAAC;IAED,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,MAAM,IAAI,UAAU,CAClB,4BAA4B,EAC5B,4EAA4E,EAC5E,EAAE,SAAS,EAAE,IAAI,EAAE,CACpB,CAAC;IACJ,CAAC;IAED,MAAM,QAAQ,GAAG,MAAM,aAAa,CAAC,6BAA6B,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IAC9E,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;QACxB,MAAM,IAAI,UAAU,CAAC,mBAAmB,EAAE,6BAA6B,MAAM,CAAC,EAAE,kBAAkB,EAAE;YAClG,SAAS,EAAE,IAAI;SAChB,CAAC,CAAC;IACL,CAAC;IACD,OAAO,eAAe,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;AAC7C,CAAC"}

package/dist/tools/train-mime.d.ts

@@ -0,0 +1,3 @@
+import type { TrainInput } from './train_schema.js';
+export declare function resolveTrainMime(input: TrainInput): string | undefined;
+//# sourceMappingURL=train-mime.d.ts.map