@actrun_ai/tastekit-core 0.1.0

package/dist/schemas/constitution.d.ts

@@ -0,0 +1,229 @@
+import { z } from 'zod';
+/**
+ * Constitution v1 Schema
+ *
+ * Represents the global taste profile for a single user.
+ * Principles are ordered by priority (1 = highest).
+ */
+export declare const ConstitutionPrincipleSchema: z.ZodObject<{
+    id: z.ZodString;
+    priority: z.ZodNumber;
+    statement: z.ZodString;
+    rationale: z.ZodOptional<z.ZodString>;
+    applies_to: z.ZodArray<z.ZodString, "many">;
+    examples_good: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    examples_bad: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    priority: number;
+    statement: string;
+    applies_to: string[];
+    rationale?: string | undefined;
+    examples_good?: string[] | undefined;
+    examples_bad?: string[] | undefined;
+}, {
+    id: string;
+    priority: number;
+    statement: string;
+    applies_to: string[];
+    rationale?: string | undefined;
+    examples_good?: string[] | undefined;
+    examples_bad?: string[] | undefined;
+}>;
+export declare const ConstitutionToneSchema: z.ZodObject<{
+    voice_keywords: z.ZodArray<z.ZodString, "many">;
+    forbidden_phrases: z.ZodArray<z.ZodString, "many">;
+    formatting_rules: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    voice_keywords: string[];
+    forbidden_phrases: string[];
+    formatting_rules: string[];
+}, {
+    voice_keywords: string[];
+    forbidden_phrases: string[];
+    formatting_rules: string[];
+}>;
+export declare const ConstitutionTradeoffsSchema: z.ZodObject<{
+    accuracy_vs_speed: z.ZodNumber;
+    cost_sensitivity: z.ZodNumber;
+    autonomy_level: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    accuracy_vs_speed: number;
+    cost_sensitivity: number;
+    autonomy_level: number;
+}, {
+    accuracy_vs_speed: number;
+    cost_sensitivity: number;
+    autonomy_level: number;
+}>;
+export declare const ConstitutionEvidencePolicySchema: z.ZodObject<{
+    require_citations_for: z.ZodArray<z.ZodString, "many">;
+    uncertainty_language_rules: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    require_citations_for: string[];
+    uncertainty_language_rules: string[];
+}, {
+    require_citations_for: string[];
+    uncertainty_language_rules: string[];
+}>;
+export declare const ConstitutionTaboosSchema: z.ZodObject<{
+    never_do: z.ZodArray<z.ZodString, "many">;
+    must_escalate: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    never_do: string[];
+    must_escalate: string[];
+}, {
+    never_do: string[];
+    must_escalate: string[];
+}>;
+export declare const ConstitutionV1Schema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"constitution.v1">;
+    generated_at: z.ZodString;
+    generator_version: z.ZodString;
+    user_scope: z.ZodLiteral<"single_user">;
+    principles: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        priority: z.ZodNumber;
+        statement: z.ZodString;
+        rationale: z.ZodOptional<z.ZodString>;
+        applies_to: z.ZodArray<z.ZodString, "many">;
+        examples_good: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        examples_bad: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        priority: number;
+        statement: string;
+        applies_to: string[];
+        rationale?: string | undefined;
+        examples_good?: string[] | undefined;
+        examples_bad?: string[] | undefined;
+    }, {
+        id: string;
+        priority: number;
+        statement: string;
+        applies_to: string[];
+        rationale?: string | undefined;
+        examples_good?: string[] | undefined;
+        examples_bad?: string[] | undefined;
+    }>, "many">;
+    tone: z.ZodObject<{
+        voice_keywords: z.ZodArray<z.ZodString, "many">;
+        forbidden_phrases: z.ZodArray<z.ZodString, "many">;
+        formatting_rules: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        voice_keywords: string[];
+        forbidden_phrases: string[];
+        formatting_rules: string[];
+    }, {
+        voice_keywords: string[];
+        forbidden_phrases: string[];
+        formatting_rules: string[];
+    }>;
+    tradeoffs: z.ZodObject<{
+        accuracy_vs_speed: z.ZodNumber;
+        cost_sensitivity: z.ZodNumber;
+        autonomy_level: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        accuracy_vs_speed: number;
+        cost_sensitivity: number;
+        autonomy_level: number;
+    }, {
+        accuracy_vs_speed: number;
+        cost_sensitivity: number;
+        autonomy_level: number;
+    }>;
+    evidence_policy: z.ZodObject<{
+        require_citations_for: z.ZodArray<z.ZodString, "many">;
+        uncertainty_language_rules: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        require_citations_for: string[];
+        uncertainty_language_rules: string[];
+    }, {
+        require_citations_for: string[];
+        uncertainty_language_rules: string[];
+    }>;
+    taboos: z.ZodObject<{
+        never_do: z.ZodArray<z.ZodString, "many">;
+        must_escalate: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        never_do: string[];
+        must_escalate: string[];
+    }, {
+        never_do: string[];
+        must_escalate: string[];
+    }>;
+    trace_map: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    schema_version: "constitution.v1";
+    generated_at: string;
+    generator_version: string;
+    user_scope: "single_user";
+    principles: {
+        id: string;
+        priority: number;
+        statement: string;
+        applies_to: string[];
+        rationale?: string | undefined;
+        examples_good?: string[] | undefined;
+        examples_bad?: string[] | undefined;
+    }[];
+    tone: {
+        voice_keywords: string[];
+        forbidden_phrases: string[];
+        formatting_rules: string[];
+    };
+    tradeoffs: {
+        accuracy_vs_speed: number;
+        cost_sensitivity: number;
+        autonomy_level: number;
+    };
+    evidence_policy: {
+        require_citations_for: string[];
+        uncertainty_language_rules: string[];
+    };
+    taboos: {
+        never_do: string[];
+        must_escalate: string[];
+    };
+    trace_map?: Record<string, any> | undefined;
+}, {
+    schema_version: "constitution.v1";
+    generated_at: string;
+    generator_version: string;
+    user_scope: "single_user";
+    principles: {
+        id: string;
+        priority: number;
+        statement: string;
+        applies_to: string[];
+        rationale?: string | undefined;
+        examples_good?: string[] | undefined;
+        examples_bad?: string[] | undefined;
+    }[];
+    tone: {
+        voice_keywords: string[];
+        forbidden_phrases: string[];
+        formatting_rules: string[];
+    };
+    tradeoffs: {
+        accuracy_vs_speed: number;
+        cost_sensitivity: number;
+        autonomy_level: number;
+    };
+    evidence_policy: {
+        require_citations_for: string[];
+        uncertainty_language_rules: string[];
+    };
+    taboos: {
+        never_do: string[];
+        must_escalate: string[];
+    };
+    trace_map?: Record<string, any> | undefined;
+}>;
+export type ConstitutionV1 = z.infer<typeof ConstitutionV1Schema>;
+export type ConstitutionPrinciple = z.infer<typeof ConstitutionPrincipleSchema>;
+export type ConstitutionTone = z.infer<typeof ConstitutionToneSchema>;
+export type ConstitutionTradeoffs = z.infer<typeof ConstitutionTradeoffsSchema>;
+export type ConstitutionEvidencePolicy = z.infer<typeof ConstitutionEvidencePolicySchema>;
+export type ConstitutionTaboos = z.infer<typeof ConstitutionTaboosSchema>;
+//# sourceMappingURL=constitution.d.ts.map

package/dist/schemas/constitution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constitution.d.ts","sourceRoot":"","sources":["../../schemas/constitution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;GAKG;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;EAQtC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;EAIjC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;EAItC,CAAC;AAEH,eAAO,MAAM,gCAAgC;;;;;;;;;EAG3C,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;EAGnC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAC1F,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/schemas/constitution.js

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+/**
+ * Constitution v1 Schema
+ *
+ * Represents the global taste profile for a single user.
+ * Principles are ordered by priority (1 = highest).
+ */
+export const ConstitutionPrincipleSchema = z.object({
+    id: z.string().describe('Stable principle identifier'),
+    priority: z.number().int().positive().describe('Priority (1 = highest)'),
+    statement: z.string().describe('The principle statement'),
+    rationale: z.string().optional().describe('Why this principle matters'),
+    applies_to: z.array(z.string()).describe('Tags: skill_ids, domains, or contexts'),
+    examples_good: z.array(z.string()).optional().describe('Positive examples'),
+    examples_bad: z.array(z.string()).optional().describe('Negative examples'),
+});
+export const ConstitutionToneSchema = z.object({
+    voice_keywords: z.array(z.string()).describe('Keywords describing voice/tone'),
+    forbidden_phrases: z.array(z.string()).describe('Phrases to never use'),
+    formatting_rules: z.array(z.string()).describe('Formatting preferences'),
+});
+export const ConstitutionTradeoffsSchema = z.object({
+    accuracy_vs_speed: z.number().min(0).max(1).describe('0 = speed, 1 = accuracy'),
+    cost_sensitivity: z.number().min(0).max(1).describe('0 = cost-insensitive, 1 = highly cost-sensitive'),
+    autonomy_level: z.number().min(0).max(1).describe('0 = always ask, 1 = fully autonomous'),
+});
+export const ConstitutionEvidencePolicySchema = z.object({
+    require_citations_for: z.array(z.string()).describe('Domains/types requiring citations'),
+    uncertainty_language_rules: z.array(z.string()).describe('How to express uncertainty'),
+});
+export const ConstitutionTaboosSchema = z.object({
+    never_do: z.array(z.string()).describe('Actions that must never be taken'),
+    must_escalate: z.array(z.string()).describe('Situations requiring human approval'),
+});
+export const ConstitutionV1Schema = z.object({
+    schema_version: z.literal('constitution.v1'),
+    generated_at: z.string().datetime().describe('ISO8601 timestamp'),
+    generator_version: z.string().describe('TasteKit version used'),
+    user_scope: z.literal('single_user'),
+    principles: z.array(ConstitutionPrincipleSchema).describe('Ordered principles'),
+    tone: ConstitutionToneSchema,
+    tradeoffs: ConstitutionTradeoffsSchema,
+    evidence_policy: ConstitutionEvidencePolicySchema,
+    taboos: ConstitutionTaboosSchema,
+    trace_map: z.record(z.any()).optional().describe('Maps principle_id to source answers/exemplars'),
+});
+//# sourceMappingURL=constitution.js.map

package/dist/schemas/constitution.js.map

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

package/dist/schemas/evalpack.d.ts

@@ -0,0 +1,322 @@
+import { z } from 'zod';
+/**
+ * EvalPack v1 Schema
+ *
+ * Evaluation scenarios with setup, expectations, and judging criteria.
+ */
+export declare const EvalScenarioSetupSchema: z.ZodObject<{
+    inputs: z.ZodRecord<z.ZodString, z.ZodAny>;
+    resources: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    context: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    inputs: Record<string, any>;
+    resources?: string[] | undefined;
+    context?: string | undefined;
+}, {
+    inputs: Record<string, any>;
+    resources?: string[] | undefined;
+    context?: string | undefined;
+}>;
+export declare const EvalScenarioExpectedSchema: z.ZodObject<{
+    rubrics: z.ZodArray<z.ZodString, "many">;
+    thresholds: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    required_outputs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    rubrics: string[];
+    thresholds: Record<string, number>;
+    required_outputs?: string[] | undefined;
+}, {
+    rubrics: string[];
+    thresholds: Record<string, number>;
+    required_outputs?: string[] | undefined;
+}>;
+export declare const EvalJudgingRuleSchema: z.ZodObject<{
+    rule_id: z.ZodString;
+    type: z.ZodEnum<["deterministic", "llm_judge", "regex", "schema"]>;
+    pattern: z.ZodOptional<z.ZodString>;
+    template: z.ZodOptional<z.ZodString>;
+    weight: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "deterministic" | "llm_judge" | "regex" | "schema";
+    rule_id: string;
+    weight: number;
+    pattern?: string | undefined;
+    template?: string | undefined;
+}, {
+    type: "deterministic" | "llm_judge" | "regex" | "schema";
+    rule_id: string;
+    pattern?: string | undefined;
+    template?: string | undefined;
+    weight?: number | undefined;
+}>;
+export declare const EvalJudgingSchema: z.ZodObject<{
+    rules: z.ZodArray<z.ZodObject<{
+        rule_id: z.ZodString;
+        type: z.ZodEnum<["deterministic", "llm_judge", "regex", "schema"]>;
+        pattern: z.ZodOptional<z.ZodString>;
+        template: z.ZodOptional<z.ZodString>;
+        weight: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "deterministic" | "llm_judge" | "regex" | "schema";
+        rule_id: string;
+        weight: number;
+        pattern?: string | undefined;
+        template?: string | undefined;
+    }, {
+        type: "deterministic" | "llm_judge" | "regex" | "schema";
+        rule_id: string;
+        pattern?: string | undefined;
+        template?: string | undefined;
+        weight?: number | undefined;
+    }>, "many">;
+    output_format: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    rules: {
+        type: "deterministic" | "llm_judge" | "regex" | "schema";
+        rule_id: string;
+        weight: number;
+        pattern?: string | undefined;
+        template?: string | undefined;
+    }[];
+    output_format: string;
+}, {
+    rules: {
+        type: "deterministic" | "llm_judge" | "regex" | "schema";
+        rule_id: string;
+        pattern?: string | undefined;
+        template?: string | undefined;
+        weight?: number | undefined;
+    }[];
+    output_format: string;
+}>;
+export declare const EvalScenarioSchema: z.ZodObject<{
+    scenario_id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    setup: z.ZodObject<{
+        inputs: z.ZodRecord<z.ZodString, z.ZodAny>;
+        resources: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        context: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        inputs: Record<string, any>;
+        resources?: string[] | undefined;
+        context?: string | undefined;
+    }, {
+        inputs: Record<string, any>;
+        resources?: string[] | undefined;
+        context?: string | undefined;
+    }>;
+    expected: z.ZodObject<{
+        rubrics: z.ZodArray<z.ZodString, "many">;
+        thresholds: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        required_outputs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        rubrics: string[];
+        thresholds: Record<string, number>;
+        required_outputs?: string[] | undefined;
+    }, {
+        rubrics: string[];
+        thresholds: Record<string, number>;
+        required_outputs?: string[] | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    expected: {
+        rubrics: string[];
+        thresholds: Record<string, number>;
+        required_outputs?: string[] | undefined;
+    };
+    description: string;
+    name: string;
+    scenario_id: string;
+    setup: {
+        inputs: Record<string, any>;
+        resources?: string[] | undefined;
+        context?: string | undefined;
+    };
+}, {
+    expected: {
+        rubrics: string[];
+        thresholds: Record<string, number>;
+        required_outputs?: string[] | undefined;
+    };
+    description: string;
+    name: string;
+    scenario_id: string;
+    setup: {
+        inputs: Record<string, any>;
+        resources?: string[] | undefined;
+        context?: string | undefined;
+    };
+}>;
+export declare const EvalPackV1Schema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"evalpack.v1">;
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    scenarios: z.ZodArray<z.ZodObject<{
+        scenario_id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        setup: z.ZodObject<{
+            inputs: z.ZodRecord<z.ZodString, z.ZodAny>;
+            resources: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            context: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            inputs: Record<string, any>;
+            resources?: string[] | undefined;
+            context?: string | undefined;
+        }, {
+            inputs: Record<string, any>;
+            resources?: string[] | undefined;
+            context?: string | undefined;
+        }>;
+        expected: z.ZodObject<{
+            rubrics: z.ZodArray<z.ZodString, "many">;
+            thresholds: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            required_outputs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            rubrics: string[];
+            thresholds: Record<string, number>;
+            required_outputs?: string[] | undefined;
+        }, {
+            rubrics: string[];
+            thresholds: Record<string, number>;
+            required_outputs?: string[] | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        expected: {
+            rubrics: string[];
+            thresholds: Record<string, number>;
+            required_outputs?: string[] | undefined;
+        };
+        description: string;
+        name: string;
+        scenario_id: string;
+        setup: {
+            inputs: Record<string, any>;
+            resources?: string[] | undefined;
+            context?: string | undefined;
+        };
+    }, {
+        expected: {
+            rubrics: string[];
+            thresholds: Record<string, number>;
+            required_outputs?: string[] | undefined;
+        };
+        description: string;
+        name: string;
+        scenario_id: string;
+        setup: {
+            inputs: Record<string, any>;
+            resources?: string[] | undefined;
+            context?: string | undefined;
+        };
+    }>, "many">;
+    judging: z.ZodObject<{
+        rules: z.ZodArray<z.ZodObject<{
+            rule_id: z.ZodString;
+            type: z.ZodEnum<["deterministic", "llm_judge", "regex", "schema"]>;
+            pattern: z.ZodOptional<z.ZodString>;
+            template: z.ZodOptional<z.ZodString>;
+            weight: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            type: "deterministic" | "llm_judge" | "regex" | "schema";
+            rule_id: string;
+            weight: number;
+            pattern?: string | undefined;
+            template?: string | undefined;
+        }, {
+            type: "deterministic" | "llm_judge" | "regex" | "schema";
+            rule_id: string;
+            pattern?: string | undefined;
+            template?: string | undefined;
+            weight?: number | undefined;
+        }>, "many">;
+        output_format: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        rules: {
+            type: "deterministic" | "llm_judge" | "regex" | "schema";
+            rule_id: string;
+            weight: number;
+            pattern?: string | undefined;
+            template?: string | undefined;
+        }[];
+        output_format: string;
+    }, {
+        rules: {
+            type: "deterministic" | "llm_judge" | "regex" | "schema";
+            rule_id: string;
+            pattern?: string | undefined;
+            template?: string | undefined;
+            weight?: number | undefined;
+        }[];
+        output_format: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    name: string;
+    schema_version: "evalpack.v1";
+    id: string;
+    scenarios: {
+        expected: {
+            rubrics: string[];
+            thresholds: Record<string, number>;
+            required_outputs?: string[] | undefined;
+        };
+        description: string;
+        name: string;
+        scenario_id: string;
+        setup: {
+            inputs: Record<string, any>;
+            resources?: string[] | undefined;
+            context?: string | undefined;
+        };
+    }[];
+    judging: {
+        rules: {
+            type: "deterministic" | "llm_judge" | "regex" | "schema";
+            rule_id: string;
+            weight: number;
+            pattern?: string | undefined;
+            template?: string | undefined;
+        }[];
+        output_format: string;
+    };
+}, {
+    description: string;
+    name: string;
+    schema_version: "evalpack.v1";
+    id: string;
+    scenarios: {
+        expected: {
+            rubrics: string[];
+            thresholds: Record<string, number>;
+            required_outputs?: string[] | undefined;
+        };
+        description: string;
+        name: string;
+        scenario_id: string;
+        setup: {
+            inputs: Record<string, any>;
+            resources?: string[] | undefined;
+            context?: string | undefined;
+        };
+    }[];
+    judging: {
+        rules: {
+            type: "deterministic" | "llm_judge" | "regex" | "schema";
+            rule_id: string;
+            pattern?: string | undefined;
+            template?: string | undefined;
+            weight?: number | undefined;
+        }[];
+        output_format: string;
+    };
+}>;
+export type EvalPackV1 = z.infer<typeof EvalPackV1Schema>;
+export type EvalScenario = z.infer<typeof EvalScenarioSchema>;
+export type EvalScenarioSetup = z.infer<typeof EvalScenarioSetupSchema>;
+export type EvalScenarioExpected = z.infer<typeof EvalScenarioExpectedSchema>;
+export type EvalJudging = z.infer<typeof EvalJudgingSchema>;
+export type EvalJudgingRule = z.infer<typeof EvalJudgingRuleSchema>;
+//# sourceMappingURL=evalpack.d.ts.map

package/dist/schemas/evalpack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evalpack.d.ts","sourceRoot":"","sources":["../../schemas/evalpack.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;EAIlC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;EAIrC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;EAMhC,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG5B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM7B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/schemas/evalpack.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+/**
+ * EvalPack v1 Schema
+ *
+ * Evaluation scenarios with setup, expectations, and judging criteria.
+ */
+export const EvalScenarioSetupSchema = z.object({
+    inputs: z.record(z.any()).describe('Input data for the scenario'),
+    resources: z.array(z.string()).optional().describe('Required resources'),
+    context: z.string().optional().describe('Additional context'),
+});
+export const EvalScenarioExpectedSchema = z.object({
+    rubrics: z.array(z.string()).describe('Rubric identifiers to apply'),
+    thresholds: z.record(z.number()).describe('Minimum scores by rubric'),
+    required_outputs: z.array(z.string()).optional().describe('Required output fields'),
+});
+export const EvalJudgingRuleSchema = z.object({
+    rule_id: z.string(),
+    type: z.enum(['deterministic', 'llm_judge', 'regex', 'schema']),
+    pattern: z.string().optional().describe('Pattern for regex/schema rules'),
+    template: z.string().optional().describe('LLM judge prompt template'),
+    weight: z.number().min(0).max(1).default(1),
+});
+export const EvalJudgingSchema = z.object({
+    rules: z.array(EvalJudgingRuleSchema),
+    output_format: z.string().describe('Required output format'),
+});
+export const EvalScenarioSchema = z.object({
+    scenario_id: z.string(),
+    name: z.string(),
+    description: z.string(),
+    setup: EvalScenarioSetupSchema,
+    expected: EvalScenarioExpectedSchema,
+});
+export const EvalPackV1Schema = z.object({
+    schema_version: z.literal('evalpack.v1'),
+    id: z.string(),
+    name: z.string(),
+    description: z.string(),
+    scenarios: z.array(EvalScenarioSchema),
+    judging: EvalJudgingSchema,
+});
+//# sourceMappingURL=evalpack.js.map

package/dist/schemas/evalpack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evalpack.js","sourceRoot":"","sources":["../../schemas/evalpack.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AAEH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC9C,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,CAAC,6BAA6B,CAAC;IACjE,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,oBAAoB,CAAC;IACxE,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,oBAAoB,CAAC;CAC9D,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC;IACjD,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC,6BAA6B,CAAC;IACpE,UAAU,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC,0BAA0B,CAAC;IACrE,gBAAgB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,wBAAwB,CAAC;CACpF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,eAAe,EAAE,WAAW,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC/D,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,gCAAgC,CAAC;IACzE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,2BAA2B,CAAC;IACrE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;CAC5C,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,qBAAqB,CAAC;IACrC,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,wBAAwB,CAAC;CAC7D,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,KAAK,EAAE,uBAAuB;IAC9B,QAAQ,EAAE,0BAA0B;CACrC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,cAAc,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC;IAExC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IAEvB,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC;IACtC,OAAO,EAAE,iBAAiB;CAC3B,CAAC,CAAC"}