@lssm/lib.contracts-spec 17.3.2

package/dist/agent/protocol/model-routing.d.ts

@@ -0,0 +1,206 @@
+import { z } from 'zod';
+export * from './model-route-contracts.js';
+export declare const AGENT_MODEL_SELECTION_V1: 'contractspec.agent.model-selection.v1';
+export declare const AGENT_MODEL_FALLBACK_DECISION_V1: 'contractspec.agent.model-fallback-decision.v1';
+export declare const agentModelHardConstraintsV1Schema: z.ZodObject<{
+    requiredCapabilityRefs: z.ZodArray<z.ZodString>;
+    minimumContextWindowTokens: z.ZodNumber;
+    minimumOutputTokens: z.ZodNumber;
+    requireStrictToolSchemas: z.ZodBoolean;
+    requireParallelToolCalls: z.ZodBoolean;
+    allowedProviderRefs: z.ZodArray<z.ZodString>;
+    allowedRegionRefs: z.ZodArray<z.ZodString>;
+    transportProfileRef: z.ZodString;
+    authenticationProfileRef: z.ZodString;
+    privacyPolicyRef: z.ZodString;
+    residencyPolicyRef: z.ZodString;
+    retentionPolicyRef: z.ZodString;
+    riskPolicyRef: z.ZodString;
+    allowedLatencyClasses: z.ZodArray<z.ZodEnum<{
+        batch: "batch";
+        interactive: "interactive";
+        standard: "standard";
+    }>>;
+    maxCostPerMillionTokensMinorUnits: z.ZodNumber;
+    costCurrency: z.ZodString;
+    requiredQualification: z.ZodEnum<{
+        live_verified: "live_verified";
+        simulated_or_live: "simulated_or_live";
+    }>;
+}, z.core.$strict>;
+export declare const agentModelSelectionV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"contractspec.agent.model-selection.v1">;
+    id: z.ZodString;
+    runRef: z.ZodString;
+    plan: z.ZodObject<{
+        ref: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        tenantId: z.ZodString;
+        spaceId: z.ZodString;
+        productKey: z.ZodString;
+        applicationRef: z.ZodString;
+        purpose: z.ZodString;
+        sessionId: z.ZodOptional<z.ZodString>;
+        runId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    selectedRoute: z.ZodObject<{
+        ref: z.ZodString;
+        version: z.ZodString;
+        routeDigest: z.ZodString;
+        capabilityProfile: z.ZodObject<{
+            ref: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        qualification: z.ZodObject<{
+            ref: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    consideredRoutes: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        version: z.ZodString;
+        routeDigest: z.ZodString;
+        capabilityProfile: z.ZodObject<{
+            ref: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        qualification: z.ZodObject<{
+            ref: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        disposition: z.ZodEnum<{
+            rejected: "rejected";
+            selected: "selected";
+        }>;
+        reasonRef: z.ZodString;
+    }, z.core.$strict>>;
+    hardConstraints: z.ZodObject<{
+        requiredCapabilityRefs: z.ZodArray<z.ZodString>;
+        minimumContextWindowTokens: z.ZodNumber;
+        minimumOutputTokens: z.ZodNumber;
+        requireStrictToolSchemas: z.ZodBoolean;
+        requireParallelToolCalls: z.ZodBoolean;
+        allowedProviderRefs: z.ZodArray<z.ZodString>;
+        allowedRegionRefs: z.ZodArray<z.ZodString>;
+        transportProfileRef: z.ZodString;
+        authenticationProfileRef: z.ZodString;
+        privacyPolicyRef: z.ZodString;
+        residencyPolicyRef: z.ZodString;
+        retentionPolicyRef: z.ZodString;
+        riskPolicyRef: z.ZodString;
+        allowedLatencyClasses: z.ZodArray<z.ZodEnum<{
+            batch: "batch";
+            interactive: "interactive";
+            standard: "standard";
+        }>>;
+        maxCostPerMillionTokensMinorUnits: z.ZodNumber;
+        costCurrency: z.ZodString;
+        requiredQualification: z.ZodEnum<{
+            live_verified: "live_verified";
+            simulated_or_live: "simulated_or_live";
+        }>;
+    }, z.core.$strict>;
+    selectionPolicyRef: z.ZodString;
+    selectedAt: z.ZodString;
+    selectionDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const agentModelFallbackDecisionV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"contractspec.agent.model-fallback-decision.v1">;
+    id: z.ZodString;
+    runRef: z.ZodString;
+    checkpoint: z.ZodObject<{
+        ref: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>;
+    selection: z.ZodObject<{
+        ref: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>;
+    fromRoute: z.ZodObject<{
+        ref: z.ZodString;
+        version: z.ZodString;
+        routeDigest: z.ZodString;
+        capabilityProfile: z.ZodObject<{
+            ref: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        qualification: z.ZodObject<{
+            ref: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    toRoute: z.ZodObject<{
+        ref: z.ZodString;
+        version: z.ZodString;
+        routeDigest: z.ZodString;
+        capabilityProfile: z.ZodObject<{
+            ref: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        qualification: z.ZodObject<{
+            ref: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    consideredRoutes: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        version: z.ZodString;
+        routeDigest: z.ZodString;
+        capabilityProfile: z.ZodObject<{
+            ref: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        qualification: z.ZodObject<{
+            ref: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+        reasonRef: z.ZodString;
+        eligibility: z.ZodEnum<{
+            eligible: "eligible";
+            ineligible: "ineligible";
+            unknown: "unknown";
+        }>;
+        eligibilityEvidence: z.ZodObject<{
+            ref: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    decision: z.ZodEnum<{
+        allowed: "allowed";
+        denied: "denied";
+    }>;
+    reasonSummary: z.ZodString;
+    evidence: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            eval_result: "eval_result";
+            human_feedback: "human_feedback";
+            policy_decision: "policy_decision";
+            redaction_decision: "redaction_decision";
+            replay_bundle: "replay_bundle";
+            retrieval_context: "retrieval_context";
+            rollback_version: "rollback_version";
+            source_message: "source_message";
+            tool_receipt: "tool_receipt";
+        }>;
+        ref: z.ZodString;
+        sourcePackage: z.ZodString;
+        redactionStatus: z.ZodEnum<{
+            none: "none";
+            redacted: "redacted";
+            restricted: "restricted";
+        }>;
+        ontologyRef: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodString;
+        artifactHash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    decidedAt: z.ZodString;
+    decisionDigest: z.ZodString;
+}, z.core.$strict>;
+export type AgentModelHardConstraintsV1 = z.infer<typeof agentModelHardConstraintsV1Schema>;
+export type AgentModelSelectionV1 = z.infer<typeof agentModelSelectionV1Schema>;
+export type AgentModelFallbackDecisionV1 = z.infer<typeof agentModelFallbackDecisionV1Schema>;
+export { validateAgentModelFallbackEquivalenceV1 } from './bindings.js';
+export { validateAgentModelSelectionBindingV1 } from './model-selection-validation.js';

package/dist/agent/protocol/model-routing.js

@@ -0,0 +1 @@
+import{z as e}from"zod";import{agentArtifactBindingV1Schema as n,agentProtocolDigestSchema as c,agentProtocolEvidencePointerSchema as d,agentProtocolRefSchema as t,agentProtocolTimestampSchema as s,agentScopeV1Schema as u}from"./common.js";export*from"./model-route-contracts.js";export const AGENT_MODEL_SELECTION_V1="contractspec.agent.model-selection.v1";export const AGENT_MODEL_FALLBACK_DECISION_V1="contractspec.agent.model-fallback-decision.v1";const m=t.refine((i)=>!i.toLowerCase().includes("latest")&&!/[*?]/.test(i),"Production model identifiers must be pinned and cannot use latest or wildcards");function f(i,r,o){i.addIssue({code:e.ZodIssueCode.custom,path:[r],message:o})}export const agentModelHardConstraintsV1Schema=e.object({requiredCapabilityRefs:e.array(t),minimumContextWindowTokens:e.number().int().positive(),minimumOutputTokens:e.number().int().positive(),requireStrictToolSchemas:e.boolean(),requireParallelToolCalls:e.boolean(),allowedProviderRefs:e.array(t).min(1),allowedRegionRefs:e.array(t).min(1),transportProfileRef:t,authenticationProfileRef:t,privacyPolicyRef:t,residencyPolicyRef:t,retentionPolicyRef:t,riskPolicyRef:t,allowedLatencyClasses:e.array(e.enum(["interactive","standard","batch"])).min(1),maxCostPerMillionTokensMinorUnits:e.number().int().nonnegative(),costCurrency:e.string().regex(/^[A-Z]{3}$/),requiredQualification:e.enum(["simulated_or_live","live_verified"])}).strict();const a=e.object({ref:t,version:m,routeDigest:c,capabilityProfile:n,qualification:n}).strict();export const agentModelSelectionV1Schema=e.object({schemaVersion:e.literal(AGENT_MODEL_SELECTION_V1),id:t,runRef:t,plan:n,scope:u,selectedRoute:a,consideredRoutes:e.array(a.extend({disposition:e.enum(["selected","rejected"]),reasonRef:t})).min(1),hardConstraints:agentModelHardConstraintsV1Schema,selectionPolicyRef:t,selectedAt:s,selectionDigest:c}).strict().superRefine((i,r)=>{const o=i.consideredRoutes.filter((l)=>l.disposition==="selected");if(o.length!==1||o[0]?.ref!==i.selectedRoute.ref||o[0]?.version!==i.selectedRoute.version||o[0]?.routeDigest!==i.selectedRoute.routeDigest||o[0]?.capabilityProfile.ref!==i.selectedRoute.capabilityProfile.ref||o[0]?.capabilityProfile.digest!==i.selectedRoute.capabilityProfile.digest||o[0]?.qualification.ref!==i.selectedRoute.qualification.ref||o[0]?.qualification.digest!==i.selectedRoute.qualification.digest)f(r,"consideredRoutes","Exactly one considered route must match the selected route")});export const agentModelFallbackDecisionV1Schema=e.object({schemaVersion:e.literal(AGENT_MODEL_FALLBACK_DECISION_V1),id:t,runRef:t,checkpoint:n,selection:n,fromRoute:a,toRoute:a,consideredRoutes:e.array(a.extend({reasonRef:t,eligibility:e.enum(["eligible","ineligible","unknown"]),eligibilityEvidence:n})).min(1),decision:e.enum(["allowed","denied"]),reasonSummary:t,evidence:e.array(d).min(1),decidedAt:s,decisionDigest:c}).strict();export{validateAgentModelFallbackEquivalenceV1}from"./bindings.js";export{validateAgentModelSelectionBindingV1}from"./model-selection-validation.js";

package/dist/agent/protocol/model-routing.test-fixtures.d.ts

@@ -0,0 +1,157 @@
+import type { AgentExecutionPlanV1 } from './planning.js';
+export declare const modelTestNow = "2026-08-12T10:00:00+02:00";
+export declare const modelTestDigest: string;
+export declare const modelTestScope: {
+    tenantId: string;
+    spaceId: string;
+    productKey: string;
+    applicationRef: string;
+    purpose: string;
+    runId: string;
+};
+export declare const modelTestPlan: AgentExecutionPlanV1;
+export declare function modelTestProfile(id: string, overrides?: Record<string, unknown>): {
+    schemaVersion: "contractspec.agent.model-capability-profile.v1";
+    id: string;
+    provider: string;
+    modelId: string;
+    modelVersion: string;
+    contextWindowTokens: number;
+    maxOutputTokens: number;
+    capabilities: string[];
+    supportsStrictToolSchemas: boolean;
+    supportsParallelToolCalls: boolean;
+    privacyPolicyRef: string;
+    residencyPolicyRef: string;
+    retentionPolicyRef: string;
+    transportPolicyRef: string;
+    authenticationPolicyRef: string;
+    riskPolicyRef: string;
+    priceProfileRef: string;
+    latencyClass: "batch" | "interactive" | "standard";
+    profileDigest: string;
+};
+export declare function modelTestRoute(id: string, profileRef: string): {
+    schemaVersion: "contractspec.agent.model-route.v1";
+    id: string;
+    version: string;
+    capabilityProfile: {
+        ref: string;
+        digest: string;
+    };
+    provider: string;
+    modelId: string;
+    modelVersion: string;
+    region: string;
+    transportProfileRef: string;
+    authenticationProfileRef: string;
+    connectionRef: string;
+    secretRef: string;
+    availabilityClass: "degraded" | "fallback" | "primary";
+    qualificationRef: string;
+    routeDigest: string;
+};
+export declare function modelTestQualification(id: string, routeRef: string): {
+    schemaVersion: "contractspec.agent.model-qualification.v1";
+    id: string;
+    routeRef: string;
+    routeVersion: string;
+    routeDigest: string;
+    applicationRef: string;
+    applicationVersion: string;
+    promptVersion: string;
+    toolSchemaVersions: string[];
+    contextCompilerVersion: string;
+    evaluatorVersion: string;
+    policyVersion: string;
+    sandboxDigest: string;
+    releaseSha: string;
+    status: "live_verified" | "rejected" | "simulated" | "unqualified";
+    evidence: {
+        id: string;
+        kind: "eval_result" | "human_feedback" | "policy_decision" | "redaction_decision" | "replay_bundle" | "retrieval_context" | "rollback_version" | "source_message" | "tool_receipt";
+        ref: string;
+        sourcePackage: string;
+        redactionStatus: "none" | "redacted" | "restricted";
+        ontologyRef?: string | undefined;
+        timestamp: string;
+        artifactHash?: string | undefined;
+    }[];
+    qualifiedAt?: string | undefined;
+    qualificationDigest: string;
+};
+export declare function modelTestSelection(route: {
+    id: string;
+    routeDigest: string;
+    capabilityProfile: {
+        ref: string;
+        digest: string;
+    };
+}, qualificationRef: string): {
+    schemaVersion: "contractspec.agent.model-selection.v1";
+    id: string;
+    runRef: string;
+    plan: {
+        ref: string;
+        digest: string;
+    };
+    scope: {
+        tenantId: string;
+        spaceId: string;
+        productKey: string;
+        applicationRef: string;
+        purpose: string;
+        sessionId?: string | undefined;
+        runId?: string | undefined;
+    };
+    selectedRoute: {
+        ref: string;
+        version: string;
+        routeDigest: string;
+        capabilityProfile: {
+            ref: string;
+            digest: string;
+        };
+        qualification: {
+            ref: string;
+            digest: string;
+        };
+    };
+    consideredRoutes: {
+        ref: string;
+        version: string;
+        routeDigest: string;
+        capabilityProfile: {
+            ref: string;
+            digest: string;
+        };
+        qualification: {
+            ref: string;
+            digest: string;
+        };
+        disposition: "rejected" | "selected";
+        reasonRef: string;
+    }[];
+    hardConstraints: {
+        requiredCapabilityRefs: string[];
+        minimumContextWindowTokens: number;
+        minimumOutputTokens: number;
+        requireStrictToolSchemas: boolean;
+        requireParallelToolCalls: boolean;
+        allowedProviderRefs: string[];
+        allowedRegionRefs: string[];
+        transportProfileRef: string;
+        authenticationProfileRef: string;
+        privacyPolicyRef: string;
+        residencyPolicyRef: string;
+        retentionPolicyRef: string;
+        riskPolicyRef: string;
+        allowedLatencyClasses: ("batch" | "interactive" | "standard")[];
+        maxCostPerMillionTokensMinorUnits: number;
+        costCurrency: string;
+        requiredQualification: "live_verified" | "simulated_or_live";
+    };
+    selectionPolicyRef: string;
+    selectedAt: string;
+    selectionDigest: string;
+};

package/dist/agent/protocol/model-routing.test-fixtures.js

@@ -0,0 +1 @@
+import{AGENT_MODEL_CAPABILITY_PROFILE_V1 as o,AGENT_MODEL_QUALIFICATION_V1 as r,AGENT_MODEL_ROUTE_V1 as n,AGENT_MODEL_SELECTION_V1 as s,agentModelCapabilityProfileV1Schema as a,agentModelQualificationV1Schema as l,agentModelRouteV1Schema as c,agentModelSelectionV1Schema as p}from"./model-routing.js";export const modelTestNow="2026-08-12T10:00:00+02:00";export const modelTestDigest=`sha256:${"a".repeat(64)}`;export const modelTestScope={tenantId:"tenant.1",spaceId:"space.1",productKey:"companyos",applicationRef:"release-steward.1",purpose:"release",runId:"run.1"};export const modelTestPlan={id:"plan.1",planDigest:modelTestDigest,scope:modelTestScope,versions:{applicationVersion:"1.0.0",promptVersion:"prompt.1.0.0",modelRouteVersion:"1.0.0",toolSchemaVersions:["tool.1.0.0"],contextCompilerVersion:"compiler.1.0.0",evaluatorVersion:"evaluator.1.0.0",policyVersion:"policy.1.0.0",sandboxDigest:modelTestDigest,releaseSha:"a".repeat(40)}};export function modelTestProfile(e,t={}){return a.parse({schemaVersion:o,id:e,provider:"anthropic",modelId:"claude-sonnet-4-20250514",modelVersion:"2025-05-14",contextWindowTokens:200000,maxOutputTokens:8192,capabilities:["strict_tools","vision"],supportsStrictToolSchemas:!0,supportsParallelToolCalls:!0,privacyPolicyRef:"privacy.eu.v1",residencyPolicyRef:"residency.eu.v1",retentionPolicyRef:"retention.zero.v1",transportPolicyRef:"transport.https.v1",authenticationPolicyRef:"authentication.secret-lease.v1",riskPolicyRef:"risk.r1.v1",priceProfileRef:"price.anthropic.v1",latencyClass:"interactive",profileDigest:modelTestDigest,...t})}export function modelTestRoute(e,t){return c.parse({schemaVersion:n,id:e,version:"1.0.0",capabilityProfile:{ref:t,digest:modelTestDigest},provider:"anthropic",modelId:"claude-sonnet-4-20250514",modelVersion:"2025-05-14",region:"eu-west-1",transportProfileRef:"transport.https.v1",authenticationProfileRef:"authentication.secret-lease.v1",connectionRef:"connect.anthropic.eu",secretRef:"secret-lease-profile.anthropic",availabilityClass:e==="route.primary"?"primary":"fallback",qualificationRef:`qualification.${e}`,routeDigest:modelTestDigest})}export function modelTestQualification(e,t){return l.parse({schemaVersion:r,id:e,routeRef:t,routeVersion:"1.0.0",routeDigest:modelTestDigest,applicationRef:"release-steward.1",applicationVersion:"1.0.0",promptVersion:"prompt.1.0.0",toolSchemaVersions:["tool.1.0.0"],contextCompilerVersion:"compiler.1.0.0",evaluatorVersion:"evaluator.1.0.0",policyVersion:"policy.1.0.0",sandboxDigest:modelTestDigest,releaseSha:"a".repeat(40),status:"live_verified",evidence:[{id:"e.1",kind:"eval_result",ref:"eval.1",sourcePackage:"@lssm/lib.agent-evals",timestamp:modelTestNow,redactionStatus:"none"}],qualifiedAt:modelTestNow,qualificationDigest:modelTestDigest})}export function modelTestSelection(e,t){const i={ref:e.id,version:"1.0.0",routeDigest:e.routeDigest,capabilityProfile:e.capabilityProfile,qualification:{ref:t,digest:modelTestDigest}};return p.parse({schemaVersion:s,id:"selection.1",runRef:"run.1",plan:{ref:modelTestPlan.id,digest:modelTestDigest},scope:modelTestScope,selectedRoute:i,consideredRoutes:[{...i,disposition:"selected",reasonRef:"best-qualified-route"}],hardConstraints:{requiredCapabilityRefs:["strict_tools","vision"],minimumContextWindowTokens:1e5,minimumOutputTokens:4096,requireStrictToolSchemas:!0,requireParallelToolCalls:!0,allowedProviderRefs:["anthropic"],allowedRegionRefs:["eu-west-1"],transportProfileRef:"transport.https.v1",authenticationProfileRef:"authentication.secret-lease.v1",privacyPolicyRef:"privacy.eu.v1",residencyPolicyRef:"residency.eu.v1",retentionPolicyRef:"retention.zero.v1",riskPolicyRef:"risk.r1.v1",allowedLatencyClasses:["interactive"],maxCostPerMillionTokensMinorUnits:100,costCurrency:"EUR",requiredQualification:"live_verified"},selectionPolicyRef:"selector.1",selectedAt:modelTestNow,selectionDigest:modelTestDigest})}

package/dist/agent/protocol/model-selection-validation-v2.d.ts

@@ -0,0 +1,37 @@
+import type { AgentModelInvocationProfileV1 } from './model-invocation-profile.js';
+import type { AgentModelCapabilityProfileV2, AgentModelQualificationV2, AgentModelRouteV2 } from './model-route-contracts-v2.js';
+import type { AgentModelCandidateBindingV2, AgentModelSelectionV2 } from './model-routing-v2.js';
+import type { AgentExecutionPlanV1 } from './planning.js';
+export interface AgentModelCandidateViewV2 {
+    route: AgentModelRouteV2;
+    profile: AgentModelCapabilityProfileV2;
+    qualification: AgentModelQualificationV2;
+    invocationProfile: AgentModelInvocationProfileV1;
+    costPerMillionTokensMinorUnits: number;
+    costCurrency: string;
+    canary?: {
+        ref: string;
+        digest: string;
+    };
+}
+export interface AgentModelEligibilityViewV2 {
+    route: AgentModelCandidateBindingV2;
+    status: 'eligible' | 'ineligible' | 'unknown';
+    evidence: {
+        ref: string;
+        digest: string;
+    };
+}
+export declare function routeBindingMatchesModelCandidateV2(binding: AgentModelCandidateBindingV2, candidate: AgentModelCandidateViewV2): boolean;
+export declare function validateModelCandidateV2(input: {
+    plan: AgentExecutionPlanV1;
+    selection: AgentModelSelectionV2;
+    candidate: AgentModelCandidateViewV2;
+    now?: Date;
+}): string[];
+export declare function validateAgentModelSelectionBindingV2(input: {
+    plan: AgentExecutionPlanV1;
+    selection: AgentModelSelectionV2;
+    candidate: AgentModelCandidateViewV2;
+    now?: Date;
+}): string[];

package/dist/agent/protocol/model-selection-validation-v2.js

@@ -0,0 +1 @@
+import{validateAgentScopeExactV1 as a}from"./common.js";import{validateModelServingConstraintsV2 as c}from"./model-serving-validation-v2.js";export function routeBindingMatchesModelCandidateV2(e,o){return e.ref===o.route.id&&e.version===o.route.version&&e.routeDigest===o.route.routeDigest&&e.capabilityProfile.ref===o.profile.id&&e.capabilityProfile.digest===o.profile.profileDigest&&e.qualification.ref===o.qualification.id&&e.qualification.digest===o.qualification.qualificationDigest&&e.invocationProfile.ref===o.invocationProfile.id&&e.invocationProfile.digest===o.invocationProfile.invocationProfileDigest&&e.canary?.ref===o.canary?.ref&&e.canary?.digest===o.canary?.digest&&e.costPerMillionTokensMinorUnits===o.costPerMillionTokensMinorUnits&&e.costCurrency===o.costCurrency}export function validateModelCandidateV2(e){const{route:o,profile:i,qualification:t,invocationProfile:r}=e.candidate,s=e.selection.hardConstraints,n=[];if(o.capabilityProfile.ref!==i.id||o.capabilityProfile.digest!==i.profileDigest)n.push("Model route capability profile binding does not match");if(o.modelId!==i.modelId||o.modelVersion!==i.modelVersion)n.push("Model route identity does not match its capability profile");if(o.invocationProfile.ref!==r.id||o.invocationProfile.digest!==r.invocationProfileDigest||t.invocationProfile.ref!==r.id||t.invocationProfile.digest!==r.invocationProfileDigest)n.push("Model invocation profile binding does not match");if(t.routeRef!==o.id||t.routeVersion!==o.version||t.routeDigest!==o.routeDigest||o.qualificationRef!==t.id)n.push("Model qualification does not bind the route version");n.push(...d(e.plan,o,t));n.push(...u(e.plan,t));for(const l of s.requiredCapabilityRefs)if(!i.capabilities.includes(l))n.push(`Model route lacks capability: ${l}`);if(i.contextWindowTokens<s.minimumContextWindowTokens)n.push("Model route context window is below the required minimum");if(i.maxOutputTokens<s.minimumOutputTokens)n.push("Model route output limit is below the required minimum");if(r.maxOutputTokens>i.maxOutputTokens)n.push("Invocation output limit exceeds the model capability profile");if(s.requireStrictToolSchemas&&!i.supportsStrictToolSchemas)n.push("Model route lacks strict tool-schema support");if(s.requireParallelToolCalls&&!i.supportsParallelToolCalls)n.push("Model route lacks parallel tool-call support");n.push(...c(e.candidate,e.selection));if(e.candidate.costCurrency!==s.costCurrency||e.candidate.costPerMillionTokensMinorUnits>s.maxCostPerMillionTokensMinorUnits)n.push("Model route exceeds the allowed cost policy");if(!(s.requiredQualification==="live_verified"?t.status==="live_verified":t.status==="simulated"||t.status==="live_verified"))n.push("Model route lacks required qualification");if(t.status==="live_verified"&&t.expiresAt&&Date.parse(t.expiresAt)<=(e.now??new Date).getTime())n.push("Model qualification is expired");if(t.status==="revoked")n.push("Model qualification is revoked");return n}export function validateAgentModelSelectionBindingV2(e){const o=a({expected:e.plan.scope,observed:e.selection.scope});if(e.selection.plan.ref!==e.plan.id||e.selection.plan.digest!==e.plan.planDigest)o.push("Model selection plan binding does not match");if(e.selection.scope.runId!==e.selection.runRef||e.plan.scope.runId&&e.plan.scope.runId!==e.selection.runRef)o.push("Model selection run binding does not match");const i=e.selection.consideredRoutes.map((t)=>t.ref);if(new Set(i).size!==i.length)o.push("Model selection considered routes must be unique");if(!routeBindingMatchesModelCandidateV2(e.selection.selectedRoute,e.candidate))o.push("Selected model route binding does not match the candidate");o.push(...validateModelCandidateV2(e));return o}function d(e,o,i){const t=[];if(i.applicationRef!==e.scope.applicationRef||i.purposeRef!==e.scope.purpose||o.version!==e.versions.modelRouteVersion||i.applicationVersion!==e.versions.applicationVersion||i.promptVersion!==e.versions.promptVersion||i.contextCompilerVersion!==e.versions.contextCompilerVersion||i.evaluatorVersion!==e.versions.evaluatorVersion||i.policyVersion!==e.versions.policyVersion||i.sandboxDigest!==e.versions.sandboxDigest||i.releaseSha!==e.versions.releaseSha)t.push("Model qualification version set does not match the plan");const r=[...e.versions.toolSchemaVersions].sort(),s=[...i.toolSchemaVersions].sort();if(JSON.stringify(r)!==JSON.stringify(s))t.push("Model qualification tool schema versions do not match the plan");return t}function u(e,o){if(!o.operation)return[];if(o.operation.kind==="plan_step")return e.steps.some((i)=>i.id===o.operation?.ref)?[]:["Model qualification plan-step binding does not match the plan"];return e.effectProposals.some((i)=>i.operationRef===o.operation?.ref)?[]:["Model qualification operation binding does not match the plan"]}

package/dist/agent/protocol/model-selection-validation.d.ts

@@ -0,0 +1,21 @@
+import type { AgentModelCapabilityProfileV1, AgentModelQualificationV1, AgentModelRouteV1 } from './model-route-contracts.js';
+import type { AgentModelSelectionV1 } from './model-routing.js';
+import type { AgentExecutionPlanV1 } from './planning.js';
+export interface AgentModelCandidateViewV1 {
+    route: AgentModelRouteV1;
+    profile: AgentModelCapabilityProfileV1;
+    qualification: AgentModelQualificationV1;
+    costPerMillionTokensMinorUnits: number;
+    costCurrency: string;
+}
+export declare function routeBindingMatchesModelCandidateV1(binding: AgentModelSelectionV1['selectedRoute'], candidate: AgentModelCandidateViewV1): boolean;
+export declare function validateModelCandidateV1(input: {
+    plan: AgentExecutionPlanV1;
+    selection: AgentModelSelectionV1;
+    candidate: AgentModelCandidateViewV1;
+}): string[];
+export declare function validateAgentModelSelectionBindingV1(input: {
+    plan: AgentExecutionPlanV1;
+    selection: AgentModelSelectionV1;
+    candidate: AgentModelCandidateViewV1;
+}): string[];

package/dist/agent/protocol/model-selection-validation.js

@@ -0,0 +1 @@
+import{validateAgentScopeExactV1 as d}from"./common.js";export function routeBindingMatchesModelCandidateV1(e,o){return e.ref===o.route.id&&e.version===o.route.version&&e.routeDigest===o.route.routeDigest&&e.capabilityProfile.ref===o.profile.id&&e.capabilityProfile.digest===o.profile.profileDigest&&e.qualification.ref===o.qualification.id&&e.qualification.digest===o.qualification.qualificationDigest}export function validateModelCandidateV1(e){const{route:o,profile:i,qualification:t}=e.candidate,s=e.selection.hardConstraints,l=[];if(o.capabilityProfile.ref!==i.id||o.capabilityProfile.digest!==i.profileDigest)l.push("Model route capability profile binding does not match");if(o.provider!==i.provider||o.modelId!==i.modelId||o.modelVersion!==i.modelVersion)l.push("Model route identity does not match its capability profile");if(t.routeRef!==o.id||t.routeVersion!==o.version||t.routeDigest!==o.routeDigest||o.qualificationRef!==t.id)l.push("Model qualification does not bind the route version");if(t.applicationRef!==e.plan.scope.applicationRef||o.version!==e.plan.versions.modelRouteVersion||t.applicationVersion!==e.plan.versions.applicationVersion||t.promptVersion!==e.plan.versions.promptVersion||t.contextCompilerVersion!==e.plan.versions.contextCompilerVersion||t.evaluatorVersion!==e.plan.versions.evaluatorVersion||t.policyVersion!==e.plan.versions.policyVersion||t.sandboxDigest!==e.plan.versions.sandboxDigest||t.releaseSha!==e.plan.versions.releaseSha)l.push("Model qualification version set does not match the plan");const r=[...e.plan.versions.toolSchemaVersions].sort(),a=[...t.toolSchemaVersions].sort();if(JSON.stringify(r)!==JSON.stringify(a))l.push("Model qualification tool schema versions do not match the plan");for(const n of s.requiredCapabilityRefs)if(!i.capabilities.includes(n))l.push(`Model route lacks capability: ${n}`);if(i.contextWindowTokens<s.minimumContextWindowTokens)l.push("Model route context window is below the required minimum");if(i.maxOutputTokens<s.minimumOutputTokens)l.push("Model route output limit is below the required minimum");if(s.requireStrictToolSchemas&&!i.supportsStrictToolSchemas)l.push("Model route lacks strict tool-schema support");if(s.requireParallelToolCalls&&!i.supportsParallelToolCalls)l.push("Model route lacks parallel tool-call support");if(!s.allowedProviderRefs.includes(o.provider))l.push("Model route provider is not allowed");if(!s.allowedRegionRefs.includes(o.region))l.push("Model route region is not allowed");for(const[n,c]of[["transportProfileRef",o.transportProfileRef],["authenticationProfileRef",o.authenticationProfileRef],["privacyPolicyRef",i.privacyPolicyRef],["residencyPolicyRef",i.residencyPolicyRef],["retentionPolicyRef",i.retentionPolicyRef],["riskPolicyRef",i.riskPolicyRef]])if(c!==s[n])l.push(`Model route changes ${n}`);if(!s.allowedLatencyClasses.includes(i.latencyClass))l.push("Model route latency class is not allowed");if(e.candidate.costCurrency!==s.costCurrency||e.candidate.costPerMillionTokensMinorUnits>s.maxCostPerMillionTokensMinorUnits)l.push("Model route exceeds the allowed cost policy");if(!(s.requiredQualification==="live_verified"?t.status==="live_verified":t.status==="simulated"||t.status==="live_verified"))l.push("Model route lacks required qualification");return l}export function validateAgentModelSelectionBindingV1(e){const o=d({expected:e.plan.scope,observed:e.selection.scope});if(e.selection.plan.ref!==e.plan.id||e.selection.plan.digest!==e.plan.planDigest)o.push("Model selection plan binding does not match");if(e.selection.scope.runId!==e.selection.runRef||e.plan.scope.runId&&e.plan.scope.runId!==e.selection.runRef)o.push("Model selection run binding does not match");const i=e.selection.consideredRoutes.map((t)=>t.ref);if(new Set(i).size!==i.length)o.push("Model selection considered routes must be unique");if(!routeBindingMatchesModelCandidateV1(e.selection.selectedRoute,e.candidate))o.push("Selected model route binding does not match the candidate");o.push(...validateModelCandidateV1(e));return o}

package/dist/agent/protocol/model-serving-validation-v2.d.ts

@@ -0,0 +1,6 @@
+import type { AgentModelCapabilityProfileV2, AgentModelRouteV2 } from './model-route-contracts-v2.js';
+import type { AgentModelSelectionV2 } from './model-routing-v2.js';
+export declare function validateModelServingConstraintsV2(candidate: {
+    profile: AgentModelCapabilityProfileV2;
+    route: AgentModelRouteV2;
+}, selection: AgentModelSelectionV2): string[];

package/dist/agent/protocol/model-serving-validation-v2.js

@@ -0,0 +1 @@
+export function validateModelServingConstraintsV2(r,a){const{profile:s,route:c}=r,{serving:e}=c,o=a.hardConstraints,l=[],t=(i,n,f)=>{if(!i.includes(n))l.push(`Model route ${f} is not allowed`)};t(o.allowedModelAuthorRefs,s.modelAuthorRef,"author");t(o.allowedInferenceProviderRefs,e.inferenceProviderRef,"inference provider");t(o.allowedDeploymentRefs,e.deploymentRef,"deployment");t(o.allowedAdapterRefs,e.adapterRef,"adapter");t(o.allowedCommercialPolicyRefs,e.commercialPolicyRef,"commercial policy");t(o.allowedConnectionRefs,e.connection.ref,"connection");t(o.allowedRegionRefs,e.region,"region");if(e.gatewayRef){if(!o.gatewayPolicy.allowedGatewayRefs.includes(e.gatewayRef))l.push("Model route gateway is not allowed")}else if(!o.gatewayPolicy.allowDirect)l.push("Direct model routes are not allowed");for(const[i,n]of[["transportProfileRef",e.transportProfileRef],["authenticationProfileRef",e.authenticationProfileRef],["privacyPolicyRef",e.privacyPolicyRef],["residencyPolicyRef",e.residencyPolicyRef],["retentionPolicyRef",e.retentionPolicyRef],["riskPolicyRef",e.riskPolicyRef]])if(n!==o[i])l.push(`Model route changes ${i}`);if(!o.allowedLatencyClasses.includes(e.latencyClass))l.push("Model route latency class is not allowed");return l}

package/dist/agent/protocol/planning.d.ts

@@ -0,0 +1,159 @@
+import { z } from 'zod';
+export declare const AGENT_EXECUTION_STEP_V1: 'contractspec.agent.execution-step.v1';
+export declare const AGENT_EXECUTION_PLAN_V1: 'contractspec.agent.execution-plan.v1';
+export declare const AGENT_PLAN_VALIDATION_V1: 'contractspec.agent.plan-validation.v1';
+export declare const agentExecutionStepV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"contractspec.agent.execution-step.v1">;
+    id: z.ZodString;
+    dependsOn: z.ZodArray<z.ZodString>;
+    objective: z.ZodString;
+    requiredContextItemIds: z.ZodArray<z.ZodString>;
+    toolRefs: z.ZodArray<z.ZodString>;
+    expectedArtifactRefs: z.ZodArray<z.ZodString>;
+    requiredEvidenceKinds: z.ZodArray<z.ZodString>;
+    effectProposalRefs: z.ZodArray<z.ZodString>;
+    approvalCheckpointRefs: z.ZodArray<z.ZodString>;
+    completionCriteria: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const agentExecutionPlanV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"contractspec.agent.execution-plan.v1">;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    supersedesRef: z.ZodOptional<z.ZodString>;
+    scope: z.ZodObject<{
+        tenantId: z.ZodString;
+        spaceId: z.ZodString;
+        productKey: z.ZodString;
+        applicationRef: z.ZodString;
+        purpose: z.ZodString;
+        sessionId: z.ZodOptional<z.ZodString>;
+        runId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    objective: z.ZodString;
+    interpretedIntent: z.ZodString;
+    assumptions: z.ZodArray<z.ZodString>;
+    unresolvedQuestions: z.ZodArray<z.ZodString>;
+    steps: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"contractspec.agent.execution-step.v1">;
+        id: z.ZodString;
+        dependsOn: z.ZodArray<z.ZodString>;
+        objective: z.ZodString;
+        requiredContextItemIds: z.ZodArray<z.ZodString>;
+        toolRefs: z.ZodArray<z.ZodString>;
+        expectedArtifactRefs: z.ZodArray<z.ZodString>;
+        requiredEvidenceKinds: z.ZodArray<z.ZodString>;
+        effectProposalRefs: z.ZodArray<z.ZodString>;
+        approvalCheckpointRefs: z.ZodArray<z.ZodString>;
+        completionCriteria: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    requiredContextManifestRef: z.ZodString;
+    requiredToolRefs: z.ZodArray<z.ZodString>;
+    expectedArtifactRefs: z.ZodArray<z.ZodString>;
+    requiredEvidenceKinds: z.ZodArray<z.ZodString>;
+    effectProposals: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        capabilityRef: z.ZodString;
+        operationRef: z.ZodString;
+        riskTier: z.ZodEnum<{
+            R0: "R0";
+            R1: "R1";
+            R2: "R2";
+            R3: "R3";
+        }>;
+        approvalRequirementRef: z.ZodOptional<z.ZodString>;
+        connectDecisionRef: z.ZodOptional<z.ZodString>;
+        runtimeWorkOrderRef: z.ZodOptional<z.ZodString>;
+        idempotencyRef: z.ZodString;
+    }, z.core.$strict>>;
+    approvalCheckpointRefs: z.ZodArray<z.ZodString>;
+    riskTier: z.ZodEnum<{
+        R0: "R0";
+        R1: "R1";
+        R2: "R2";
+        R3: "R3";
+    }>;
+    budgetRef: z.ZodString;
+    verificationPolicyRef: z.ZodString;
+    wallClockHorizonSeconds: z.ZodNumber;
+    stopConditions: z.ZodArray<z.ZodString>;
+    helpConditions: z.ZodArray<z.ZodString>;
+    completionCriteria: z.ZodArray<z.ZodString>;
+    confidence: z.ZodObject<{
+        score: z.ZodNumber;
+        calibrationRef: z.ZodString;
+        uncertaintyRefs: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    versions: z.ZodObject<{
+        applicationVersion: z.ZodString;
+        promptVersion: z.ZodString;
+        modelRouteVersion: z.ZodString;
+        toolSchemaVersions: z.ZodArray<z.ZodString>;
+        policyVersion: z.ZodString;
+        contextCompilerVersion: z.ZodString;
+        evaluatorVersion: z.ZodString;
+        sandboxDigest: z.ZodString;
+        releaseSha: z.ZodString;
+    }, z.core.$strict>;
+    createdAt: z.ZodString;
+    planDigest: z.ZodString;
+}, z.core.$strict>;
+export declare const agentPlanValidationV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"contractspec.agent.plan-validation.v1">;
+    id: z.ZodString;
+    planRef: z.ZodString;
+    planDigest: z.ZodString;
+    status: z.ZodEnum<{
+        accepted: "accepted";
+        rejected: "rejected";
+    }>;
+    effectProposalRefs: z.ZodArray<z.ZodString>;
+    checks: z.ZodArray<z.ZodObject<{
+        check: z.ZodEnum<{
+            application_scope: "application_scope";
+            approval: "approval";
+            budget: "budget";
+            effect_classification: "effect_classification";
+            policy_narrowing: "policy_narrowing";
+            required_context: "required_context";
+            tool_grants: "tool_grants";
+        }>;
+        passed: z.ZodBoolean;
+        evidenceRefs: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    connectDecision: z.ZodOptional<z.ZodObject<{
+        ref: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>>;
+    evidence: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            eval_result: "eval_result";
+            human_feedback: "human_feedback";
+            policy_decision: "policy_decision";
+            redaction_decision: "redaction_decision";
+            replay_bundle: "replay_bundle";
+            retrieval_context: "retrieval_context";
+            rollback_version: "rollback_version";
+            source_message: "source_message";
+            tool_receipt: "tool_receipt";
+        }>;
+        ref: z.ZodString;
+        sourcePackage: z.ZodString;
+        redactionStatus: z.ZodEnum<{
+            none: "none";
+            redacted: "redacted";
+            restricted: "restricted";
+        }>;
+        ontologyRef: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodString;
+        artifactHash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    validatedAt: z.ZodString;
+}, z.core.$strict>;
+export type AgentExecutionStepV1 = z.infer<typeof agentExecutionStepV1Schema>;
+export type AgentExecutionPlanV1 = z.infer<typeof agentExecutionPlanV1Schema>;
+export type AgentPlanValidationV1 = z.infer<typeof agentPlanValidationV1Schema>;
+export declare function validateAgentPlanValidationBindingV1(input: {
+    plan: AgentExecutionPlanV1;
+    validation: AgentPlanValidationV1;
+}): string[];

package/dist/agent/protocol/planning.js

@@ -0,0 +1 @@
+import{z as e}from"zod";import{agentArtifactBindingV1Schema as l,agentConfidenceV1Schema as u,agentEffectProposalV1Schema as m,agentProtocolDigestSchema as f,agentProtocolEvidencePointerSchema as h,agentProtocolRefSchema as t,agentProtocolTimestampSchema as d,agentRiskTierV1Schema as g,agentScopeV1Schema as R,agentVersionSetV1Schema as v,validateAgentDirectedAcyclicGraph as P}from"./common.js";export const AGENT_EXECUTION_STEP_V1="contractspec.agent.execution-step.v1";export const AGENT_EXECUTION_PLAN_V1="contractspec.agent.execution-plan.v1";export const AGENT_PLAN_VALIDATION_V1="contractspec.agent.plan-validation.v1";export const agentExecutionStepV1Schema=e.object({schemaVersion:e.literal(AGENT_EXECUTION_STEP_V1),id:t,dependsOn:e.array(t),objective:t,requiredContextItemIds:e.array(t),toolRefs:e.array(t),expectedArtifactRefs:e.array(t),requiredEvidenceKinds:e.array(t),effectProposalRefs:e.array(t),approvalCheckpointRefs:e.array(t),completionCriteria:e.array(t).min(1)}).strict();export const agentExecutionPlanV1Schema=e.object({schemaVersion:e.literal(AGENT_EXECUTION_PLAN_V1),id:t,revision:e.number().int().positive(),supersedesRef:t.optional(),scope:R,objective:t,interpretedIntent:t,assumptions:e.array(t),unresolvedQuestions:e.array(t),steps:e.array(agentExecutionStepV1Schema).min(1).max(32),requiredContextManifestRef:t,requiredToolRefs:e.array(t),expectedArtifactRefs:e.array(t),requiredEvidenceKinds:e.array(t).min(1),effectProposals:e.array(m),approvalCheckpointRefs:e.array(t),riskTier:g,budgetRef:t,verificationPolicyRef:t,wallClockHorizonSeconds:e.number().int().positive(),stopConditions:e.array(t).min(1),helpConditions:e.array(t).min(1),completionCriteria:e.array(t).min(1),confidence:u,versions:v,createdAt:d,planDigest:f}).strict().superRefine((s,o)=>{for(const a of P(s.steps,32))o.addIssue({code:e.ZodIssueCode.custom,path:["steps"],message:a});const r=new Set(s.effectProposals.map((a)=>a.id));if(r.size!==s.effectProposals.length)o.addIssue({code:e.ZodIssueCode.custom,path:["effectProposals"],message:"Effect proposal ids must be unique"});const i=new Set(s.requiredToolRefs),n=new Set(s.approvalCheckpointRefs);for(const a of s.effectProposals)if(a.approvalRequirementRef&&!n.has(a.approvalRequirementRef))o.addIssue({code:e.ZodIssueCode.custom,path:["approvalCheckpointRefs"],message:`Missing effect approval checkpoint: ${a.approvalRequirementRef}`});for(const[a,p]of s.steps.entries()){for(const c of p.toolRefs)if(!i.has(c))o.addIssue({code:e.ZodIssueCode.custom,path:["steps",a,"toolRefs"],message:`Step tool is not declared by the plan: ${c}`});for(const c of p.effectProposalRefs)if(!r.has(c))o.addIssue({code:e.ZodIssueCode.custom,path:["steps",a,"effectProposalRefs"],message:`Unknown effect proposal reference: ${c}`});for(const c of p.approvalCheckpointRefs)if(!n.has(c))o.addIssue({code:e.ZodIssueCode.custom,path:["steps",a,"approvalCheckpointRefs"],message:`Unknown approval checkpoint: ${c}`})}});export const agentPlanValidationV1Schema=e.object({schemaVersion:e.literal(AGENT_PLAN_VALIDATION_V1),id:t,planRef:t,planDigest:f,status:e.enum(["accepted","rejected"]),effectProposalRefs:e.array(t),checks:e.array(e.object({check:e.enum(["application_scope","required_context","tool_grants","effect_classification","budget","approval","policy_narrowing"]),passed:e.boolean(),evidenceRefs:e.array(t).min(1)}).strict()).min(7),connectDecision:l.optional(),evidence:e.array(h).min(1),validatedAt:d}).strict().superRefine((s,o)=>{const r=s.checks.map((n)=>n.check);if(new Set(r).size!==r.length)o.addIssue({code:e.ZodIssueCode.custom,path:["checks"],message:"Plan validation checks must be unique"});if(new Set(s.effectProposalRefs).size!==s.effectProposalRefs.length)o.addIssue({code:e.ZodIssueCode.custom,path:["effectProposalRefs"],message:"Plan validation effect references must be unique"});const i=s.checks.every((n)=>n.passed);if(s.status==="accepted"!==i)o.addIssue({code:e.ZodIssueCode.custom,path:["status"],message:"Accepted plan validations require every check to pass"});if(s.status==="accepted"&&s.effectProposalRefs.length>0&&!s.connectDecision)o.addIssue({code:e.ZodIssueCode.custom,path:["connectDecision"],message:"Accepted effectful plans require a Connect decision reference"})});export function validateAgentPlanValidationBindingV1(s){const o=[];if(s.validation.planRef!==s.plan.id)o.push("Plan validation reference does not match the plan");if(s.validation.planDigest!==s.plan.planDigest)o.push("Plan validation digest does not match the plan");const r=s.plan.effectProposals.map((n)=>n.id).sort(),i=[...s.validation.effectProposalRefs].sort();if(JSON.stringify(r)!==JSON.stringify(i))o.push("Plan validation effect references do not match the plan");return o}