@tangle-network/agent-interface 0.27.2 → 0.29.0

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

@@ -70,10 +70,8 @@ export declare const agentCandidateModelSettlementMaterialSchema: z.ZodObject<{
         modelCalls: z.ZodNumber;
         costUsdNanos: z.ZodNumber;
     }, z.core.$strict>;
-    schemaVersion: z.ZodLiteral<2>;
 }, z.core.$strict>;
 export declare const agentCandidateModelSettlementEvidenceSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<2>;
     kind: z.ZodLiteral<"agent-candidate-model-settlement">;
     digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     material: z.ZodType<{
@@ -111,7 +109,6 @@ export declare const agentCandidateModelSettlementEvidenceSchema: z.ZodObject<{
             modelCalls: number;
             costUsdNanos: number;
         };
-        schemaVersion: 2;
     }, unknown, z.core.$ZodTypeInternals<{
         calls: {
             callId: string;
@@ -147,7 +144,6 @@ export declare const agentCandidateModelSettlementEvidenceSchema: z.ZodObject<{
             modelCalls: number;
             costUsdNanos: number;
         };
-        schemaVersion: 2;
     }, unknown>>;
     artifact: z.ZodUnion<readonly [z.ZodObject<{
         locator: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -176,7 +172,6 @@ export declare const agentCandidateRepositoryStateSchema: z.ZodObject<{
     tree: z.ZodString;
 }, z.core.$strict>;
 export declare const agentCandidateTaskOutcomeMaterialSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<2>;
     kind: z.ZodLiteral<"agent-candidate-task-outcome-material">;
     executionPlanDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     outcome: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -194,11 +189,9 @@ export declare const agentCandidateTaskOutcomeMaterialSchema: z.ZodObject<{
             tree: z.ZodString;
         }, z.core.$strict>;
         afterState: 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;
@@ -286,11 +279,9 @@ export declare const agentCandidateTaskOutcomeMaterialSchema: z.ZodObject<{
     }, z.core.$strict>], "kind">;
 }, z.core.$strict>;
 export declare const agentCandidateTaskOutcomeEvidenceSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<2>;
     kind: z.ZodLiteral<"agent-candidate-task-outcome">;
     digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     material: z.ZodType<{
-        schemaVersion: 2;
         kind: "agent-candidate-task-outcome-material";
         executionPlanDigest: `sha256:${string}`;
         outcome: {
@@ -308,11 +299,9 @@ export declare const agentCandidateTaskOutcomeEvidenceSchema: z.ZodObject<{
                 tree: string;
             };
             afterState: {
-                schemaVersion: 2;
                 kind: "agent-candidate-workspace-snapshot";
                 digest: `sha256:${string}`;
                 material: {
-                    schemaVersion: 2;
                     kind: "agent-candidate-workspace-manifest";
                     files: {
                         path: string;
@@ -399,7 +388,6 @@ export declare const agentCandidateTaskOutcomeEvidenceSchema: z.ZodObject<{
             };
         };
     }, unknown, z.core.$ZodTypeInternals<{
-        schemaVersion: 2;
         kind: "agent-candidate-task-outcome-material";
         executionPlanDigest: `sha256:${string}`;
         outcome: {
@@ -417,11 +405,9 @@ export declare const agentCandidateTaskOutcomeEvidenceSchema: z.ZodObject<{
                 tree: string;
             };
             afterState: {
-                schemaVersion: 2;
                 kind: "agent-candidate-workspace-snapshot";
                 digest: `sha256:${string}`;
                 material: {
-                    schemaVersion: 2;
                     kind: "agent-candidate-workspace-manifest";
                     files: {
                         path: string;
@@ -533,19 +519,13 @@ export declare const agentCandidateBenchmarkDimensionSchema: z.ZodObject<{
     score: z.ZodNumber;
 }, z.core.$strict>;
 export declare const agentCandidateBenchmarkResultMaterialSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
     kind: z.ZodLiteral<"agent-candidate-benchmark-result-material">;
     executionPlanDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     taskOutcomeDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
-    benchmark: z.ZodObject<{
-        name: z.ZodString;
-        version: z.ZodString;
-        taskId: z.ZodString;
-        splitDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
-    }, z.core.$strict>;
     grader: z.ZodObject<{
         name: z.ZodString;
         version: z.ZodString;
+        format: z.ZodLiteral<"tangle-grader">;
         artifact: z.ZodObject<{
             locator: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 kind: z.ZodLiteral<"s3">;
@@ -575,6 +555,21 @@ export declare const agentCandidateBenchmarkResultMaterialSchema: z.ZodObject<{
         sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
         byteLength: z.ZodNumber;
     }, z.core.$strict>;
+    grading: z.ZodObject<{
+        usage: z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            cachedInputTokens: z.ZodNumber;
+            reasoningTokens: z.ZodNumber;
+            modelCalls: z.ZodNumber;
+            costUsdNanos: z.ZodNumber;
+        }, z.core.$strict>;
+        timing: z.ZodObject<{
+            startedAtMs: z.ZodNumber;
+            endedAtMs: z.ZodNumber;
+            durationMs: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
     score: z.ZodNumber;
     passed: z.ZodBoolean;
     dimensions: z.ZodArray<z.ZodObject<{
@@ -583,23 +578,16 @@ export declare const agentCandidateBenchmarkResultMaterialSchema: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const agentCandidateBenchmarkResultEvidenceSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
     kind: z.ZodLiteral<"agent-candidate-benchmark-result">;
     digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     material: z.ZodType<{
-        schemaVersion: 1;
         kind: "agent-candidate-benchmark-result-material";
         executionPlanDigest: `sha256:${string}`;
         taskOutcomeDigest: `sha256:${string}`;
-        benchmark: {
-            name: string;
-            version: string;
-            taskId: string;
-            splitDigest: `sha256:${string}`;
-        };
         grader: {
             name: string;
             version: string;
+            format: "tangle-grader";
             artifact: {
                 locator: {
                     kind: "s3";
@@ -629,6 +617,21 @@ export declare const agentCandidateBenchmarkResultEvidenceSchema: z.ZodObject<{
             sha256: `sha256:${string}`;
             byteLength: number;
         };
+        grading: {
+            usage: {
+                inputTokens: number;
+                outputTokens: number;
+                cachedInputTokens: number;
+                reasoningTokens: number;
+                modelCalls: number;
+                costUsdNanos: number;
+            };
+            timing: {
+                startedAtMs: number;
+                endedAtMs: number;
+                durationMs: number;
+            };
+        };
         score: number;
         passed: boolean;
         dimensions: {
@@ -636,19 +639,13 @@ export declare const agentCandidateBenchmarkResultEvidenceSchema: z.ZodObject<{
             score: number;
         }[];
     }, unknown, z.core.$ZodTypeInternals<{
-        schemaVersion: 1;
         kind: "agent-candidate-benchmark-result-material";
         executionPlanDigest: `sha256:${string}`;
         taskOutcomeDigest: `sha256:${string}`;
-        benchmark: {
-            name: string;
-            version: string;
-            taskId: string;
-            splitDigest: `sha256:${string}`;
-        };
         grader: {
             name: string;
             version: string;
+            format: "tangle-grader";
             artifact: {
                 locator: {
                     kind: "s3";
@@ -678,6 +675,21 @@ export declare const agentCandidateBenchmarkResultEvidenceSchema: z.ZodObject<{
             sha256: `sha256:${string}`;
             byteLength: number;
         };
+        grading: {
+            usage: {
+                inputTokens: number;
+                outputTokens: number;
+                cachedInputTokens: number;
+                reasoningTokens: number;
+                modelCalls: number;
+                costUsdNanos: number;
+            };
+            timing: {
+                startedAtMs: number;
+                endedAtMs: number;
+                durationMs: number;
+            };
+        };
         score: number;
         passed: boolean;
         dimensions: {

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { agentCandidateArtifactRefSchema, agentCandidateCapturedArtifactSchema, agentCandidateWorkspaceSnapshotEvidenceSchema, } from "./agent-candidate-artifact-schema.js";
-import { agentCandidateResolvedModelSchema } from "./agent-candidate-execution-plan-schema.js";
+import { agentCandidateBenchmarkGraderIdentitySchema, agentCandidateResolvedModelSchema, } from "./agent-candidate-execution-plan-schema.js";
 import { agentCandidateMediaTypeSchema, gitObjectSchema, isCanonicalJsonValue, sameGitObjectFormat, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
 const safeCountSchema = z
     .number()
@@ -66,7 +66,6 @@ const modelSettlementMaterialShape = {
 };
 export const agentCandidateModelSettlementMaterialSchema = z
     .object({
-    schemaVersion: z.literal(2),
     ...modelSettlementMaterialShape,
     calls: z.array(agentCandidateModelSettlementCallSchema),
 })
@@ -150,7 +149,7 @@ function refineModelSettlementMaterial(material, ctx) {
         });
     }
 }
-export const agentCandidateModelSettlementEvidenceSchema = evidenceSchema(2, "agent-candidate-model-settlement", agentCandidateModelSettlementMaterialSchema, "model settlement");
+export const agentCandidateModelSettlementEvidenceSchema = evidenceSchema("agent-candidate-model-settlement", agentCandidateModelSettlementMaterialSchema, "model settlement");
 export const agentCandidateRepositoryStateSchema = z
     .object({
     identity: z.string().min(1),
@@ -170,7 +169,6 @@ export const agentCandidateRepositoryStateSchema = z
 });
 export const agentCandidateTaskOutcomeMaterialSchema = z
     .object({
-    schemaVersion: z.literal(2),
     kind: z.literal("agent-candidate-task-outcome-material"),
     executionPlanDigest: sha256DigestSchema,
     outcome: z.discriminatedUnion("kind", [
@@ -255,7 +253,7 @@ export const agentCandidateTaskOutcomeMaterialSchema = z
         });
     }
 });
-export const agentCandidateTaskOutcomeEvidenceSchema = evidenceSchema(2, "agent-candidate-task-outcome", agentCandidateTaskOutcomeMaterialSchema, "task outcome");
+export const agentCandidateTaskOutcomeEvidenceSchema = evidenceSchema("agent-candidate-task-outcome", agentCandidateTaskOutcomeMaterialSchema, "task outcome");
 export const agentCandidateBenchmarkDimensionSchema = z
     .object({
     name: normalizedDimensionNameSchema,
@@ -264,39 +262,29 @@ export const agentCandidateBenchmarkDimensionSchema = z
     .strict();
 export const agentCandidateBenchmarkResultMaterialSchema = z
     .object({
-    schemaVersion: z.literal(1),
     kind: z.literal("agent-candidate-benchmark-result-material"),
     executionPlanDigest: sha256DigestSchema,
     taskOutcomeDigest: sha256DigestSchema,
-    benchmark: z
-        .object({
-        name: z.string().min(1),
-        version: z.string().min(1),
-        taskId: z.string().min(1),
-        splitDigest: sha256DigestSchema,
-    })
-        .strict(),
-    grader: z
+    grader: agentCandidateBenchmarkGraderIdentitySchema,
+    evidence: agentCandidateArtifactRefSchema,
+    grading: z
         .object({
-        name: z.string().min(1),
-        version: z.string().min(1),
-        artifact: agentCandidateArtifactRefSchema,
+        usage: agentCandidateFixedSpendSchema,
+        timing: z
+            .object({
+            startedAtMs: safeCountSchema,
+            endedAtMs: safeCountSchema,
+            durationMs: safeCountSchema,
+        })
+            .strict(),
     })
         .strict(),
-    evidence: agentCandidateArtifactRefSchema,
     score: normalizedScoreSchema,
     passed: z.boolean(),
     dimensions: z.array(agentCandidateBenchmarkDimensionSchema),
 })
     .strict()
     .superRefine((material, ctx) => {
-    if (material.grader.artifact.byteLength === 0) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["grader", "artifact", "byteLength"],
-            message: "pinned grader artifact must contain executable grader bytes",
-        });
-    }
     if (material.evidence.byteLength === 0) {
         ctx.addIssue({
             code: "custom",
@@ -304,11 +292,15 @@ export const agentCandidateBenchmarkResultMaterialSchema = z
             message: "benchmark result must contain non-empty durable grading evidence",
         });
     }
-    if (material.evidence.sha256 === material.grader.artifact.sha256) {
+    if (material.grading.timing.endedAtMs <
+        material.grading.timing.startedAtMs ||
+        material.grading.timing.durationMs !==
+            material.grading.timing.endedAtMs -
+                material.grading.timing.startedAtMs) {
         ctx.addIssue({
             code: "custom",
-            path: ["evidence", "sha256"],
-            message: "grading evidence must be distinct from the grader implementation",
+            path: ["grading", "timing"],
+            message: "grader timing must be ordered and internally consistent",
         });
     }
     for (let index = 1; index < material.dimensions.length; index++) {
@@ -329,7 +321,7 @@ export const agentCandidateBenchmarkResultMaterialSchema = z
         });
     }
 });
-export const agentCandidateBenchmarkResultEvidenceSchema = evidenceSchema(1, "agent-candidate-benchmark-result", agentCandidateBenchmarkResultMaterialSchema, "benchmark result");
+export const agentCandidateBenchmarkResultEvidenceSchema = evidenceSchema("agent-candidate-benchmark-result", agentCandidateBenchmarkResultMaterialSchema, "benchmark result");
 function sameFixedSpend(left, right) {
     return (left.inputTokens === right.inputTokens &&
         left.outputTokens === right.outputTokens &&
@@ -338,10 +330,9 @@ function sameFixedSpend(left, right) {
         left.modelCalls === right.modelCalls &&
         left.costUsdNanos === right.costUsdNanos);
 }
-function evidenceSchema(schemaVersion, kind, material, label) {
+function evidenceSchema(kind, material, label) {
     return z
         .object({
-        schemaVersion: z.literal(schemaVersion),
         kind: z.literal(kind),
         digest: sha256DigestSchema,
         material,