@archon-claw/cli 0.0.2

package/dist/schemas.d.ts

@@ -0,0 +1,899 @@
+import { z } from "zod";
+export declare const modelConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    provider: z.ZodEnum<["anthropic", "openai", "bailian"]>;
+    model: z.ZodString;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    baseURL: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    provider: "anthropic" | "openai" | "bailian";
+    model: string;
+    $schema?: string | undefined;
+    maxTokens?: number | undefined;
+    temperature?: number | undefined;
+    apiKey?: string | undefined;
+    baseURL?: string | undefined;
+}, {
+    provider: "anthropic" | "openai" | "bailian";
+    model: string;
+    $schema?: string | undefined;
+    maxTokens?: number | undefined;
+    temperature?: number | undefined;
+    apiKey?: string | undefined;
+    baseURL?: string | undefined;
+}>;
+export type ModelConfig = z.infer<typeof modelConfigSchema>;
+export declare const jsonSchemaPropertySchema: z.ZodType<JSONSchemaProperty>;
+export interface JSONSchemaProperty {
+    type: "string" | "number" | "boolean" | "array" | "object";
+    description?: string;
+    enum?: (string | number)[];
+    items?: JSONSchemaProperty;
+    properties?: Record<string, JSONSchemaProperty>;
+    required?: string[];
+}
+export declare const jsonSchemaObjectSchema: z.ZodObject<{
+    type: z.ZodLiteral<"object">;
+    properties: z.ZodRecord<z.ZodString, z.ZodType<JSONSchemaProperty, z.ZodTypeDef, JSONSchemaProperty>>;
+    required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "object";
+    properties: Record<string, JSONSchemaProperty>;
+    required?: string[] | undefined;
+}, {
+    type: "object";
+    properties: Record<string, JSONSchemaProperty>;
+    required?: string[] | undefined;
+}>;
+export type JSONSchema = z.infer<typeof jsonSchemaObjectSchema>;
+export declare const toolSchemaSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodString;
+    input_schema: z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+        properties: z.ZodRecord<z.ZodString, z.ZodType<JSONSchemaProperty, z.ZodTypeDef, JSONSchemaProperty>>;
+        required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: "object";
+        properties: Record<string, JSONSchemaProperty>;
+        required?: string[] | undefined;
+    }, {
+        type: "object";
+        properties: Record<string, JSONSchemaProperty>;
+        required?: string[] | undefined;
+    }>;
+    execution_target: z.ZodOptional<z.ZodEnum<["server", "client", "host"]>>;
+    handler: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    description: string;
+    name: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, JSONSchemaProperty>;
+        required?: string[] | undefined;
+    };
+    $schema?: string | undefined;
+    execution_target?: "server" | "client" | "host" | undefined;
+    handler?: string | undefined;
+}, {
+    description: string;
+    name: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, JSONSchemaProperty>;
+        required?: string[] | undefined;
+    };
+    $schema?: string | undefined;
+    execution_target?: "server" | "client" | "host" | undefined;
+    handler?: string | undefined;
+}>, {
+    description: string;
+    name: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, JSONSchemaProperty>;
+        required?: string[] | undefined;
+    };
+    $schema?: string | undefined;
+    execution_target?: "server" | "client" | "host" | undefined;
+    handler?: string | undefined;
+}, {
+    description: string;
+    name: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, JSONSchemaProperty>;
+        required?: string[] | undefined;
+    };
+    $schema?: string | undefined;
+    execution_target?: "server" | "client" | "host" | undefined;
+    handler?: string | undefined;
+}>, {
+    description: string;
+    name: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, JSONSchemaProperty>;
+        required?: string[] | undefined;
+    };
+    $schema?: string | undefined;
+    execution_target?: "server" | "client" | "host" | undefined;
+    handler?: string | undefined;
+}, {
+    description: string;
+    name: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, JSONSchemaProperty>;
+        required?: string[] | undefined;
+    };
+    $schema?: string | undefined;
+    execution_target?: "server" | "client" | "host" | undefined;
+    handler?: string | undefined;
+}>;
+export type ToolSchema = z.infer<typeof toolSchemaSchema>;
+export declare const datasetSchema: z.ZodArray<z.ZodUnknown, "many">;
+export declare const agentSkillFrontmatterSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    description: string;
+    name: string;
+}, {
+    description: string;
+    name: string;
+}>;
+export declare const assertionTypeSchema: z.ZodEnum<["contains", "not-contains", "regex", "length-min", "length-max", "json-valid", "tool-called", "tool-not-called", "tool-called-with"]>;
+export type AssertionType = z.infer<typeof assertionTypeSchema>;
+export declare const assertionSchema: z.ZodObject<{
+    type: z.ZodEnum<["contains", "not-contains", "regex", "length-min", "length-max", "json-valid", "tool-called", "tool-not-called", "tool-called-with"]>;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+}, {
+    value: string;
+    type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+}>;
+export type Assertion = z.infer<typeof assertionSchema>;
+export declare const evalTurnToolCallSchema: z.ZodObject<{
+    name: z.ZodString;
+    args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    result: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    args: Record<string, unknown>;
+    result?: unknown;
+}, {
+    name: string;
+    args: Record<string, unknown>;
+    result?: unknown;
+}>;
+export type EvalTurnToolCall = z.infer<typeof evalTurnToolCallSchema>;
+export declare const evalTurnSchema: z.ZodObject<{
+    role: z.ZodEnum<["user", "assistant"]>;
+    content: z.ZodString;
+    assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["contains", "not-contains", "regex", "length-min", "length-max", "json-valid", "tool-called", "tool-not-called", "tool-called-with"]>;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+    }, {
+        value: string;
+        type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+    }>, "many">>;
+    judge: z.ZodOptional<z.ZodBoolean>;
+    expectedOutput: z.ZodOptional<z.ZodString>;
+    toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        result: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        args: Record<string, unknown>;
+        result?: unknown;
+    }, {
+        name: string;
+        args: Record<string, unknown>;
+        result?: unknown;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    role: "user" | "assistant";
+    content: string;
+    assertions?: {
+        value: string;
+        type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+    }[] | undefined;
+    judge?: boolean | undefined;
+    expectedOutput?: string | undefined;
+    toolCalls?: {
+        name: string;
+        args: Record<string, unknown>;
+        result?: unknown;
+    }[] | undefined;
+}, {
+    role: "user" | "assistant";
+    content: string;
+    assertions?: {
+        value: string;
+        type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+    }[] | undefined;
+    judge?: boolean | undefined;
+    expectedOutput?: string | undefined;
+    toolCalls?: {
+        name: string;
+        args: Record<string, unknown>;
+        result?: unknown;
+    }[] | undefined;
+}>;
+export type EvalTurn = z.infer<typeof evalTurnSchema>;
+export declare const evalModeSchema: z.ZodEnum<["single", "injected", "sequential"]>;
+export type EvalMode = z.infer<typeof evalModeSchema>;
+export declare const evalCaseSchema: z.ZodObject<{
+    name: z.ZodString;
+    mode: z.ZodEnum<["single", "injected", "sequential"]>;
+    turns: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<["user", "assistant"]>;
+        content: z.ZodString;
+        assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["contains", "not-contains", "regex", "length-min", "length-max", "json-valid", "tool-called", "tool-not-called", "tool-called-with"]>;
+            value: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+        }, {
+            value: string;
+            type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+        }>, "many">>;
+        judge: z.ZodOptional<z.ZodBoolean>;
+        expectedOutput: z.ZodOptional<z.ZodString>;
+        toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            result: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            args: Record<string, unknown>;
+            result?: unknown;
+        }, {
+            name: string;
+            args: Record<string, unknown>;
+            result?: unknown;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        role: "user" | "assistant";
+        content: string;
+        assertions?: {
+            value: string;
+            type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+        }[] | undefined;
+        judge?: boolean | undefined;
+        expectedOutput?: string | undefined;
+        toolCalls?: {
+            name: string;
+            args: Record<string, unknown>;
+            result?: unknown;
+        }[] | undefined;
+    }, {
+        role: "user" | "assistant";
+        content: string;
+        assertions?: {
+            value: string;
+            type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+        }[] | undefined;
+        judge?: boolean | undefined;
+        expectedOutput?: string | undefined;
+        toolCalls?: {
+            name: string;
+            args: Record<string, unknown>;
+            result?: unknown;
+        }[] | undefined;
+    }>, "many">;
+    assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["contains", "not-contains", "regex", "length-min", "length-max", "json-valid", "tool-called", "tool-not-called", "tool-called-with"]>;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+    }, {
+        value: string;
+        type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+    }>, "many">>;
+    expectedOutput: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    judge: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    mode: "single" | "injected" | "sequential";
+    turns: {
+        role: "user" | "assistant";
+        content: string;
+        assertions?: {
+            value: string;
+            type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+        }[] | undefined;
+        judge?: boolean | undefined;
+        expectedOutput?: string | undefined;
+        toolCalls?: {
+            name: string;
+            args: Record<string, unknown>;
+            result?: unknown;
+        }[] | undefined;
+    }[];
+    assertions?: {
+        value: string;
+        type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+    }[] | undefined;
+    judge?: string | undefined;
+    expectedOutput?: string | undefined;
+    tags?: string[] | undefined;
+    tools?: string[] | undefined;
+}, {
+    name: string;
+    mode: "single" | "injected" | "sequential";
+    turns: {
+        role: "user" | "assistant";
+        content: string;
+        assertions?: {
+            value: string;
+            type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+        }[] | undefined;
+        judge?: boolean | undefined;
+        expectedOutput?: string | undefined;
+        toolCalls?: {
+            name: string;
+            args: Record<string, unknown>;
+            result?: unknown;
+        }[] | undefined;
+    }[];
+    assertions?: {
+        value: string;
+        type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+    }[] | undefined;
+    judge?: string | undefined;
+    expectedOutput?: string | undefined;
+    tags?: string[] | undefined;
+    tools?: string[] | undefined;
+}>;
+export type EvalCase = z.infer<typeof evalCaseSchema>;
+export declare const evalFileSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    cases: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        mode: z.ZodEnum<["single", "injected", "sequential"]>;
+        turns: z.ZodArray<z.ZodObject<{
+            role: z.ZodEnum<["user", "assistant"]>;
+            content: z.ZodString;
+            assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<["contains", "not-contains", "regex", "length-min", "length-max", "json-valid", "tool-called", "tool-not-called", "tool-called-with"]>;
+                value: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                value: string;
+                type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+            }, {
+                value: string;
+                type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+            }>, "many">>;
+            judge: z.ZodOptional<z.ZodBoolean>;
+            expectedOutput: z.ZodOptional<z.ZodString>;
+            toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                result: z.ZodUnknown;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                args: Record<string, unknown>;
+                result?: unknown;
+            }, {
+                name: string;
+                args: Record<string, unknown>;
+                result?: unknown;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            role: "user" | "assistant";
+            content: string;
+            assertions?: {
+                value: string;
+                type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+            }[] | undefined;
+            judge?: boolean | undefined;
+            expectedOutput?: string | undefined;
+            toolCalls?: {
+                name: string;
+                args: Record<string, unknown>;
+                result?: unknown;
+            }[] | undefined;
+        }, {
+            role: "user" | "assistant";
+            content: string;
+            assertions?: {
+                value: string;
+                type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+            }[] | undefined;
+            judge?: boolean | undefined;
+            expectedOutput?: string | undefined;
+            toolCalls?: {
+                name: string;
+                args: Record<string, unknown>;
+                result?: unknown;
+            }[] | undefined;
+        }>, "many">;
+        assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<["contains", "not-contains", "regex", "length-min", "length-max", "json-valid", "tool-called", "tool-not-called", "tool-called-with"]>;
+            value: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+        }, {
+            value: string;
+            type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+        }>, "many">>;
+        expectedOutput: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        judge: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        mode: "single" | "injected" | "sequential";
+        turns: {
+            role: "user" | "assistant";
+            content: string;
+            assertions?: {
+                value: string;
+                type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+            }[] | undefined;
+            judge?: boolean | undefined;
+            expectedOutput?: string | undefined;
+            toolCalls?: {
+                name: string;
+                args: Record<string, unknown>;
+                result?: unknown;
+            }[] | undefined;
+        }[];
+        assertions?: {
+            value: string;
+            type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+        }[] | undefined;
+        judge?: string | undefined;
+        expectedOutput?: string | undefined;
+        tags?: string[] | undefined;
+        tools?: string[] | undefined;
+    }, {
+        name: string;
+        mode: "single" | "injected" | "sequential";
+        turns: {
+            role: "user" | "assistant";
+            content: string;
+            assertions?: {
+                value: string;
+                type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+            }[] | undefined;
+            judge?: boolean | undefined;
+            expectedOutput?: string | undefined;
+            toolCalls?: {
+                name: string;
+                args: Record<string, unknown>;
+                result?: unknown;
+            }[] | undefined;
+        }[];
+        assertions?: {
+            value: string;
+            type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+        }[] | undefined;
+        judge?: string | undefined;
+        expectedOutput?: string | undefined;
+        tags?: string[] | undefined;
+        tools?: string[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    cases: {
+        name: string;
+        mode: "single" | "injected" | "sequential";
+        turns: {
+            role: "user" | "assistant";
+            content: string;
+            assertions?: {
+                value: string;
+                type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+            }[] | undefined;
+            judge?: boolean | undefined;
+            expectedOutput?: string | undefined;
+            toolCalls?: {
+                name: string;
+                args: Record<string, unknown>;
+                result?: unknown;
+            }[] | undefined;
+        }[];
+        assertions?: {
+            value: string;
+            type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+        }[] | undefined;
+        judge?: string | undefined;
+        expectedOutput?: string | undefined;
+        tags?: string[] | undefined;
+        tools?: string[] | undefined;
+    }[];
+    $schema?: string | undefined;
+    description?: string | undefined;
+}, {
+    name: string;
+    cases: {
+        name: string;
+        mode: "single" | "injected" | "sequential";
+        turns: {
+            role: "user" | "assistant";
+            content: string;
+            assertions?: {
+                value: string;
+                type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+            }[] | undefined;
+            judge?: boolean | undefined;
+            expectedOutput?: string | undefined;
+            toolCalls?: {
+                name: string;
+                args: Record<string, unknown>;
+                result?: unknown;
+            }[] | undefined;
+        }[];
+        assertions?: {
+            value: string;
+            type: "contains" | "not-contains" | "regex" | "length-min" | "length-max" | "json-valid" | "tool-called" | "tool-not-called" | "tool-called-with";
+        }[] | undefined;
+        judge?: string | undefined;
+        expectedOutput?: string | undefined;
+        tags?: string[] | undefined;
+        tools?: string[] | undefined;
+    }[];
+    $schema?: string | undefined;
+    description?: string | undefined;
+}>;
+export type EvalFile = z.infer<typeof evalFileSchema>;
+export declare const judgeDimensionSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    weight: z.ZodNumber;
+    type: z.ZodOptional<z.ZodEnum<["numeric", "binary"]>>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    label: string;
+    weight: number;
+    type?: "numeric" | "binary" | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+}, {
+    key: string;
+    label: string;
+    weight: number;
+    type?: "numeric" | "binary" | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+}>;
+export type JudgeDimension = z.infer<typeof judgeDimensionSchema>;
+export declare const judgeConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodObject<{
+        $schema: z.ZodOptional<z.ZodString>;
+        provider: z.ZodEnum<["anthropic", "openai", "bailian"]>;
+        model: z.ZodString;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        apiKey: z.ZodOptional<z.ZodString>;
+        baseURL: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        provider: "anthropic" | "openai" | "bailian";
+        model: string;
+        $schema?: string | undefined;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        apiKey?: string | undefined;
+        baseURL?: string | undefined;
+    }, {
+        provider: "anthropic" | "openai" | "bailian";
+        model: string;
+        $schema?: string | undefined;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        apiKey?: string | undefined;
+        baseURL?: string | undefined;
+    }>>;
+    dimensions: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        weight: z.ZodNumber;
+        type: z.ZodOptional<z.ZodEnum<["numeric", "binary"]>>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        label: string;
+        weight: number;
+        type?: "numeric" | "binary" | undefined;
+        min?: number | undefined;
+        max?: number | undefined;
+    }, {
+        key: string;
+        label: string;
+        weight: number;
+        type?: "numeric" | "binary" | undefined;
+        min?: number | undefined;
+        max?: number | undefined;
+    }>, "many">;
+    promptTemplate: z.ZodOptional<z.ZodString>;
+    turnPromptTemplate: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    dimensions: {
+        key: string;
+        label: string;
+        weight: number;
+        type?: "numeric" | "binary" | undefined;
+        min?: number | undefined;
+        max?: number | undefined;
+    }[];
+    $schema?: string | undefined;
+    model?: {
+        provider: "anthropic" | "openai" | "bailian";
+        model: string;
+        $schema?: string | undefined;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        apiKey?: string | undefined;
+        baseURL?: string | undefined;
+    } | undefined;
+    promptTemplate?: string | undefined;
+    turnPromptTemplate?: string | undefined;
+}, {
+    dimensions: {
+        key: string;
+        label: string;
+        weight: number;
+        type?: "numeric" | "binary" | undefined;
+        min?: number | undefined;
+        max?: number | undefined;
+    }[];
+    $schema?: string | undefined;
+    model?: {
+        provider: "anthropic" | "openai" | "bailian";
+        model: string;
+        $schema?: string | undefined;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        apiKey?: string | undefined;
+        baseURL?: string | undefined;
+    } | undefined;
+    promptTemplate?: string | undefined;
+    turnPromptTemplate?: string | undefined;
+}>;
+export type JudgeConfig = z.infer<typeof judgeConfigSchema>;
+export declare const mcpToolsFilterSchema: z.ZodObject<{
+    include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    rename: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strict", z.ZodTypeAny, {
+    include?: string[] | undefined;
+    exclude?: string[] | undefined;
+    rename?: Record<string, string> | undefined;
+}, {
+    include?: string[] | undefined;
+    exclude?: string[] | undefined;
+    rename?: Record<string, string> | undefined;
+}>;
+export declare const mcpServerConfigSchema: z.ZodEffects<z.ZodObject<{
+    transport: z.ZodOptional<z.ZodEnum<["stdio", "sse", "streamable-http"]>>;
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    cwd: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    tools: z.ZodOptional<z.ZodObject<{
+        include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        rename: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strict", z.ZodTypeAny, {
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+        rename?: Record<string, string> | undefined;
+    }, {
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+        rename?: Record<string, string> | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    args?: string[] | undefined;
+    tools?: {
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+        rename?: Record<string, string> | undefined;
+    } | undefined;
+    transport?: "stdio" | "sse" | "streamable-http" | undefined;
+    command?: string | undefined;
+    env?: Record<string, string> | undefined;
+    cwd?: string | undefined;
+    url?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    enabled?: boolean | undefined;
+    timeout?: number | undefined;
+}, {
+    args?: string[] | undefined;
+    tools?: {
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+        rename?: Record<string, string> | undefined;
+    } | undefined;
+    transport?: "stdio" | "sse" | "streamable-http" | undefined;
+    command?: string | undefined;
+    env?: Record<string, string> | undefined;
+    cwd?: string | undefined;
+    url?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    enabled?: boolean | undefined;
+    timeout?: number | undefined;
+}>, {
+    args?: string[] | undefined;
+    tools?: {
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+        rename?: Record<string, string> | undefined;
+    } | undefined;
+    transport?: "stdio" | "sse" | "streamable-http" | undefined;
+    command?: string | undefined;
+    env?: Record<string, string> | undefined;
+    cwd?: string | undefined;
+    url?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    enabled?: boolean | undefined;
+    timeout?: number | undefined;
+}, {
+    args?: string[] | undefined;
+    tools?: {
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+        rename?: Record<string, string> | undefined;
+    } | undefined;
+    transport?: "stdio" | "sse" | "streamable-http" | undefined;
+    command?: string | undefined;
+    env?: Record<string, string> | undefined;
+    cwd?: string | undefined;
+    url?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    enabled?: boolean | undefined;
+    timeout?: number | undefined;
+}>;
+export declare const mcpConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    mcpServers: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodObject<{
+        transport: z.ZodOptional<z.ZodEnum<["stdio", "sse", "streamable-http"]>>;
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        cwd: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        tools: z.ZodOptional<z.ZodObject<{
+            include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            rename: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "strict", z.ZodTypeAny, {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+            rename?: Record<string, string> | undefined;
+        }, {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+            rename?: Record<string, string> | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        args?: string[] | undefined;
+        tools?: {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+            rename?: Record<string, string> | undefined;
+        } | undefined;
+        transport?: "stdio" | "sse" | "streamable-http" | undefined;
+        command?: string | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        enabled?: boolean | undefined;
+        timeout?: number | undefined;
+    }, {
+        args?: string[] | undefined;
+        tools?: {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+            rename?: Record<string, string> | undefined;
+        } | undefined;
+        transport?: "stdio" | "sse" | "streamable-http" | undefined;
+        command?: string | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        enabled?: boolean | undefined;
+        timeout?: number | undefined;
+    }>, {
+        args?: string[] | undefined;
+        tools?: {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+            rename?: Record<string, string> | undefined;
+        } | undefined;
+        transport?: "stdio" | "sse" | "streamable-http" | undefined;
+        command?: string | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        enabled?: boolean | undefined;
+        timeout?: number | undefined;
+    }, {
+        args?: string[] | undefined;
+        tools?: {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+            rename?: Record<string, string> | undefined;
+        } | undefined;
+        transport?: "stdio" | "sse" | "streamable-http" | undefined;
+        command?: string | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        enabled?: boolean | undefined;
+        timeout?: number | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    mcpServers: Record<string, {
+        args?: string[] | undefined;
+        tools?: {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+            rename?: Record<string, string> | undefined;
+        } | undefined;
+        transport?: "stdio" | "sse" | "streamable-http" | undefined;
+        command?: string | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        enabled?: boolean | undefined;
+        timeout?: number | undefined;
+    }>;
+    $schema?: string | undefined;
+}, {
+    mcpServers: Record<string, {
+        args?: string[] | undefined;
+        tools?: {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+            rename?: Record<string, string> | undefined;
+        } | undefined;
+        transport?: "stdio" | "sse" | "streamable-http" | undefined;
+        command?: string | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        enabled?: boolean | undefined;
+        timeout?: number | undefined;
+    }>;
+    $schema?: string | undefined;
+}>;
+export type McpToolsFilter = z.infer<typeof mcpToolsFilterSchema>;
+export type McpServerConfig = z.infer<typeof mcpServerConfigSchema>;
+export type McpConfig = z.infer<typeof mcpConfigSchema>;