npm - openpond-sdk - Versions diffs - 0.11.4 → 0.11.6 - Mend

openpond-sdk 0.11.4 → 0.11.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (189) hide show

package/dist/types/packages/sdk/src/task-design-contracts.d.ts ADDED Viewed

@@ -0,0 +1,363 @@
+import { z } from "zod";
+export declare const TrainingTacticSchema: z.ZodEnum<{
+    sft: "sft";
+    sdpo: "sdpo";
+    preference: "preference";
+    retrieval: "retrieval";
+    grpo_rft: "grpo_rft";
+    no_training: "no_training";
+    prompting: "prompting";
+    sdft_opsd: "sdft_opsd";
+    agentic_rl: "agentic_rl";
+}>;
+export declare const TaskDesignFixtureTemplateSchema: z.ZodObject<{
+    id: z.ZodString;
+    taskIndex: z.ZodNumber;
+    label: z.ZodEnum<{
+        infrastructure_failure: "infrastructure_failure";
+        positive: "positive";
+        negative: "negative";
+        boundary: "boundary";
+        adversarial: "adversarial";
+        prompt_injection: "prompt_injection";
+    }>;
+    output: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    infrastructureError: z.ZodNullable<z.ZodString>;
+    expectedPassed: z.ZodBoolean;
+    expectedRewardEligible: z.ZodBoolean;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const CapabilityDiagnosisSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.capabilityDiagnosis.v1">;
+    summary: z.ZodString;
+    stableBehavior: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    changingKnowledge: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    requiredContext: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    requiredTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    intervention: z.ZodEnum<{
+        sft: "sft";
+        sdpo: "sdpo";
+        preference: "preference";
+        retrieval: "retrieval";
+        grpo_rft: "grpo_rft";
+        no_training: "no_training";
+        prompting: "prompting";
+        sdft_opsd: "sdft_opsd";
+        agentic_rl: "agentic_rl";
+    }>;
+    trainingEligible: z.ZodBoolean;
+    rationale: z.ZodArray<z.ZodString>;
+    confidence: z.ZodNumber;
+}, z.core.$strip>;
+export declare const TaskExampleProposalSchema: z.ZodObject<{
+    id: z.ZodString;
+    sourceId: z.ZodString;
+    sourceTurnId: z.ZodNullable<z.ZodString>;
+    split: z.ZodEnum<{
+        train: "train";
+        validation: "validation";
+        test: "test";
+        frozen_eval: "frozen_eval";
+    }>;
+    origin: z.ZodEnum<{
+        corrected: "corrected";
+        expert_authored: "expert_authored";
+        extracted: "extracted";
+        synthetic: "synthetic";
+    }>;
+    inputPrompt: z.ZodString;
+    expectedOutputText: z.ZodNullable<z.ZodString>;
+    rationale: z.ZodString;
+}, z.core.$strip>;
+export declare const TaskDesignProposalSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.taskDesignProposal.v1">;
+    id: z.ZodString;
+    name: z.ZodString;
+    objective: z.ZodString;
+    diagnosis: z.ZodDefault<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.capabilityDiagnosis.v1">;
+        summary: z.ZodString;
+        stableBehavior: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        changingKnowledge: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        requiredContext: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        requiredTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        intervention: z.ZodEnum<{
+            sft: "sft";
+            sdpo: "sdpo";
+            preference: "preference";
+            retrieval: "retrieval";
+            grpo_rft: "grpo_rft";
+            no_training: "no_training";
+            prompting: "prompting";
+            sdft_opsd: "sdft_opsd";
+            agentic_rl: "agentic_rl";
+        }>;
+        trainingEligible: z.ZodBoolean;
+        rationale: z.ZodArray<z.ZodString>;
+        confidence: z.ZodNumber;
+    }, z.core.$strip>>;
+    taskKind: z.ZodEnum<{
+        chat: "chat";
+        single_agent: "single_agent";
+        multi_agent: "multi_agent";
+        custom_program: "custom_program";
+    }>;
+    sourceIds: z.ZodArray<z.ZodString>;
+    assumptions: z.ZodArray<z.ZodString>;
+    successCriteria: z.ZodArray<z.ZodString>;
+    proposedGraders: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        label: z.ZodString;
+        weight: z.ZodDefault<z.ZodNumber>;
+        hardGate: z.ZodDefault<z.ZodBoolean>;
+        rewardEligible: z.ZodDefault<z.ZodBoolean>;
+        privileged: z.ZodDefault<z.ZodBoolean>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        kind: z.ZodEnum<{
+            file: "file";
+            content: "content";
+            state: "state";
+            test: "test";
+            diff: "diff";
+            schema: "schema";
+            runtime_event: "runtime_event";
+        }>;
+        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        label: z.ZodString;
+        weight: z.ZodDefault<z.ZodNumber>;
+        hardGate: z.ZodDefault<z.ZodBoolean>;
+        rewardEligible: z.ZodDefault<z.ZodBoolean>;
+        privileged: z.ZodDefault<z.ZodBoolean>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        kind: z.ZodLiteral<"model_judge">;
+        rubric: z.ZodString;
+        judge: z.ZodObject<{
+            providerId: z.ZodUnion<readonly [z.ZodEnum<{
+                openpond: "openpond";
+                codex: "codex";
+                "claude-code": "claude-code";
+                "grok-build": "grok-build";
+                opencode: "opencode";
+                anthropic: "anthropic";
+                openai: "openai";
+                xai: "xai";
+                google: "google";
+                openrouter: "openrouter";
+                deepseek: "deepseek";
+                zai: "zai";
+                moonshot: "moonshot";
+                together: "together";
+                groq: "groq";
+                "custom-openai-compatible": "custom-openai-compatible";
+            }>, z.ZodTemplateLiteral<`acp:${string}`>]>;
+            modelId: z.ZodString;
+        }, z.core.$strip>;
+        calibrationFixtureRefs: z.ZodArray<z.ZodString>;
+        calibrationStatus: z.ZodEnum<{
+            passed: "passed";
+            pending: "pending";
+            failed: "failed";
+        }>;
+        temperature: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        label: z.ZodString;
+        weight: z.ZodDefault<z.ZodNumber>;
+        hardGate: z.ZodDefault<z.ZodBoolean>;
+        rewardEligible: z.ZodDefault<z.ZodBoolean>;
+        privileged: z.ZodDefault<z.ZodBoolean>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        kind: z.ZodLiteral<"human">;
+        form: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
+            mode: z.ZodEnum<{
+                individual: "individual";
+                pairwise: "pairwise";
+            }>;
+            instructions: z.ZodString;
+            criteria: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                instructions: z.ZodString;
+                required: z.ZodBoolean;
+                allowAbstain: z.ZodBoolean;
+                requireRationale: z.ZodOptional<z.ZodBoolean>;
+                anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                    description: z.ZodString;
+                }, z.core.$strict>>>;
+                kind: z.ZodLiteral<"score">;
+                minimum: z.ZodNumber;
+                maximum: z.ZodNumber;
+                step: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                instructions: z.ZodString;
+                required: z.ZodBoolean;
+                allowAbstain: z.ZodBoolean;
+                requireRationale: z.ZodOptional<z.ZodBoolean>;
+                anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                    description: z.ZodString;
+                }, z.core.$strict>>>;
+                kind: z.ZodLiteral<"category">;
+                options: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                instructions: z.ZodString;
+                required: z.ZodBoolean;
+                allowAbstain: z.ZodBoolean;
+                requireRationale: z.ZodOptional<z.ZodBoolean>;
+                anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                    description: z.ZodString;
+                }, z.core.$strict>>>;
+                kind: z.ZodLiteral<"boolean">;
+            }, z.core.$strict>, z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                instructions: z.ZodString;
+                required: z.ZodBoolean;
+                allowAbstain: z.ZodBoolean;
+                requireRationale: z.ZodOptional<z.ZodBoolean>;
+                anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                    description: z.ZodString;
+                }, z.core.$strict>>>;
+                kind: z.ZodLiteral<"text">;
+                minimumLength: z.ZodOptional<z.ZodNumber>;
+                maximumLength: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                instructions: z.ZodString;
+                required: z.ZodBoolean;
+                allowAbstain: z.ZodBoolean;
+                requireRationale: z.ZodOptional<z.ZodBoolean>;
+                anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                    description: z.ZodString;
+                }, z.core.$strict>>>;
+                kind: z.ZodLiteral<"preference">;
+                requireStrength: z.ZodOptional<z.ZodBoolean>;
+                allowTie: z.ZodBoolean;
+            }, z.core.$strict>], "kind">>;
+        }, z.core.$strict>>;
+        rubric: z.ZodString;
+        reviewerRole: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        label: z.ZodString;
+        weight: z.ZodDefault<z.ZodNumber>;
+        hardGate: z.ZodDefault<z.ZodBoolean>;
+        rewardEligible: z.ZodDefault<z.ZodBoolean>;
+        privileged: z.ZodDefault<z.ZodBoolean>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        kind: z.ZodLiteral<"custom_verifier">;
+        runtime: z.ZodOptional<z.ZodEnum<{
+            isolated_javascript: "isolated_javascript";
+            sandbox_process: "sandbox_process";
+        }>>;
+        module: z.ZodString;
+        exportName: z.ZodString;
+        timeoutMs: z.ZodNumber;
+        networkPolicy: z.ZodLiteral<"none">;
+    }, z.core.$strip>]>>>;
+    graderFixtures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        taskIndex: z.ZodNumber;
+        label: z.ZodEnum<{
+            infrastructure_failure: "infrastructure_failure";
+            positive: "positive";
+            negative: "negative";
+            boundary: "boundary";
+            adversarial: "adversarial";
+            prompt_injection: "prompt_injection";
+        }>;
+        output: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        infrastructureError: z.ZodNullable<z.ZodString>;
+        expectedPassed: z.ZodBoolean;
+        expectedRewardEligible: z.ZodBoolean;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    generatedFiles: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        role: z.ZodEnum<{
+            environment: "environment";
+            fixture: "fixture";
+            verifier: "verifier";
+        }>;
+        content: z.ZodString;
+    }, z.core.$strip>>>;
+    proposedExamples: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sourceId: z.ZodString;
+        sourceTurnId: z.ZodNullable<z.ZodString>;
+        split: z.ZodEnum<{
+            train: "train";
+            validation: "validation";
+            test: "test";
+            frozen_eval: "frozen_eval";
+        }>;
+        origin: z.ZodEnum<{
+            corrected: "corrected";
+            expert_authored: "expert_authored";
+            extracted: "extracted";
+            synthetic: "synthetic";
+        }>;
+        inputPrompt: z.ZodString;
+        expectedOutputText: z.ZodNullable<z.ZodString>;
+        rationale: z.ZodString;
+    }, z.core.$strip>>>;
+    proposedMethod: z.ZodEnum<{
+        none: "none";
+        sft: "sft";
+        dpo: "dpo";
+        grpo: "grpo";
+        ppo: "ppo";
+        sdft: "sdft";
+        opd: "opd";
+        opsd: "opsd";
+        sdpo: "sdpo";
+        retrieval: "retrieval";
+    }>;
+    trainingPath: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        primaryMethod: z.ZodEnum<{
+            sft: "sft";
+            dpo: "dpo";
+            grpo: "grpo";
+            ppo: "ppo";
+            sdft: "sdft";
+            opsd: "opsd";
+            sdpo: "sdpo";
+        }>;
+        bootstrap: z.ZodNullable<z.ZodObject<{
+            method: z.ZodLiteral<"sft">;
+            purpose: z.ZodLiteral<"trajectory_bootstrap">;
+            demonstrationRefs: z.ZodArray<z.ZodString>;
+            limitations: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    policy: z.ZodObject<{
+        policyVisibleFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        privilegedFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        hiddenGraderRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        connectedAppScopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    warnings: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type TaskDesignFixtureTemplate = z.infer<typeof TaskDesignFixtureTemplateSchema>;
+export type CapabilityDiagnosis = z.infer<typeof CapabilityDiagnosisSchema>;
+export type TaskExampleProposal = z.infer<typeof TaskExampleProposalSchema>;
+export type TaskDesignProposal = z.infer<typeof TaskDesignProposalSchema>;
+export type TrainingTactic = z.infer<typeof TrainingTacticSchema>;
+//# sourceMappingURL=task-design-contracts.d.ts.map

package/dist/types/packages/sdk/src/task-design-contracts.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"task-design-contracts.d.ts","sourceRoot":"","sources":["../../../../../src/task-design-contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgBxB,eAAO,MAAM,oBAAoB;;;;;;;;;;EAU/B,CAAC;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;iBAS1C,CAAC;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;iBAWpC,CAAC;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;iBASpC,CAAC;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BnC,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AACxF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/types/packages/sdk/src/taskset-authored-contracts.d.ts CHANGED Viewed

@@ -212,7 +212,7 @@ export declare const AuthoringRepairSchema: z.ZodObject<{
 export declare const AuthoringProvenanceSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"openpond.taskAuthoringProvenance.v1">;
     model: z.ZodNullable<z.ZodObject<{
-        providerId: z.ZodEnum<{
+        providerId: z.ZodUnion<readonly [z.ZodEnum<{
             openpond: "openpond";
             codex: "codex";
             "claude-code": "claude-code";
@@ -229,7 +229,7 @@ export declare const AuthoringProvenanceSchema: z.ZodObject<{
             together: "together";
             groq: "groq";
             "custom-openai-compatible": "custom-openai-compatible";
-        }>;
+        }>, z.ZodTemplateLiteral<`acp:${string}`>]>;
         modelId: z.ZodString;
     }, z.core.$strip>>;
     modelConfig: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -879,7 +879,7 @@ export declare const TasksetSchema: z.ZodObject<{
         kind: z.ZodLiteral<"model_judge">;
         rubric: z.ZodString;
         judge: z.ZodObject<{
-            providerId: z.ZodEnum<{
+            providerId: z.ZodUnion<readonly [z.ZodEnum<{
                 openpond: "openpond";
                 codex: "codex";
                 "claude-code": "claude-code";
@@ -896,7 +896,7 @@ export declare const TasksetSchema: z.ZodObject<{
                 together: "together";
                 groq: "groq";
                 "custom-openai-compatible": "custom-openai-compatible";
-            }>;
+            }>, z.ZodTemplateLiteral<`acp:${string}`>]>;
             modelId: z.ZodString;
         }, z.core.$strip>;
         calibrationFixtureRefs: z.ZodArray<z.ZodString>;
@@ -1132,7 +1132,7 @@ export declare const TasksetSchema: z.ZodObject<{
     authoringProvenance: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.taskAuthoringProvenance.v1">;
         model: z.ZodNullable<z.ZodObject<{
-            providerId: z.ZodEnum<{
+            providerId: z.ZodUnion<readonly [z.ZodEnum<{
                 openpond: "openpond";
                 codex: "codex";
                 "claude-code": "claude-code";
@@ -1149,7 +1149,7 @@ export declare const TasksetSchema: z.ZodObject<{
                 together: "together";
                 groq: "groq";
                 "custom-openai-compatible": "custom-openai-compatible";
-            }>;
+            }>, z.ZodTemplateLiteral<`acp:${string}`>]>;
             modelId: z.ZodString;
         }, z.core.$strip>>;
         modelConfig: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;

package/dist/types/packages/sdk/src/taskset-authored-files.d.ts CHANGED Viewed

@@ -59,7 +59,7 @@ export declare function prepareAuthoredTasksetSource(tasksetInput: Taskset, sour
             licensingStatus: "pending" | "approved" | "review" | "blocked";
             secretScanStatus: "passed" | "pending" | "blocked";
             piiScanStatus: "passed" | "pending" | "review" | "blocked";
-            origin: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
+            origin: "codex" | "hermes" | "openclaw" | "native_chat" | "native_work" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
             sourceId: string;
             sessionId: string;
             normalizerVersion: string;
@@ -285,7 +285,7 @@ export declare function prepareAuthoredTasksetSource(tasksetInput: Taskset, sour
             kind: "model_judge";
             rubric: string;
             judge: {
-                providerId: "claude-code" | "custom-openai-compatible" | "openpond" | "codex" | "opencode" | "grok-build" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
+                providerId: "claude-code" | "codex" | "custom-openai-compatible" | "openpond" | "opencode" | `acp:${string}` | "grok-build" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
                 modelId: string;
             };
             calibrationFixtureRefs: string[];
@@ -499,7 +499,7 @@ export declare function prepareAuthoredTasksetSource(tasksetInput: Taskset, sour
         authoringProvenance: {
             schemaVersion: "openpond.taskAuthoringProvenance.v1";
             model: {
-                providerId: "claude-code" | "custom-openai-compatible" | "openpond" | "codex" | "opencode" | "grok-build" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
+                providerId: "claude-code" | "codex" | "custom-openai-compatible" | "openpond" | "opencode" | `acp:${string}` | "grok-build" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
                 modelId: string;
             } | null;
             modelConfig: Record<string, unknown>;

package/dist/types/packages/sdk/src/taskset-authored-validation.d.ts CHANGED Viewed

@@ -14,6 +14,7 @@ export type TasksetValidationReport = {
 };
 export declare function validateTaskset(input: unknown, options?: {
     allowUnscoredOnlineRewardBatch?: boolean;
+    purpose?: "publication" | "execution";
 }): TasksetValidationReport;
 export declare function computeTasksetHash(taskset: Omit<Taskset, "contentHash"> | Taskset): string;
 export declare function validatePortability(capabilities: TasksetCapabilityManifest): TasksetValidationIssue[];

package/dist/types/packages/sdk/src/taskset-authored-validation.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"taskset-authored-validation.d.ts","sourceRoot":"","sources":["../../../../../src/taskset-authored-validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,EAIL,KAAK,OAAO,EACb,MAAM,iCAAiC,CAAC;AAGzC,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,SAAS,GAAG,OAAO,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACxB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,MAAM,EAAE,sBAAsB,EAAE,CAAC;CAClC,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE;IAAE,8BAA8B,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,uBAAuB,~~CA4CnI~~;AA6ED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,aAAa,CAAC,GAAG,OAAO,GAAG,MAAM,CAE1F;AAOD,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,yBAAyB,GAAG,sBAAsB,EAAE,CAIrG"}
1	+ {"version":3,"file":"taskset-authored-validation.d.ts","sourceRoot":"","sources":["../../../../../src/taskset-authored-validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,EAIL,KAAK,OAAO,EACb,MAAM,iCAAiC,CAAC;AAGzC,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,SAAS,GAAG,OAAO,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACxB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,MAAM,EAAE,sBAAsB,EAAE,CAAC;CAClC,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE;IAAE,8BAA8B,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,aAAa,GAAG,WAAW,CAAA;CAAO,GAAG,uBAAuB,CA+C1K;AA6ED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,aAAa,CAAC,GAAG,OAAO,GAAG,MAAM,CAE1F;AAOD,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,yBAAyB,GAAG,sBAAsB,EAAE,CAIrG"}

package/dist/types/packages/sdk/src/taskset-draft-api-contracts.d.ts CHANGED Viewed

@@ -652,7 +652,7 @@ export declare const TasksetDraftReadbackSchema: z.ZodObject<{
             kind: z.ZodLiteral<"model_judge">;
             rubric: z.ZodString;
             judge: z.ZodObject<{
-                providerId: z.ZodEnum<{
+                providerId: z.ZodUnion<readonly [z.ZodEnum<{
                     openpond: "openpond";
                     codex: "codex";
                     "claude-code": "claude-code";
@@ -669,7 +669,7 @@ export declare const TasksetDraftReadbackSchema: z.ZodObject<{
                     together: "together";
                     groq: "groq";
                     "custom-openai-compatible": "custom-openai-compatible";
-                }>;
+                }>, z.ZodTemplateLiteral<`acp:${string}`>]>;
                 modelId: z.ZodString;
             }, z.core.$strip>;
             calibrationFixtureRefs: z.ZodArray<z.ZodString>;
@@ -1596,7 +1596,7 @@ export declare const TasksetDraftSaveRequestSchema: z.ZodObject<{
             kind: z.ZodLiteral<"model_judge">;
             rubric: z.ZodString;
             judge: z.ZodObject<{
-                providerId: z.ZodEnum<{
+                providerId: z.ZodUnion<readonly [z.ZodEnum<{
                     openpond: "openpond";
                     codex: "codex";
                     "claude-code": "claude-code";
@@ -1613,7 +1613,7 @@ export declare const TasksetDraftSaveRequestSchema: z.ZodObject<{
                     together: "together";
                     groq: "groq";
                     "custom-openai-compatible": "custom-openai-compatible";
-                }>;
+                }>, z.ZodTemplateLiteral<`acp:${string}`>]>;
                 modelId: z.ZodString;
             }, z.core.$strip>;
             calibrationFixtureRefs: z.ZodArray<z.ZodString>;

package/dist/types/packages/sdk/src/taskset-draft-authoring.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"taskset-draft-authoring.d.ts","sourceRoot":"","sources":["../../../../../src/taskset-draft-authoring.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEpF,MAAM,MAAM,wBAAwB,GAAG;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB,CAAC;AAEF,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,QAAQ,CAAC,MAAM,EAAE,wBAAwB,EAAE,CAAC;gBAEhC,MAAM,EAAE,wBAAwB,EAAE;CAK/C;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,YAAY,CAAC,YAAY,CAAC,CAAC;IACxC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,GAAG,YAAY,CA6Ff;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,wBAAwB,EAAE,~~CAiBlF~~"}
1	+ {"version":3,"file":"taskset-draft-authoring.d.ts","sourceRoot":"","sources":["../../../../../src/taskset-draft-authoring.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEpF,MAAM,MAAM,wBAAwB,GAAG;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB,CAAC;AAEF,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,QAAQ,CAAC,MAAM,EAAE,wBAAwB,EAAE,CAAC;gBAEhC,MAAM,EAAE,wBAAwB,EAAE;CAK/C;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,YAAY,CAAC,YAAY,CAAC,CAAC;IACxC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,GAAG,YAAY,CA6Ff;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,wBAAwB,EAAE,CAYlF"}

package/dist/types/packages/sdk/src/taskset-draft-client.d.ts CHANGED Viewed

@@ -100,7 +100,7 @@ export declare class OpenPondTasksetDraftClient {
                 licensingStatus: "pending" | "approved" | "review" | "blocked";
                 secretScanStatus: "passed" | "pending" | "blocked";
                 piiScanStatus: "passed" | "pending" | "review" | "blocked";
-                origin: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
+                origin: "codex" | "hermes" | "openclaw" | "native_chat" | "native_work" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
                 sourceId: string;
                 sessionId: string;
                 normalizerVersion: string;
@@ -363,7 +363,7 @@ export declare class OpenPondTasksetDraftClient {
                 kind: "model_judge";
                 rubric: string;
                 judge: {
-                    providerId: "claude-code" | "custom-openai-compatible" | "openpond" | "codex" | "opencode" | "grok-build" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
+                    providerId: "claude-code" | "codex" | "custom-openai-compatible" | "openpond" | "opencode" | `acp:${string}` | "grok-build" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
                     modelId: string;
                 };
                 calibrationFixtureRefs: string[];
@@ -700,7 +700,7 @@ export declare class OpenPondTasksetDraftClient {
                 licensingStatus: "pending" | "approved" | "review" | "blocked";
                 secretScanStatus: "passed" | "pending" | "blocked";
                 piiScanStatus: "passed" | "pending" | "review" | "blocked";
-                origin: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
+                origin: "codex" | "hermes" | "openclaw" | "native_chat" | "native_work" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
                 sourceId: string;
                 sessionId: string;
                 normalizerVersion: string;
@@ -963,7 +963,7 @@ export declare class OpenPondTasksetDraftClient {
                 kind: "model_judge";
                 rubric: string;
                 judge: {
-                    providerId: "claude-code" | "custom-openai-compatible" | "openpond" | "codex" | "opencode" | "grok-build" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
+                    providerId: "claude-code" | "codex" | "custom-openai-compatible" | "openpond" | "opencode" | `acp:${string}` | "grok-build" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
                     modelId: string;
                 };
                 calibrationFixtureRefs: string[];
@@ -1321,7 +1321,7 @@ export declare class OpenPondTasksetDraftClient {
                 licensingStatus: "pending" | "approved" | "review" | "blocked";
                 secretScanStatus: "passed" | "pending" | "blocked";
                 piiScanStatus: "passed" | "pending" | "review" | "blocked";
-                origin: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
+                origin: "codex" | "hermes" | "openclaw" | "native_chat" | "native_work" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
                 sourceId: string;
                 sessionId: string;
                 normalizerVersion: string;
@@ -1584,7 +1584,7 @@ export declare class OpenPondTasksetDraftClient {
                 kind: "model_judge";
                 rubric: string;
                 judge: {
-                    providerId: "claude-code" | "custom-openai-compatible" | "openpond" | "codex" | "opencode" | "grok-build" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
+                    providerId: "claude-code" | "codex" | "custom-openai-compatible" | "openpond" | "opencode" | `acp:${string}` | "grok-build" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
                     modelId: string;
                 };
                 calibrationFixtureRefs: string[];
@@ -1921,7 +1921,7 @@ export declare class OpenPondTasksetDraftClient {
                 licensingStatus: "pending" | "approved" | "review" | "blocked";
                 secretScanStatus: "passed" | "pending" | "blocked";
                 piiScanStatus: "passed" | "pending" | "review" | "blocked";
-                origin: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
+                origin: "codex" | "hermes" | "openclaw" | "native_chat" | "native_work" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
                 sourceId: string;
                 sessionId: string;
                 normalizerVersion: string;
@@ -2184,7 +2184,7 @@ export declare class OpenPondTasksetDraftClient {
                 kind: "model_judge";
                 rubric: string;
                 judge: {
-                    providerId: "claude-code" | "custom-openai-compatible" | "openpond" | "codex" | "opencode" | "grok-build" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
+                    providerId: "claude-code" | "codex" | "custom-openai-compatible" | "openpond" | "opencode" | `acp:${string}` | "grok-build" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
                     modelId: string;
                 };
                 calibrationFixtureRefs: string[];
@@ -2521,7 +2521,7 @@ export declare class OpenPondTasksetDraftClient {
                 licensingStatus: "pending" | "approved" | "review" | "blocked";
                 secretScanStatus: "passed" | "pending" | "blocked";
                 piiScanStatus: "passed" | "pending" | "review" | "blocked";
-                origin: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
+                origin: "codex" | "hermes" | "openclaw" | "native_chat" | "native_work" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
                 sourceId: string;
                 sessionId: string;
                 normalizerVersion: string;
@@ -2784,7 +2784,7 @@ export declare class OpenPondTasksetDraftClient {
                 kind: "model_judge";
                 rubric: string;
                 judge: {
-                    providerId: "claude-code" | "custom-openai-compatible" | "openpond" | "codex" | "opencode" | "grok-build" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
+                    providerId: "claude-code" | "codex" | "custom-openai-compatible" | "openpond" | "opencode" | `acp:${string}` | "grok-build" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
                     modelId: string;
                 };
                 calibrationFixtureRefs: string[];
@@ -3150,7 +3150,7 @@ export declare class OpenPondTasksetDraftClient {
                 licensingStatus: "pending" | "approved" | "review" | "blocked";
                 secretScanStatus: "passed" | "pending" | "blocked";
                 piiScanStatus: "passed" | "pending" | "review" | "blocked";
-                origin: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
+                origin: "codex" | "hermes" | "openclaw" | "native_chat" | "native_work" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
                 sourceId: string;
                 sessionId: string;
                 normalizerVersion: string;
@@ -3413,7 +3413,7 @@ export declare class OpenPondTasksetDraftClient {
                 kind: "model_judge";
                 rubric: string;
                 judge: {
-                    providerId: "claude-code" | "custom-openai-compatible" | "openpond" | "codex" | "opencode" | "grok-build" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
+                    providerId: "claude-code" | "codex" | "custom-openai-compatible" | "openpond" | "opencode" | `acp:${string}` | "grok-build" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
                     modelId: string;
                 };
                 calibrationFixtureRefs: string[];