@tangle-network/agent-interface 0.27.2 → 0.29.0

package/dist/agent-candidate-execution-plan-schema.js

@@ -1,17 +1,9 @@
 import { z } from "zod";
 import { agentCandidateArtifactRefSchema, agentCandidateCapturedArtifactSchema, agentCandidateWorkspaceSnapshotEvidenceSchema, } from "./agent-candidate-artifact-schema.js";
 import { agentCandidateContainerSchema, agentCandidateInstructionDeliverySchema, agentCandidateWorkingDirectorySchema, } from "./agent-candidate-code-schema.js";
+import { reasoningEffortSchema } from "./profile-schema.js";
 import { addDuplicateIssues, agentCandidateConfigValueSchema, agentCandidateMediaTypeSchema, environmentConfigSchema, gitObjectSchema, isCanonicalJsonValue, isObviouslyPrivateHostname, isSafeExecutable, isSafeRelativePath, isWellFormedUnicode, sameGitObjectFormat, sha256Utf8, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
 import { harnessTypeSchema } from "./harness.js";
-const reasoningEffortSchema = z.enum([
-    "none",
-    "minimal",
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-    "ultracode",
-]);
 function isCanonicalAbsolutePath(value) {
     return (value.startsWith("/") &&
         value !== "/" &&
@@ -58,9 +50,59 @@ export const agentCandidateResolvedModelSchema = z
     reasoningEffort: reasoningEffortSchema,
 })
     .strict();
+export const agentCandidateBenchmarkGraderIdentitySchema = z
+    .object({
+    name: z.string().min(1),
+    version: z.string().min(1),
+    format: z.literal("tangle-grader"),
+    artifact: agentCandidateArtifactRefSchema,
+})
+    .strict()
+    .superRefine((grader, ctx) => {
+    if (grader.artifact.byteLength === 0) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["artifact", "byteLength"],
+            message: "pinned grader artifact must contain executable grader bytes",
+        });
+    }
+});
+export const agentCandidateTaskRepositorySchema = z
+    .object({
+    identity: z.string().min(1).max(512),
+    rootIdentity: z.string().min(1).max(512),
+    baseCommit: gitObjectSchema,
+    baseTree: gitObjectSchema,
+})
+    .strict()
+    .superRefine((repository, ctx) => {
+    if (!sameGitObjectFormat(repository.baseCommit, repository.baseTree)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "task Git object ids must use one object format",
+        });
+    }
+});
+export const agentCandidateResolvedTaskContainerSchema = agentCandidateContainerSchema
+    .extend({
+    source: z.literal("evaluator-task-container"),
+    manifestDigest: sha256DigestSchema,
+    platform: z
+        .object({
+        os: z.string().min(1).max(100),
+        architecture: z.string().min(1).max(100),
+        variant: z.string().min(1).max(100).optional(),
+    })
+        .strict(),
+})
+    .strict();
+export const agentCandidateRetryPolicySchema = z.enum([
+    "pre-model-infrastructure-only",
+    "none",
+]);
 export const agentCandidateProfilePlanMaterialSchema = z
     .object({
-    version: z.literal(1),
+    sourceProfileDigest: sha256DigestSchema,
     harness: harnessTypeSchema,
     files: z.array(z
         .object({
@@ -150,46 +192,35 @@ export const agentCandidateTaskOutcomeSpecSchema = z.discriminatedUnion("kind",
     })
         .strict(),
 ]);
+export const agentCandidateBenchmarkCellRefSchema = z
+    .object({
+    suiteDigest: sha256DigestSchema,
+    taskIndex: z.number().int().nonnegative(),
+    repetition: z.number().int().nonnegative(),
+})
+    .strict();
+export const agentCandidateRunCellMaterialSchema = z
+    .object({
+    kind: z.literal("agent-candidate-run-cell"),
+    experimentDigest: sha256DigestSchema,
+    arm: z.enum(["baseline", "candidate"]),
+    bundleDigest: sha256DigestSchema,
+    suiteDigest: sha256DigestSchema,
+    taskDigest: sha256DigestSchema,
+    taskIndex: z.number().int().nonnegative(),
+    repetition: z.number().int().nonnegative(),
+    seed: z.number().int().safe(),
+    attempt: z.number().int().positive(),
+})
+    .strict();
+export const agentCandidateRunCellSchema = agentCandidateRunCellMaterialSchema
+    .extend({ digest: sha256DigestSchema })
+    .strict();
 export const agentCandidateExecutionPlanMaterialSchema = z
     .object({
-    schemaVersion: z.literal(2),
     kind: z.literal("agent-candidate-execution-plan-material"),
-    bundleDigest: sha256DigestSchema,
+    runCell: agentCandidateRunCellSchema,
     executionId: z.string().min(1),
-    attempt: z
-        .object({
-        number: z.number().int().min(1),
-        maxAttempts: z.number().int().min(1),
-        retryPolicy: z.enum(["pre-model-infrastructure-only", "none"]),
-    })
-        .strict(),
-    task: z
-        .object({
-        benchmark: z.string().min(1),
-        benchmarkVersion: z.string().min(1),
-        taskId: z.string().min(1),
-        splitDigest: sha256DigestSchema,
-        instruction: z
-            .object({
-            encoding: z.literal("utf8"),
-            sha256: sha256DigestSchema,
-            byteLength: z.number().int().positive(),
-            delivery: agentCandidateInstructionDeliverySchema,
-        })
-            .strict(),
-        repository: z
-            .object({
-            identity: z.string().min(1),
-            rootIdentity: z.string().min(1),
-            baseCommit: gitObjectSchema,
-            baseTree: gitObjectSchema,
-        })
-            .strict()
-            .optional(),
-        outcome: agentCandidateTaskOutcomeSpecSchema,
-        workspace: agentCandidateWorkspaceSnapshotEvidenceSchema,
-    })
-        .strict(),
     workspaces: z
         .object({
         taskRoot: z
@@ -214,6 +245,8 @@ export const agentCandidateExecutionPlanMaterialSchema = z
         .strict(),
     harness: harnessTypeSchema,
     harnessVersion: z.string().min(1),
+    instructionDelivery: agentCandidateInstructionDeliverySchema,
+    limits: agentCandidateExecutionLimitsSchema,
     container: agentCandidateContainerSchema
         .extend({
         source: z.enum(["pinned-container", "evaluator-task-container"]),
@@ -270,13 +303,6 @@ export const agentCandidateExecutionPlanMaterialSchema = z
             .min(1),
     })
         .strict(),
-    grader: z
-        .object({
-        name: z.string().min(1),
-        version: z.string().min(1),
-        artifact: agentCandidateArtifactRefSchema,
-    })
-        .strict(),
     launch: z
         .object({
         executable: z
@@ -289,42 +315,10 @@ export const agentCandidateExecutionPlanMaterialSchema = z
         .strict(),
     knowledgeManifestDigest: sha256DigestSchema.optional(),
     memory: agentCandidateEffectiveMemorySchema,
-    limits: agentCandidateExecutionLimitsSchema,
     network: z.object({ mode: z.literal("disabled") }).strict(),
 })
     .strict()
     .superRefine((material, ctx) => {
-    if (material.task.repository !== undefined &&
-        !sameGitObjectFormat(material.task.repository.baseCommit, material.task.repository.baseTree)) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["task", "repository"],
-            message: "task Git object ids must use one object format",
-        });
-    }
-    if (material.task.outcome.kind === "workspace" &&
-        material.task.repository === undefined) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["task", "repository"],
-            message: "workspace outcomes require task repository provenance",
-        });
-    }
-    if (material.attempt.number > material.attempt.maxAttempts) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["attempt", "number"],
-            message: "attempt number cannot exceed the frozen maximum",
-        });
-    }
-    if (material.attempt.retryPolicy === "none" &&
-        material.attempt.maxAttempts !== 1) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["attempt", "maxAttempts"],
-            message: "a no-retry plan must allow exactly one attempt",
-        });
-    }
     const routeIds = material.model.routes.map((route) => route.kind === "mode" || route.kind === "subagent"
         ? `${route.kind}:${route.name}`
         : route.kind);
@@ -358,20 +352,6 @@ export const agentCandidateExecutionPlanMaterialSchema = z
         }
     }
     const modelNetwork = material.model.access.network;
-    if (material.limits.maxModelCalls === 0 && modelNetwork.mode !== "disabled") {
-        ctx.addIssue({
-            code: "custom",
-            path: ["model", "access", "network"],
-            message: "zero-call plans cannot expose a model gateway",
-        });
-    }
-    if (material.limits.maxModelCalls > 0 && modelNetwork.mode !== "gateway-only") {
-        ctx.addIssue({
-            code: "custom",
-            path: ["model", "access", "network"],
-            message: "model-calling plans require one frozen gateway allowlist",
-        });
-    }
     if (modelNetwork.mode === "gateway-only") {
         addDuplicateIssues(modelNetwork.domains, ["model", "access", "network", "domains"], ctx);
         for (let index = 1; index < modelNetwork.domains.length; index++) {
@@ -407,62 +387,46 @@ export const agentCandidateExecutionPlanMaterialSchema = z
             message: "task and candidate workspace roots must be disjoint",
         });
     }
-    if (material.launch.cwd.workspace === "candidate" &&
-        material.workspaces.candidateRoot === undefined) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["launch", "cwd", "workspace"],
-            message: "candidate cwd requires a pinned candidate workspace root",
-        });
-    }
-    if (material.profile.targetWorkspace === "candidate" &&
-        material.workspaces.candidateRoot === undefined) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["profile", "targetWorkspace"],
-            message: "candidate-targeted profile files require a candidate workspace root",
-        });
-    }
-    const delivery = material.task.instruction.delivery;
     const taskPath = material.launch.env.TANGLE_CANDIDATE_TASK_PATH;
-    if (delivery.kind === "utf8-file") {
-        if (taskPath?.value !== delivery.path) {
+    if (taskPath !== undefined) {
+        if (taskPath.value !== "/tangle/input/task.txt") {
             ctx.addIssue({
                 code: "custom",
                 path: ["launch", "env", "TANGLE_CANDIDATE_TASK_PATH"],
-                message: "file delivery requires the signed fixed task path",
+                message: "task file delivery must use the fixed evaluator-owned path",
             });
         }
-        if (pathsOverlap(material.workspaces.taskRoot, delivery.path) ||
+        if (pathsOverlap(taskPath.value, material.workspaces.taskRoot) ||
             (material.workspaces.candidateRoot !== undefined &&
-                pathsOverlap(material.workspaces.candidateRoot, delivery.path))) {
+                pathsOverlap(taskPath.value, material.workspaces.candidateRoot))) {
             ctx.addIssue({
                 code: "custom",
-                path: ["workspaces"],
-                message: "the task instruction file must be outside both workspaces",
+                path: ["launch", "env", "TANGLE_CANDIDATE_TASK_PATH"],
+                message: "task file delivery must be outside both workspaces",
             });
         }
     }
-    else if (taskPath !== undefined) {
+    if (material.launch.cwd.workspace === "candidate" &&
+        material.workspaces.candidateRoot === undefined) {
         ctx.addIssue({
             code: "custom",
-            path: ["launch", "env", "TANGLE_CANDIDATE_TASK_PATH"],
-            message: "non-file delivery cannot expose an instruction path",
+            path: ["launch", "cwd", "workspace"],
+            message: "candidate cwd requires a pinned candidate workspace root",
         });
     }
-    if (activeCode && material.candidateWorkspace?.material.files.length === 0) {
+    if (material.profile.targetWorkspace === "candidate" &&
+        material.workspaces.candidateRoot === undefined) {
         ctx.addIssue({
             code: "custom",
-            path: ["candidateWorkspace", "material", "files"],
-            message: "active candidate workspaces cannot be empty",
+            path: ["profile", "targetWorkspace"],
+            message: "candidate-targeted profile files require a candidate workspace root",
         });
     }
-    if (material.task.outcome.kind === "workspace" &&
-        material.task.workspace.material.files.length === 0) {
+    if (activeCode && material.candidateWorkspace?.material.files.length === 0) {
         ctx.addIssue({
             code: "custom",
-            path: ["task", "workspace", "material", "files"],
-            message: "task workspace snapshots cannot be empty",
+            path: ["candidateWorkspace", "material", "files"],
+            message: "active candidate workspaces cannot be empty",
         });
     }
     if (!isCanonicalJsonValue(material)) {
@@ -472,10 +436,9 @@ export const agentCandidateExecutionPlanMaterialSchema = z
         });
     }
 });
-function planEvidenceSchema(schemaVersion, kind, material) {
+function planEvidenceSchema(kind, material) {
     return z
         .object({
-        schemaVersion: z.literal(schemaVersion),
         kind: z.literal(kind),
         digest: sha256DigestSchema,
         material,
@@ -499,10 +462,9 @@ function planEvidenceSchema(schemaVersion, kind, material) {
         }
     });
 }
-export const agentCandidateProfilePlanEvidenceSchema = planEvidenceSchema(1, "agent-profile-workspace-plan", agentCandidateProfilePlanMaterialSchema);
+export const agentCandidateProfilePlanEvidenceSchema = planEvidenceSchema("agent-profile-workspace-plan", agentCandidateProfilePlanMaterialSchema);
 export const agentCandidateProfileActivationSchema = z
     .object({
-    schemaVersion: z.literal(1),
     kind: z.literal("agent-candidate-profile-activation"),
     profilePlan: agentCandidateProfilePlanEvidenceSchema,
     files: z.array(z
@@ -550,4 +512,4 @@ export const agentCandidateProfileActivationSchema = z
         });
     }
 });
-export const agentCandidateExecutionPlanEvidenceSchema = planEvidenceSchema(2, "agent-candidate-execution-plan", agentCandidateExecutionPlanMaterialSchema);
+export const agentCandidateExecutionPlanEvidenceSchema = planEvidenceSchema("agent-candidate-execution-plan", agentCandidateExecutionPlanMaterialSchema);

package/dist/agent-candidate-lineage-schema.d.ts

@@ -1,7 +1,6 @@
 import { z } from "zod";
 export declare const agentCandidateKnowledgeSchema: z.ZodObject<{
     candidate: z.ZodObject<{
-        schemaVersion: z.ZodLiteral<1>;
         kind: z.ZodLiteral<"knowledge-improvement-candidate">;
         runId: z.ZodString;
         candidateId: z.ZodString;
@@ -12,11 +11,9 @@ export declare const agentCandidateKnowledgeSchema: z.ZodObject<{
         promotionPlanHash: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     }, z.core.$strict>;
     snapshot: z.ZodObject<{
-        schemaVersion: z.ZodLiteral<2>;
         kind: z.ZodLiteral<"agent-candidate-workspace-snapshot">;
         digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
         material: z.ZodObject<{
-            schemaVersion: z.ZodLiteral<2>;
             kind: z.ZodLiteral<"agent-candidate-workspace-manifest">;
             files: z.ZodArray<z.ZodObject<{
                 path: z.ZodString;
@@ -123,13 +120,6 @@ export declare const agentCandidateMemoryPolicySchema: z.ZodDiscriminatedUnion<[
         byteLength: z.ZodNumber;
     }, z.core.$strict>>;
 }, z.core.$strict>], "mode">;
-export declare const agentCandidateSpendSchema: z.ZodObject<{
-    costUsd: z.ZodNumber;
-    inputTokens: z.ZodNumber;
-    outputTokens: z.ZodNumber;
-    cachedInputTokens: z.ZodOptional<z.ZodNumber>;
-    modelCalls: z.ZodNumber;
-}, z.core.$strict>;
 export declare const agentCandidateLineageSchema: z.ZodObject<{
     source: z.ZodEnum<{
         optimizer: "optimizer";
@@ -141,25 +131,5 @@ export declare const agentCandidateLineageSchema: z.ZodObject<{
     runIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     profileDiffIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     modelSnapshots: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    benchmark: z.ZodOptional<z.ZodObject<{
-        name: z.ZodString;
-        version: z.ZodString;
-        splitDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
-    }, z.core.$strict>>;
-    spend: z.ZodOptional<z.ZodObject<{
-        proposal: z.ZodObject<{
-            costUsd: z.ZodNumber;
-            inputTokens: z.ZodNumber;
-            outputTokens: z.ZodNumber;
-            cachedInputTokens: z.ZodOptional<z.ZodNumber>;
-            modelCalls: z.ZodNumber;
-        }, z.core.$strict>;
-        evaluation: z.ZodObject<{
-            costUsd: z.ZodNumber;
-            inputTokens: z.ZodNumber;
-            outputTokens: z.ZodNumber;
-            cachedInputTokens: z.ZodOptional<z.ZodNumber>;
-            modelCalls: z.ZodNumber;
-        }, z.core.$strict>;
-    }, z.core.$strict>>;
+    developmentSplitDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
 }, z.core.$strict>;

package/dist/agent-candidate-lineage-schema.js

@@ -5,7 +5,6 @@ export const agentCandidateKnowledgeSchema = z
     .object({
     candidate: z
         .object({
-        schemaVersion: z.literal(1),
         kind: z.literal("knowledge-improvement-candidate"),
         runId: z.string().min(1),
         candidateId: z.string().min(1),
@@ -31,15 +30,6 @@ export const agentCandidateMemoryPolicySchema = z.discriminatedUnion("mode", [
     })
         .strict(),
 ]);
-export const agentCandidateSpendSchema = z
-    .object({
-    costUsd: z.number().finite().nonnegative(),
-    inputTokens: z.number().int().nonnegative(),
-    outputTokens: z.number().int().nonnegative(),
-    cachedInputTokens: z.number().int().nonnegative().optional(),
-    modelCalls: z.number().int().nonnegative(),
-})
-    .strict();
 export const agentCandidateLineageSchema = z
     .object({
     source: z.enum(["optimizer", "human", "import", "compound"]),
@@ -47,21 +37,7 @@ export const agentCandidateLineageSchema = z
     runIds: z.array(z.string().min(1)).optional(),
     profileDiffIds: z.array(z.string().min(1)).optional(),
     modelSnapshots: z.array(z.string().min(1)).optional(),
-    benchmark: z
-        .object({
-        name: z.string().min(1),
-        version: z.string().min(1),
-        splitDigest: sha256DigestSchema,
-    })
-        .strict()
-        .optional(),
-    spend: z
-        .object({
-        proposal: agentCandidateSpendSchema,
-        evaluation: agentCandidateSpendSchema,
-    })
-        .strict()
-        .optional(),
+    developmentSplitDigest: sha256DigestSchema.optional(),
 })
     .strict()
     .superRefine((lineage, ctx) => {
@@ -92,19 +68,12 @@ export const agentCandidateLineageSchema = z
                 message: "generated candidates must name their producing run",
             });
         }
-        if (lineage.benchmark === undefined) {
+        if (lineage.developmentSplitDigest === undefined) {
             ctx.addIssue({
                 code: "custom",
-                path: ["benchmark"],
+                path: ["developmentSplitDigest"],
                 message: "generated candidates must pin their development split",
             });
         }
-        if (lineage.spend === undefined) {
-            ctx.addIssue({
-                code: "custom",
-                path: ["spend"],
-                message: "generated candidates must record proposal and evaluation spend",
-            });
-        }
     }
 });