@tangle-network/agent-interface 0.24.0 → 0.26.0

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { agentCandidateCapturedArtifactSchema, agentCandidateWorkspaceSnapshotEvidenceSchema, } from "./agent-candidate-artifact-schema.js";
+import { agentCandidateArtifactRefSchema, agentCandidateCapturedArtifactSchema, agentCandidateWorkspaceSnapshotEvidenceSchema, } from "./agent-candidate-artifact-schema.js";
 import { agentCandidateContainerSchema, agentCandidateInstructionDeliverySchema, agentCandidateWorkingDirectorySchema, } from "./agent-candidate-code-schema.js";
-import { addDuplicateIssues, agentCandidateConfigValueSchema, environmentConfigSchema, gitObjectSchema, isCanonicalJsonValue, isObviouslyPrivateHostname, isSafeExecutable, isSafeRelativePath, sameGitObjectFormat, sha256DigestSchema, } from "./agent-candidate-schema-common.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",
@@ -140,9 +140,19 @@ export const agentCandidateExecutionLimitsSchema = z
     maxCostUsd: z.number().finite().nonnegative(),
 })
     .strict();
+export const agentCandidateTaskOutcomeSpecSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("workspace") }).strict(),
+    z
+        .object({
+        kind: z.literal("output"),
+        mediaType: agentCandidateMediaTypeSchema,
+        maxBytes: z.number().int().positive().max(64 * 1024 * 1024),
+    })
+        .strict(),
+]);
 export const agentCandidateExecutionPlanMaterialSchema = z
     .object({
-    schemaVersion: z.literal(1),
+    schemaVersion: z.literal(2),
     kind: z.literal("agent-candidate-execution-plan-material"),
     bundleDigest: sha256DigestSchema,
     executionId: z.string().min(1),
@@ -174,7 +184,9 @@ export const agentCandidateExecutionPlanMaterialSchema = z
             baseCommit: gitObjectSchema,
             baseTree: gitObjectSchema,
         })
-            .strict(),
+            .strict()
+            .optional(),
+        outcome: agentCandidateTaskOutcomeSpecSchema,
         workspace: agentCandidateWorkspaceSnapshotEvidenceSchema,
     })
         .strict(),
@@ -258,6 +270,13 @@ 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
@@ -275,13 +294,22 @@ export const agentCandidateExecutionPlanMaterialSchema = z
 })
     .strict()
     .superRefine((material, ctx) => {
-    if (!sameGitObjectFormat(material.task.repository.baseCommit, material.task.repository.baseTree)) {
+    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",
@@ -429,7 +457,8 @@ export const agentCandidateExecutionPlanMaterialSchema = z
             message: "active candidate workspaces cannot be empty",
         });
     }
-    if (material.task.workspace.material.files.length === 0) {
+    if (material.task.outcome.kind === "workspace" &&
+        material.task.workspace.material.files.length === 0) {
         ctx.addIssue({
             code: "custom",
             path: ["task", "workspace", "material", "files"],
@@ -443,10 +472,10 @@ export const agentCandidateExecutionPlanMaterialSchema = z
         });
     }
 });
-function planEvidenceSchema(kind, material) {
+function planEvidenceSchema(schemaVersion, kind, material) {
     return z
         .object({
-        schemaVersion: z.literal(1),
+        schemaVersion: z.literal(schemaVersion),
         kind: z.literal(kind),
         digest: sha256DigestSchema,
         material,
@@ -470,5 +499,55 @@ function planEvidenceSchema(kind, material) {
         }
     });
 }
-export const agentCandidateProfilePlanEvidenceSchema = planEvidenceSchema("agent-profile-workspace-plan", agentCandidateProfilePlanMaterialSchema);
-export const agentCandidateExecutionPlanEvidenceSchema = planEvidenceSchema("agent-candidate-execution-plan", agentCandidateExecutionPlanMaterialSchema);
+export const agentCandidateProfilePlanEvidenceSchema = planEvidenceSchema(1, "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
+        .object({
+        path: z
+            .string()
+            .refine((value) => isSafeRelativePath(value, false), "profile activation file must use a canonical relative path"),
+        mode: z.number().int().min(0).max(0o777),
+        content: z
+            .string()
+            .refine(isWellFormedUnicode, "profile activation content must be valid Unicode"),
+    })
+        .strict()),
+    digest: sha256DigestSchema,
+})
+    .strict()
+    .superRefine((activation, ctx) => {
+    const planned = activation.profilePlan.material.files;
+    if (activation.files.length !== planned.length) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["files"],
+            message: "profile activation must contain every planned native file",
+        });
+    }
+    for (let index = 0; index < planned.length; index++) {
+        const expected = planned[index];
+        const actual = activation.files[index];
+        if (expected === undefined ||
+            actual === undefined ||
+            actual.path !== expected.relPath ||
+            actual.mode !== expected.mode ||
+            sha256Utf8(actual.content) !== expected.contentSha256) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["files", index],
+                message: "profile activation file path, mode, and content must match the canonical plan",
+            });
+        }
+    }
+    if (!isCanonicalJsonValue(activation)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "profile activation must contain only RFC 8785 JSON values",
+        });
+    }
+});
+export const agentCandidateExecutionPlanEvidenceSchema = planEvidenceSchema(2, "agent-candidate-execution-plan", agentCandidateExecutionPlanMaterialSchema);

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

@@ -1,7 +1,70 @@
 import { z } from "zod";
 export declare const agentCandidateKnowledgeSchema: z.ZodObject<{
-    snapshotId: z.ZodString;
-    manifest: z.ZodObject<{
+    candidate: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        kind: z.ZodLiteral<"knowledge-improvement-candidate">;
+        runId: z.ZodString;
+        candidateId: z.ZodString;
+        goalHash: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        baseHash: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        candidateHash: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        evidenceHash: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        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;
+                mode: z.ZodNumber;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        manifest: z.ZodUnion<readonly [z.ZodObject<{
+            locator: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"s3">;
+                bucket: z.ZodString;
+                key: z.ZodString;
+                region: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"ipfs">;
+                cid: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>], "kind">;
+            sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            encoding: z.ZodLiteral<"base64">;
+            content: z.ZodString;
+            sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>]>;
+        archive: z.ZodUnion<readonly [z.ZodObject<{
+            locator: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"s3">;
+                bucket: z.ZodString;
+                key: z.ZodString;
+                region: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"ipfs">;
+                cid: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>], "kind">;
+            sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            encoding: z.ZodLiteral<"base64">;
+            content: z.ZodString;
+            sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>;
+    retrievalConfig: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
         locator: z.ZodDiscriminatedUnion<[z.ZodObject<{
             kind: z.ZodLiteral<"s3">;
             bucket: z.ZodString;
@@ -14,7 +77,31 @@ export declare const agentCandidateKnowledgeSchema: z.ZodObject<{
         }, z.core.$strict>], "kind">;
         sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
         byteLength: z.ZodNumber;
-    }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        encoding: z.ZodLiteral<"base64">;
+        content: z.ZodString;
+        sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        byteLength: z.ZodNumber;
+    }, z.core.$strict>]>>;
+    evaluation: z.ZodUnion<readonly [z.ZodObject<{
+        locator: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"s3">;
+            bucket: z.ZodString;
+            key: z.ZodString;
+            region: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"ipfs">;
+            cid: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "kind">;
+        sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        byteLength: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        encoding: z.ZodLiteral<"base64">;
+        content: z.ZodString;
+        sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        byteLength: z.ZodNumber;
+    }, z.core.$strict>]>;
 }, z.core.$strict>;
 export declare const agentCandidateMemoryPolicySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     mode: z.ZodLiteral<"disabled">;

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

@@ -1,10 +1,24 @@
 import { z } from "zod";
-import { agentCandidateArtifactRefSchema } from "./agent-candidate-artifact-schema.js";
+import { agentCandidateArtifactRefSchema, agentCandidateCapturedArtifactSchema, agentCandidateWorkspaceSnapshotEvidenceSchema, } from "./agent-candidate-artifact-schema.js";
 import { addDuplicateIssues, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
 export const agentCandidateKnowledgeSchema = z
     .object({
-    snapshotId: z.string().min(1),
-    manifest: agentCandidateArtifactRefSchema,
+    candidate: z
+        .object({
+        schemaVersion: z.literal(1),
+        kind: z.literal("knowledge-improvement-candidate"),
+        runId: z.string().min(1),
+        candidateId: z.string().min(1),
+        goalHash: sha256DigestSchema,
+        baseHash: sha256DigestSchema,
+        candidateHash: sha256DigestSchema,
+        evidenceHash: sha256DigestSchema,
+        promotionPlanHash: sha256DigestSchema,
+    })
+        .strict(),
+    snapshot: agentCandidateWorkspaceSnapshotEvidenceSchema,
+    retrievalConfig: agentCandidateCapturedArtifactSchema.optional(),
+    evaluation: agentCandidateCapturedArtifactSchema,
 })
     .strict();
 export const agentCandidateMemoryPolicySchema = z.discriminatedUnion("mode", [