@tangle-network/agent-interface 0.20.0 → 0.22.0

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

@@ -0,0 +1,293 @@
+import { z } from "zod";
+import { agentCandidateArtifactRefSchema, agentCandidateCapturedArtifactSchema, agentCandidateWorkspaceSnapshotEvidenceSchema, } from "./agent-candidate-artifact-schema.js";
+import { agentCandidateResolvedModelSchema } from "./agent-candidate-execution-plan-schema.js";
+import { gitObjectSchema, isCanonicalJsonValue, sameGitObjectFormat, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
+const safeCountSchema = z
+    .number()
+    .int()
+    .nonnegative()
+    .refine(Number.isSafeInteger, "value must be a nonnegative safe integer");
+const boundedIdentifierSchema = z.string().min(1).max(256);
+const normalizedDimensionNameSchema = z
+    .string()
+    .regex(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/, "dimension names must be normalized lowercase identifiers");
+const normalizedScoreSchema = z.number().finite().min(0).max(1);
+export const agentCandidateFixedSpendSchema = z
+    .object({
+    inputTokens: safeCountSchema,
+    outputTokens: safeCountSchema,
+    cachedInputTokens: safeCountSchema,
+    reasoningTokens: safeCountSchema,
+    modelCalls: safeCountSchema,
+    costUsdNanos: safeCountSchema,
+})
+    .strict();
+export const agentCandidateModelSettlementCallSchema = z
+    .object({
+    callId: boundedIdentifierSchema,
+    traceSpanId: boundedIdentifierSchema,
+    model: boundedIdentifierSchema,
+    inputTokens: safeCountSchema,
+    outputTokens: safeCountSchema,
+    cachedInputTokens: safeCountSchema,
+    reasoningTokens: safeCountSchema,
+    costUsdNanos: safeCountSchema,
+})
+    .strict();
+export const agentCandidateModelSettlementMaterialSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    kind: z.literal("agent-candidate-model-settlement-material"),
+    executionPlanDigest: sha256DigestSchema,
+    preparationId: boundedIdentifierSchema,
+    grantDigest: sha256DigestSchema,
+    closed: z.literal(true),
+    resolved: agentCandidateResolvedModelSchema,
+    calls: z.array(agentCandidateModelSettlementCallSchema),
+    usage: agentCandidateFixedSpendSchema,
+})
+    .strict()
+    .superRefine((material, ctx) => {
+    const callIds = new Set();
+    const traceSpanIds = new Set();
+    const totals = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cachedInputTokens: 0,
+        reasoningTokens: 0,
+        modelCalls: material.calls.length,
+        costUsdNanos: 0,
+    };
+    for (const [index, call] of material.calls.entries()) {
+        if (callIds.has(call.callId)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["calls", index, "callId"],
+                message: "model settlement call ids must be unique",
+            });
+        }
+        callIds.add(call.callId);
+        if (traceSpanIds.has(call.traceSpanId)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["calls", index, "traceSpanId"],
+                message: "model settlement trace span ids must be unique",
+            });
+        }
+        traceSpanIds.add(call.traceSpanId);
+        if (call.model !== material.resolved.model) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["calls", index, "model"],
+                message: "settled call model must match the resolved single model",
+            });
+        }
+        for (const field of [
+            "inputTokens",
+            "outputTokens",
+            "cachedInputTokens",
+            "reasoningTokens",
+            "costUsdNanos",
+        ]) {
+            const sum = totals[field] + call[field];
+            if (!Number.isSafeInteger(sum)) {
+                ctx.addIssue({
+                    code: "custom",
+                    path: ["calls", index, field],
+                    message: `model settlement ${field} total exceeds safe integer range`,
+                });
+            }
+            else {
+                totals[field] = sum;
+            }
+        }
+    }
+    if (!sameFixedSpend(totals, material.usage)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["usage"],
+            message: "model settlement usage must equal the exact per-call aggregate",
+        });
+    }
+    if (!isCanonicalJsonValue(material)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "model settlement material must contain only RFC 8785 JSON values",
+        });
+    }
+});
+export const agentCandidateModelSettlementEvidenceSchema = evidenceSchema("agent-candidate-model-settlement", agentCandidateModelSettlementMaterialSchema, "model settlement");
+export const agentCandidateRepositoryStateSchema = z
+    .object({
+    identity: z.string().min(1),
+    rootIdentity: z.string().min(1),
+    commit: gitObjectSchema,
+    tree: gitObjectSchema,
+})
+    .strict()
+    .superRefine((state, ctx) => {
+    if (!sameGitObjectFormat(state.commit, state.tree)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["tree"],
+            message: "repository commit and tree must use the same Git object format",
+        });
+    }
+});
+export const agentCandidateTaskOutcomeMaterialSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    kind: z.literal("agent-candidate-task-outcome-material"),
+    executionPlanDigest: sha256DigestSchema,
+    baseRepository: agentCandidateRepositoryStateSchema,
+    resultRepository: agentCandidateRepositoryStateSchema,
+    afterState: agentCandidateWorkspaceSnapshotEvidenceSchema,
+    gitDiff: z
+        .object({
+        format: z.literal("git-diff-binary"),
+        artifact: agentCandidateArtifactRefSchema,
+    })
+        .strict(),
+})
+    .strict()
+    .superRefine((material, ctx) => {
+    if (material.baseRepository.identity !== material.resultRepository.identity) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["resultRepository", "identity"],
+            message: "base and result repository identities must match",
+        });
+    }
+    if (material.baseRepository.rootIdentity !==
+        material.resultRepository.rootIdentity) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["resultRepository", "rootIdentity"],
+            message: "base and result repository roots must match",
+        });
+    }
+    if (!sameGitObjectFormat(material.baseRepository.commit, material.resultRepository.commit) ||
+        !sameGitObjectFormat(material.baseRepository.tree, material.resultRepository.tree)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["resultRepository"],
+            message: "base and result repositories must use one Git object format",
+        });
+    }
+    if (!isCanonicalJsonValue(material)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "task outcome material must contain only RFC 8785 JSON values",
+        });
+    }
+});
+export const agentCandidateTaskOutcomeEvidenceSchema = evidenceSchema("agent-candidate-task-outcome", agentCandidateTaskOutcomeMaterialSchema, "task outcome");
+export const agentCandidateBenchmarkDimensionSchema = z
+    .object({
+    name: normalizedDimensionNameSchema,
+    score: normalizedScoreSchema,
+})
+    .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
+        .object({
+        name: z.string().min(1),
+        version: z.string().min(1),
+        artifact: agentCandidateArtifactRefSchema,
+    })
+        .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",
+            path: ["evidence", "byteLength"],
+            message: "benchmark result must contain non-empty durable grading evidence",
+        });
+    }
+    if (material.evidence.sha256 === material.grader.artifact.sha256) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["evidence", "sha256"],
+            message: "grading evidence must be distinct from the grader implementation",
+        });
+    }
+    for (let index = 1; index < material.dimensions.length; index++) {
+        const previous = material.dimensions[index - 1]?.name ?? "";
+        const current = material.dimensions[index]?.name ?? "";
+        if (previous >= current) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["dimensions", index, "name"],
+                message: "benchmark dimensions must be unique and lexicographically sorted",
+            });
+        }
+    }
+    if (!isCanonicalJsonValue(material)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "benchmark result material must contain only RFC 8785 JSON values",
+        });
+    }
+});
+export const agentCandidateBenchmarkResultEvidenceSchema = evidenceSchema("agent-candidate-benchmark-result", agentCandidateBenchmarkResultMaterialSchema, "benchmark result");
+export function sameFixedSpend(left, right) {
+    return (left.inputTokens === right.inputTokens &&
+        left.outputTokens === right.outputTokens &&
+        left.cachedInputTokens === right.cachedInputTokens &&
+        left.reasoningTokens === right.reasoningTokens &&
+        left.modelCalls === right.modelCalls &&
+        left.costUsdNanos === right.costUsdNanos);
+}
+function evidenceSchema(kind, material, label) {
+    return z
+        .object({
+        schemaVersion: z.literal(1),
+        kind: z.literal(kind),
+        digest: sha256DigestSchema,
+        material,
+        artifact: agentCandidateCapturedArtifactSchema,
+    })
+        .strict()
+        .superRefine((evidence, ctx) => {
+        if (evidence.artifact.sha256 !== evidence.digest) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["artifact", "sha256"],
+                message: `${label} artifact hash must equal its canonical material digest`,
+            });
+        }
+        if (evidence.artifact.byteLength === 0) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["artifact", "byteLength"],
+                message: `${label} artifact must contain canonical material bytes`,
+            });
+        }
+    });
+}

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

@@ -0,0 +1,267 @@
+import { z } from "zod";
+export declare const agentCandidateMcpServerSchema: z.ZodObject<{
+    transport: z.ZodOptional<z.ZodLiteral<"stdio">>;
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"public">;
+        value: z.ZodString;
+    }, z.core.$strict>>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        kind: z.ZodLiteral<"public">;
+        value: z.ZodString;
+    }, z.core.$strict>>>;
+    cwd: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const agentCandidateHookCommandSchema: z.ZodObject<{
+    executable: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"public">;
+        value: z.ZodString;
+    }, z.core.$strict>>>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    blocking: z.ZodOptional<z.ZodBoolean>;
+    matcher: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        kind: z.ZodLiteral<"public">;
+        value: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const agentCandidateProfileSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    prompt: z.ZodOptional<z.ZodObject<{
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        instructions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    model: z.ZodOptional<z.ZodObject<{
+        reasoningEffort: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+            ultracode: "ultracode";
+        }>>;
+        default: z.ZodOptional<z.ZodString>;
+        small: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    harness: z.ZodOptional<z.ZodEnum<{
+        "claude-code": "claude-code";
+        claude: "claude";
+        claudish: "claudish";
+        nanoclaw: "nanoclaw";
+        codex: "codex";
+        opencode: "opencode";
+        "kimi-code": "kimi-code";
+        kimi: "kimi";
+        pi: "pi";
+        gemini: "gemini";
+        hermes: "hermes";
+        openclaw: "openclaw";
+        amp: "amp";
+        "factory-droids": "factory-droids";
+        acp: "acp";
+        "cli-base": "cli-base";
+    }>>;
+    permissions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+        allow: "allow";
+        ask: "ask";
+        deny: "deny";
+    }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+        allow: "allow";
+        ask: "ask";
+        deny: "deny";
+    }>>]>>>;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    mcp: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        transport: z.ZodOptional<z.ZodLiteral<"stdio">>;
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodLiteral<"public">;
+            value: z.ZodString;
+        }, z.core.$strict>>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            kind: z.ZodLiteral<"public">;
+            value: z.ZodString;
+        }, z.core.$strict>>>;
+        cwd: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    subagents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        prompt: z.ZodOptional<z.ZodString>;
+        permissions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            deny: "deny";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            deny: "deny";
+        }>>]>>>;
+        tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+        description: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        maxSteps: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    resources: z.ZodOptional<z.ZodObject<{
+        files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            resource: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"inline">;
+                name: z.ZodString;
+                content: z.ZodString;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"github">;
+                repository: z.ZodObject<{
+                    kind: z.ZodLiteral<"github">;
+                    owner: z.ZodString;
+                    repo: z.ZodString;
+                }, z.core.$strict>;
+                path: z.ZodString;
+                commit: z.ZodString;
+                name: z.ZodOptional<z.ZodString>;
+                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+                byteLength: z.ZodNumber;
+            }, z.core.$strict>], "kind">;
+            executable: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"inline">;
+            name: z.ZodString;
+            content: z.ZodString;
+            sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"github">;
+            repository: z.ZodObject<{
+                kind: z.ZodLiteral<"github">;
+                owner: z.ZodString;
+                repo: z.ZodString;
+            }, z.core.$strict>;
+            path: z.ZodString;
+            commit: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>], "kind">>>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"inline">;
+            name: z.ZodString;
+            content: z.ZodString;
+            sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"github">;
+            repository: z.ZodObject<{
+                kind: z.ZodLiteral<"github">;
+                owner: z.ZodString;
+                repo: z.ZodString;
+            }, z.core.$strict>;
+            path: z.ZodString;
+            commit: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>], "kind">>>;
+        agents: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"inline">;
+            name: z.ZodString;
+            content: z.ZodString;
+            sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"github">;
+            repository: z.ZodObject<{
+                kind: z.ZodLiteral<"github">;
+                owner: z.ZodString;
+                repo: z.ZodString;
+            }, z.core.$strict>;
+            path: z.ZodString;
+            commit: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>], "kind">>>;
+        commands: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"inline">;
+            name: z.ZodString;
+            content: z.ZodString;
+            sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"github">;
+            repository: z.ZodObject<{
+                kind: z.ZodLiteral<"github">;
+                owner: z.ZodString;
+                repo: z.ZodString;
+            }, z.core.$strict>;
+            path: z.ZodString;
+            commit: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>], "kind">>>;
+        instructions: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"inline">;
+            name: z.ZodString;
+            content: z.ZodString;
+            sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"github">;
+            repository: z.ZodObject<{
+                kind: z.ZodLiteral<"github">;
+                owner: z.ZodString;
+                repo: z.ZodString;
+            }, z.core.$strict>;
+            path: z.ZodString;
+            commit: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            byteLength: z.ZodNumber;
+        }, z.core.$strict>], "kind">]>>;
+        failOnError: z.ZodLiteral<true>;
+    }, z.core.$strict>>;
+    hooks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        executable: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodLiteral<"public">;
+            value: z.ZodString;
+        }, z.core.$strict>>>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        blocking: z.ZodOptional<z.ZodBoolean>;
+        matcher: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            kind: z.ZodLiteral<"public">;
+            value: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>>;
+    modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        prompt: z.ZodOptional<z.ZodString>;
+        permissions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            deny: "deny";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            deny: "deny";
+        }>>]>>>;
+        tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+        description: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    confidential: z.ZodOptional<z.ZodObject<{
+        tee: z.ZodOptional<z.ZodString>;
+        attestationNonce: z.ZodOptional<z.ZodString>;
+        sealed: z.ZodOptional<z.ZodBoolean>;
+        attestationRefresh: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;

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

@@ -0,0 +1,125 @@
+import { z } from "zod";
+import { agentCandidateResourcesSchema } from "./agent-candidate-artifact-schema.js";
+import { agentCandidateConfigValueSchema, environmentConfigSchema, isCanonicalJsonValue, isSafeExecutable, isSafeRelativePath, isWellFormedUnicode, } from "./agent-candidate-schema-common.js";
+import { harnessTypeSchema } from "./harness.js";
+import { agentProfileConfidentialSchema, agentProfileModeSchema, agentProfileModelHintsSchema, agentProfilePermissionSchema, agentProfilePromptSchema, agentSubagentProfileSchema, } from "./profile-schema.js";
+const executableSchema = z
+    .string()
+    .refine(isSafeExecutable, "executable must be a canonical non-shell command");
+export const agentCandidateMcpServerSchema = z
+    .object({
+    transport: z.literal("stdio").optional(),
+    command: executableSchema.optional(),
+    args: z.array(agentCandidateConfigValueSchema).optional(),
+    env: environmentConfigSchema.optional(),
+    cwd: z
+        .string()
+        .refine((value) => isSafeRelativePath(value, true), "MCP cwd must be a canonical workspace-relative path")
+        .optional(),
+    enabled: z.boolean().optional(),
+})
+    .strict()
+    .superRefine((server, ctx) => {
+    if (server.enabled === false) {
+        if (server.transport !== undefined ||
+            server.command !== undefined ||
+            server.args !== undefined ||
+            server.env !== undefined ||
+            server.cwd !== undefined) {
+            ctx.addIssue({
+                code: "custom",
+                message: "disabled MCP servers cannot carry process fields",
+            });
+        }
+        return;
+    }
+    if (server.command === undefined) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["command"],
+            message: "enabled stdio MCP servers require a command",
+        });
+    }
+});
+export const agentCandidateHookCommandSchema = z
+    .object({
+    executable: executableSchema,
+    args: z.array(agentCandidateConfigValueSchema).optional(),
+    timeoutMs: z.number().positive().optional(),
+    blocking: z.boolean().optional(),
+    matcher: z.string().refine(isWellFormedUnicode).optional(),
+    env: environmentConfigSchema.optional(),
+})
+    .strict();
+const candidateModelHintsSchema = agentProfileModelHintsSchema
+    .omit({ metadata: true })
+    .extend({
+    default: z.string().min(1).optional(),
+    small: z.string().min(1).optional(),
+    provider: z.string().min(1).optional(),
+})
+    .strict();
+const candidateSubagentSchema = agentSubagentProfileSchema
+    .omit({ metadata: true })
+    .extend({
+    model: z.string().min(1).optional(),
+    maxSteps: z.number().int().positive().optional(),
+})
+    .strict();
+const candidateModeSchema = agentProfileModeSchema
+    .omit({ metadata: true })
+    .extend({ model: z.string().min(1).optional() })
+    .strict();
+export const agentCandidateProfileSchema = z
+    .object({
+    name: z.string().refine(isWellFormedUnicode).optional(),
+    description: z.string().refine(isWellFormedUnicode).optional(),
+    version: z.string().refine(isWellFormedUnicode).optional(),
+    tags: z.array(z.string().refine(isWellFormedUnicode)).optional(),
+    prompt: agentProfilePromptSchema.strict().optional(),
+    model: candidateModelHintsSchema.optional(),
+    harness: harnessTypeSchema.optional(),
+    permissions: z
+        .record(z.string(), agentProfilePermissionSchema)
+        .optional(),
+    tools: z.record(z.string(), z.boolean()).optional(),
+    mcp: z.record(z.string(), agentCandidateMcpServerSchema).optional(),
+    subagents: z.record(z.string(), candidateSubagentSchema).optional(),
+    resources: agentCandidateResourcesSchema.optional(),
+    hooks: z
+        .record(z.string(), z.array(agentCandidateHookCommandSchema))
+        .optional(),
+    modes: z.record(z.string(), candidateModeSchema).optional(),
+    confidential: agentProfileConfidentialSchema.strict().optional(),
+})
+    .strict()
+    .superRefine((profile, ctx) => {
+    if (!isCanonicalJsonValue(profile)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "candidate profile must contain only RFC 8785 JSON values",
+        });
+    }
+    const primaryModel = profile.model?.default;
+    const alternateRoutes = [
+        ...(profile.model?.small === undefined
+            ? []
+            : [["model", "small", profile.model.small]]),
+        ...Object.entries(profile.subagents ?? {}).flatMap(([name, subagent]) => subagent.model === undefined
+            ? []
+            : [["subagents", name, "model", subagent.model]]),
+        ...Object.entries(profile.modes ?? {}).flatMap(([name, mode]) => mode.model === undefined
+            ? []
+            : [["modes", name, "model", mode.model]]),
+    ];
+    for (const route of alternateRoutes) {
+        const routeModel = route.at(-1);
+        if (primaryModel === undefined || routeModel !== primaryModel) {
+            ctx.addIssue({
+                code: "custom",
+                path: route.slice(0, -1),
+                message: "sealed candidates require every model route to use the exact primary model",
+            });
+        }
+    }
+});