@sequenceholdings/agent-spec 0.1.1 → 0.1.3

package/dist/voice-provider-release.d.ts

@@ -0,0 +1,386 @@
+import { z } from 'zod';
+export declare const voiceProviderReleaseEvidenceSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1">;
+    scope: z.ZodObject<{
+        tenantId: z.ZodString;
+        environmentId: z.ZodString;
+        agentId: z.ZodString;
+    }, z.core.$strict>;
+    releaseId: z.ZodString;
+    publicationOperationId: z.ZodString;
+    agentVersionId: z.ZodString;
+    createdByPrincipalId: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    inputEvidence: z.ZodObject<{
+        authoredDefinitionHash: z.ZodString;
+        localProjectionCompilerVersion: z.ZodString;
+        localProjectionHash: z.ZodString;
+        eligibleToolCatalogHash: z.ZodString;
+        resolvedBindingHash: z.ZodString;
+    }, z.core.$strict>;
+    ownedReleaseMarker: z.ZodString;
+    providerAgentId: z.ZodString;
+    agentBranchVersion: z.ZodObject<{
+        identifierContract: z.ZodEnum<{
+            LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+            NOT_USED: "NOT_USED";
+            BRANCH_ONLY: "BRANCH_ONLY";
+            VERSION_ONLY: "VERSION_ONLY";
+            BRANCH_AND_VERSION: "BRANCH_AND_VERSION";
+        }>;
+        branchId: z.ZodNullable<z.ZodString>;
+        versionId: z.ZodNullable<z.ZodString>;
+        verifiedAt: z.ZodNullable<z.ZodISODateTime>;
+        evidenceRef: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    procedureMappings: z.ZodArray<z.ZodObject<{
+        localProcedureKey: z.ZodString;
+        providerProcedureId: z.ZodString;
+        branchVersion: z.ZodObject<{
+            identifierContract: z.ZodEnum<{
+                LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+                NOT_USED: "NOT_USED";
+                BRANCH_ONLY: "BRANCH_ONLY";
+                VERSION_ONLY: "VERSION_ONLY";
+                BRANCH_AND_VERSION: "BRANCH_AND_VERSION";
+            }>;
+            branchId: z.ZodNullable<z.ZodString>;
+            versionId: z.ZodNullable<z.ZodString>;
+            verifiedAt: z.ZodNullable<z.ZodISODateTime>;
+            evidenceRef: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    publicationProgress: z.ZodObject<{
+        phase: z.ZodEnum<{
+            FAILED: "FAILED";
+            RECONCILIATION_REQUIRED: "RECONCILIATION_REQUIRED";
+            CREATE_AGENT: "CREATE_AGENT";
+            CREATE_PROCEDURES: "CREATE_PROCEDURES";
+            COMPILE: "COMPILE";
+            VALIDATE_GENERATED_WORKFLOW: "VALIDATE_GENERATED_WORKFLOW";
+            FINALIZE: "FINALIZE";
+            READBACK: "READBACK";
+            COMPLETE: "COMPLETE";
+        }>;
+        compile: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"NOT_STARTED">;
+            operationId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            lastObservedAt: z.ZodISODateTime;
+            operationId: z.ZodString;
+            startedAt: z.ZodISODateTime;
+            status: z.ZodLiteral<"IN_PROGRESS">;
+        }, z.core.$strict>, z.ZodObject<{
+            completedAt: z.ZodISODateTime;
+            receiptId: z.ZodNullable<z.ZodString>;
+            operationId: z.ZodString;
+            startedAt: z.ZodISODateTime;
+            status: z.ZodLiteral<"SUCCEEDED">;
+        }, z.core.$strict>, z.ZodObject<{
+            failedAt: z.ZodISODateTime;
+            errorCode: z.ZodString;
+            sanitizedMessage: z.ZodString;
+            retryable: z.ZodBoolean;
+            operationId: z.ZodString;
+            startedAt: z.ZodISODateTime;
+            status: z.ZodLiteral<"FAILED">;
+        }, z.core.$strict>, z.ZodObject<{
+            observedAt: z.ZodISODateTime;
+            reconciliationKey: z.ZodString;
+            sanitizedReason: z.ZodString;
+            operationId: z.ZodString;
+            startedAt: z.ZodISODateTime;
+            status: z.ZodLiteral<"UNKNOWN">;
+        }, z.core.$strict>], "status">;
+        finalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"NOT_STARTED">;
+            operationId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            lastObservedAt: z.ZodISODateTime;
+            operationId: z.ZodString;
+            startedAt: z.ZodISODateTime;
+            status: z.ZodLiteral<"IN_PROGRESS">;
+        }, z.core.$strict>, z.ZodObject<{
+            completedAt: z.ZodISODateTime;
+            receiptId: z.ZodNullable<z.ZodString>;
+            operationId: z.ZodString;
+            startedAt: z.ZodISODateTime;
+            status: z.ZodLiteral<"SUCCEEDED">;
+        }, z.core.$strict>, z.ZodObject<{
+            failedAt: z.ZodISODateTime;
+            errorCode: z.ZodString;
+            sanitizedMessage: z.ZodString;
+            retryable: z.ZodBoolean;
+            operationId: z.ZodString;
+            startedAt: z.ZodISODateTime;
+            status: z.ZodLiteral<"FAILED">;
+        }, z.core.$strict>, z.ZodObject<{
+            observedAt: z.ZodISODateTime;
+            reconciliationKey: z.ZodString;
+            sanitizedReason: z.ZodString;
+            operationId: z.ZodString;
+            startedAt: z.ZodISODateTime;
+            status: z.ZodLiteral<"UNKNOWN">;
+        }, z.core.$strict>], "status">;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    generatedWorkflow: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        capturedAt: z.ZodISODateTime;
+        documentHash: z.ZodString;
+        sanitizedDocument: z.ZodJSONSchema;
+        normalized: z.ZodObject<{
+            authoritySource: z.ZodLiteral<"ATLAS_RELEASE_BINDINGS">;
+            procedures: z.ZodArray<z.ZodObject<{
+                localProcedureKey: z.ZodString;
+                providerProcedureId: z.ZodString;
+                toolAliases: z.ZodArray<z.ZodString>;
+                referencedProviderProcedureIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            toolAliases: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    desiredConfiguration: z.ZodObject<{
+        configuration: z.ZodObject<{
+            providerAgentId: z.ZodString;
+            agentBranchVersion: z.ZodObject<{
+                identifierContract: z.ZodEnum<{
+                    LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+                    NOT_USED: "NOT_USED";
+                    BRANCH_ONLY: "BRANCH_ONLY";
+                    VERSION_ONLY: "VERSION_ONLY";
+                    BRANCH_AND_VERSION: "BRANCH_AND_VERSION";
+                }>;
+                branchId: z.ZodNullable<z.ZodString>;
+                versionId: z.ZodNullable<z.ZodString>;
+                verifiedAt: z.ZodNullable<z.ZodISODateTime>;
+                evidenceRef: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+            privacy: z.ZodLiteral<"PRIVATE">;
+            procedureMappings: z.ZodArray<z.ZodObject<{
+                localProcedureKey: z.ZodString;
+                providerProcedureId: z.ZodString;
+                branchVersion: z.ZodObject<{
+                    identifierContract: z.ZodEnum<{
+                        LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+                        NOT_USED: "NOT_USED";
+                        BRANCH_ONLY: "BRANCH_ONLY";
+                        VERSION_ONLY: "VERSION_ONLY";
+                        BRANCH_AND_VERSION: "BRANCH_AND_VERSION";
+                    }>;
+                    branchId: z.ZodNullable<z.ZodString>;
+                    versionId: z.ZodNullable<z.ZodString>;
+                    verifiedAt: z.ZodNullable<z.ZodISODateTime>;
+                    evidenceRef: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            toolAliases: z.ZodArray<z.ZodString>;
+            generatedWorkflowHash: z.ZodString;
+            maxCallDurationSeconds: z.ZodNumber;
+            providerDurationCeilingSeconds: z.ZodNumber;
+            recordingEnabled: z.ZodBoolean;
+            retentionDays: z.ZodLiteral<-1>;
+            telephonyConnection: z.ZodLiteral<"ATLAS_TWILIO_REGISTER_CALL">;
+            directProviderConversationAccess: z.ZodLiteral<false>;
+            transfersEnabled: z.ZodLiteral<false>;
+            authoritySource: z.ZodLiteral<"ATLAS_RELEASE_BINDINGS">;
+        }, z.core.$strict>;
+        configurationHash: z.ZodString;
+        capturedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    readbackEvidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"VERIFIED">;
+        configuration: z.ZodObject<{
+            providerAgentId: z.ZodString;
+            agentBranchVersion: z.ZodObject<{
+                identifierContract: z.ZodEnum<{
+                    LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+                    NOT_USED: "NOT_USED";
+                    BRANCH_ONLY: "BRANCH_ONLY";
+                    VERSION_ONLY: "VERSION_ONLY";
+                    BRANCH_AND_VERSION: "BRANCH_AND_VERSION";
+                }>;
+                branchId: z.ZodNullable<z.ZodString>;
+                versionId: z.ZodNullable<z.ZodString>;
+                verifiedAt: z.ZodNullable<z.ZodISODateTime>;
+                evidenceRef: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+            privacy: z.ZodLiteral<"PRIVATE">;
+            procedureMappings: z.ZodArray<z.ZodObject<{
+                localProcedureKey: z.ZodString;
+                providerProcedureId: z.ZodString;
+                branchVersion: z.ZodObject<{
+                    identifierContract: z.ZodEnum<{
+                        LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+                        NOT_USED: "NOT_USED";
+                        BRANCH_ONLY: "BRANCH_ONLY";
+                        VERSION_ONLY: "VERSION_ONLY";
+                        BRANCH_AND_VERSION: "BRANCH_AND_VERSION";
+                    }>;
+                    branchId: z.ZodNullable<z.ZodString>;
+                    versionId: z.ZodNullable<z.ZodString>;
+                    verifiedAt: z.ZodNullable<z.ZodISODateTime>;
+                    evidenceRef: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            toolAliases: z.ZodArray<z.ZodString>;
+            generatedWorkflowHash: z.ZodString;
+            maxCallDurationSeconds: z.ZodNumber;
+            providerDurationCeilingSeconds: z.ZodNumber;
+            recordingEnabled: z.ZodBoolean;
+            retentionDays: z.ZodLiteral<-1>;
+            telephonyConnection: z.ZodLiteral<"ATLAS_TWILIO_REGISTER_CALL">;
+            directProviderConversationAccess: z.ZodLiteral<false>;
+            transfersEnabled: z.ZodLiteral<false>;
+            authoritySource: z.ZodLiteral<"ATLAS_RELEASE_BINDINGS">;
+        }, z.core.$strict>;
+        configurationHash: z.ZodString;
+        observedAt: z.ZodISODateTime;
+        evidenceRef: z.ZodString;
+        sanitizedDetail: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodEnum<{
+            INCOMPLETE: "INCOMPLETE";
+            CONTRADICTORY: "CONTRADICTORY";
+        }>;
+        configuration: z.ZodNullable<z.ZodObject<{
+            providerAgentId: z.ZodString;
+            agentBranchVersion: z.ZodObject<{
+                identifierContract: z.ZodEnum<{
+                    LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+                    NOT_USED: "NOT_USED";
+                    BRANCH_ONLY: "BRANCH_ONLY";
+                    VERSION_ONLY: "VERSION_ONLY";
+                    BRANCH_AND_VERSION: "BRANCH_AND_VERSION";
+                }>;
+                branchId: z.ZodNullable<z.ZodString>;
+                versionId: z.ZodNullable<z.ZodString>;
+                verifiedAt: z.ZodNullable<z.ZodISODateTime>;
+                evidenceRef: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+            privacy: z.ZodLiteral<"PRIVATE">;
+            procedureMappings: z.ZodArray<z.ZodObject<{
+                localProcedureKey: z.ZodString;
+                providerProcedureId: z.ZodString;
+                branchVersion: z.ZodObject<{
+                    identifierContract: z.ZodEnum<{
+                        LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+                        NOT_USED: "NOT_USED";
+                        BRANCH_ONLY: "BRANCH_ONLY";
+                        VERSION_ONLY: "VERSION_ONLY";
+                        BRANCH_AND_VERSION: "BRANCH_AND_VERSION";
+                    }>;
+                    branchId: z.ZodNullable<z.ZodString>;
+                    versionId: z.ZodNullable<z.ZodString>;
+                    verifiedAt: z.ZodNullable<z.ZodISODateTime>;
+                    evidenceRef: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            toolAliases: z.ZodArray<z.ZodString>;
+            generatedWorkflowHash: z.ZodString;
+            maxCallDurationSeconds: z.ZodNumber;
+            providerDurationCeilingSeconds: z.ZodNumber;
+            recordingEnabled: z.ZodBoolean;
+            retentionDays: z.ZodLiteral<-1>;
+            telephonyConnection: z.ZodLiteral<"ATLAS_TWILIO_REGISTER_CALL">;
+            directProviderConversationAccess: z.ZodLiteral<false>;
+            transfersEnabled: z.ZodLiteral<false>;
+            authoritySource: z.ZodLiteral<"ATLAS_RELEASE_BINDINGS">;
+        }, z.core.$strict>>;
+        configurationHash: z.ZodNullable<z.ZodString>;
+        observedAt: z.ZodISODateTime;
+        evidenceRef: z.ZodNullable<z.ZodString>;
+        sanitizedDetail: z.ZodString;
+    }, z.core.$strict>], "status">;
+    capabilityGates: z.ZodObject<{
+        procedureLifecycle: z.ZodObject<{
+            status: z.ZodEnum<{
+                LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+                VERIFIED_SUPPORTED: "VERIFIED_SUPPORTED";
+                VERIFIED_UNSUPPORTED: "VERIFIED_UNSUPPORTED";
+                DEFERRED: "DEFERRED";
+            }>;
+            verifiedAt: z.ZodNullable<z.ZodISODateTime>;
+            verifiedByPrincipalId: z.ZodNullable<z.ZodString>;
+            evidenceRef: z.ZodNullable<z.ZodString>;
+            sanitizedNote: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        durationEnforcement: z.ZodObject<{
+            status: z.ZodEnum<{
+                LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+                VERIFIED_SUPPORTED: "VERIFIED_SUPPORTED";
+                VERIFIED_UNSUPPORTED: "VERIFIED_UNSUPPORTED";
+                DEFERRED: "DEFERRED";
+            }>;
+            verifiedAt: z.ZodNullable<z.ZodISODateTime>;
+            verifiedByPrincipalId: z.ZodNullable<z.ZodString>;
+            evidenceRef: z.ZodNullable<z.ZodString>;
+            sanitizedNote: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        recording: z.ZodObject<{
+            status: z.ZodEnum<{
+                LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+                VERIFIED_SUPPORTED: "VERIFIED_SUPPORTED";
+                VERIFIED_UNSUPPORTED: "VERIFIED_UNSUPPORTED";
+                DEFERRED: "DEFERRED";
+            }>;
+            verifiedAt: z.ZodNullable<z.ZodISODateTime>;
+            verifiedByPrincipalId: z.ZodNullable<z.ZodString>;
+            evidenceRef: z.ZodNullable<z.ZodString>;
+            sanitizedNote: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        unlimitedRecordingRetention: z.ZodObject<{
+            status: z.ZodEnum<{
+                LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+                VERIFIED_SUPPORTED: "VERIFIED_SUPPORTED";
+                VERIFIED_UNSUPPORTED: "VERIFIED_UNSUPPORTED";
+                DEFERRED: "DEFERRED";
+            }>;
+            verifiedAt: z.ZodNullable<z.ZodISODateTime>;
+            verifiedByPrincipalId: z.ZodNullable<z.ZodString>;
+            evidenceRef: z.ZodNullable<z.ZodString>;
+            sanitizedNote: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        audioRetrieval: z.ZodObject<{
+            status: z.ZodEnum<{
+                LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+                VERIFIED_SUPPORTED: "VERIFIED_SUPPORTED";
+                VERIFIED_UNSUPPORTED: "VERIFIED_UNSUPPORTED";
+                DEFERRED: "DEFERRED";
+            }>;
+            verifiedAt: z.ZodNullable<z.ZodISODateTime>;
+            verifiedByPrincipalId: z.ZodNullable<z.ZodString>;
+            evidenceRef: z.ZodNullable<z.ZodString>;
+            sanitizedNote: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type VoiceProviderReleaseEvidence = z.infer<typeof voiceProviderReleaseEvidenceSchema>;
+export type VoiceProviderReleaseEvidenceInput = z.input<typeof voiceProviderReleaseEvidenceSchema>;
+export declare const voiceProviderReadinessBlockerSchema: z.ZodEnum<{
+    PUBLICATION_NOT_COMPLETE: "PUBLICATION_NOT_COMPLETE";
+    COMPILE_NOT_SUCCEEDED: "COMPILE_NOT_SUCCEEDED";
+    FINALIZATION_NOT_SUCCEEDED: "FINALIZATION_NOT_SUCCEEDED";
+    AGENT_BRANCH_VERSION_CONTRACT_UNVERIFIED: "AGENT_BRANCH_VERSION_CONTRACT_UNVERIFIED";
+    PROCEDURE_BRANCH_VERSION_CONTRACT_UNVERIFIED: "PROCEDURE_BRANCH_VERSION_CONTRACT_UNVERIFIED";
+    PROCEDURE_LIFECYCLE_NOT_VERIFIED: "PROCEDURE_LIFECYCLE_NOT_VERIFIED";
+    DURATION_ENFORCEMENT_NOT_VERIFIED: "DURATION_ENFORCEMENT_NOT_VERIFIED";
+    RECORDING_CAPABILITY_NOT_VERIFIED: "RECORDING_CAPABILITY_NOT_VERIFIED";
+    UNLIMITED_RECORDING_RETENTION_NOT_VERIFIED: "UNLIMITED_RECORDING_RETENTION_NOT_VERIFIED";
+    AUDIO_RETRIEVAL_NOT_VERIFIED: "AUDIO_RETRIEVAL_NOT_VERIFIED";
+    GENERATED_WORKFLOW_HASH_INVALID: "GENERATED_WORKFLOW_HASH_INVALID";
+    GENERATED_WORKFLOW_REFERENCE_MISMATCH: "GENERATED_WORKFLOW_REFERENCE_MISMATCH";
+    DESIRED_CONFIGURATION_HASH_INVALID: "DESIRED_CONFIGURATION_HASH_INVALID";
+    READBACK_NOT_VERIFIED: "READBACK_NOT_VERIFIED";
+    READBACK_CONFIGURATION_HASH_INVALID: "READBACK_CONFIGURATION_HASH_INVALID";
+    DESIRED_READBACK_MISMATCH: "DESIRED_READBACK_MISMATCH";
+    RELEASE_CONFIGURATION_MISMATCH: "RELEASE_CONFIGURATION_MISMATCH";
+}>;
+export type VoiceProviderReadinessBlocker = z.infer<typeof voiceProviderReadinessBlockerSchema>;
+export type VoiceProviderReadiness = {
+    ready: boolean;
+    blockers: VoiceProviderReadinessBlocker[];
+};
+export declare function evaluateVoiceProviderReleaseReadiness({ release }: {
+    release: VoiceProviderReleaseEvidence;
+}): VoiceProviderReadiness;

package/dist/voice-provider-release.js

@@ -0,0 +1,154 @@
+import { z } from 'zod';
+import { canonicalJson } from './canonical-json.js';
+import { voiceAgentScopeSchema, voiceHashSchema, voiceIdSchema, voiceTimestampSchema, } from './voice-common.js';
+import { hashVoiceProviderEvidenceValue, voiceCanonicalProcedureMappingsSchema, voiceGeneratedWorkflowEvidenceSchema, voiceProviderBranchVersionSchema, } from './voice-provider-evidence.js';
+import { voiceProviderCapabilityGateSchema, voiceProviderDesiredConfigurationSchema, voiceProviderPublicationProgressSchema, voiceProviderReadbackEvidenceSchema, } from './voice-provider-publication.js';
+export const voiceProviderReleaseEvidenceSchema = z.strictObject({
+    schemaVersion: z.literal('1'),
+    scope: voiceAgentScopeSchema,
+    releaseId: voiceIdSchema,
+    publicationOperationId: voiceIdSchema,
+    agentVersionId: voiceIdSchema,
+    createdByPrincipalId: voiceIdSchema,
+    createdAt: voiceTimestampSchema,
+    inputEvidence: z.strictObject({
+        authoredDefinitionHash: voiceHashSchema,
+        localProjectionCompilerVersion: voiceIdSchema,
+        localProjectionHash: voiceHashSchema,
+        eligibleToolCatalogHash: voiceHashSchema,
+        resolvedBindingHash: voiceHashSchema,
+    }),
+    ownedReleaseMarker: z.string().trim().min(1).max(500),
+    providerAgentId: voiceIdSchema,
+    agentBranchVersion: voiceProviderBranchVersionSchema,
+    procedureMappings: voiceCanonicalProcedureMappingsSchema,
+    publicationProgress: voiceProviderPublicationProgressSchema,
+    generatedWorkflow: voiceGeneratedWorkflowEvidenceSchema,
+    desiredConfiguration: voiceProviderDesiredConfigurationSchema,
+    readbackEvidence: voiceProviderReadbackEvidenceSchema,
+    capabilityGates: z.strictObject({
+        procedureLifecycle: voiceProviderCapabilityGateSchema,
+        durationEnforcement: voiceProviderCapabilityGateSchema,
+        recording: voiceProviderCapabilityGateSchema,
+        unlimitedRecordingRetention: voiceProviderCapabilityGateSchema,
+        audioRetrieval: voiceProviderCapabilityGateSchema,
+    }),
+}).superRefine((value, context) => {
+    if (Date.parse(value.desiredConfiguration.capturedAt) <
+        Date.parse(value.generatedWorkflow.capturedAt)) {
+        context.addIssue({
+            code: 'custom', path: ['desiredConfiguration', 'capturedAt'],
+            message: 'desired configuration must follow generated workflow validation',
+        });
+    }
+    if (Date.parse(value.readbackEvidence.observedAt) <
+        Date.parse(value.desiredConfiguration.capturedAt)) {
+        context.addIssue({
+            code: 'custom', path: ['readbackEvidence', 'observedAt'],
+            message: 'readback cannot precede desired configuration capture',
+        });
+    }
+});
+export const voiceProviderReadinessBlockerSchema = z.enum([
+    'PUBLICATION_NOT_COMPLETE', 'COMPILE_NOT_SUCCEEDED', 'FINALIZATION_NOT_SUCCEEDED',
+    'AGENT_BRANCH_VERSION_CONTRACT_UNVERIFIED',
+    'PROCEDURE_BRANCH_VERSION_CONTRACT_UNVERIFIED',
+    'PROCEDURE_LIFECYCLE_NOT_VERIFIED', 'DURATION_ENFORCEMENT_NOT_VERIFIED',
+    'RECORDING_CAPABILITY_NOT_VERIFIED',
+    'UNLIMITED_RECORDING_RETENTION_NOT_VERIFIED', 'AUDIO_RETRIEVAL_NOT_VERIFIED',
+    'GENERATED_WORKFLOW_HASH_INVALID', 'GENERATED_WORKFLOW_REFERENCE_MISMATCH',
+    'DESIRED_CONFIGURATION_HASH_INVALID', 'READBACK_NOT_VERIFIED',
+    'READBACK_CONFIGURATION_HASH_INVALID', 'DESIRED_READBACK_MISMATCH',
+    'RELEASE_CONFIGURATION_MISMATCH',
+]);
+function sameEvidence({ left, right }) {
+    return canonicalJson(left) === canonicalJson(right);
+}
+function evaluateProgress({ release, blockers }) {
+    if (release.publicationProgress.phase !== 'COMPLETE') {
+        blockers.add('PUBLICATION_NOT_COMPLETE');
+    }
+    if (release.publicationProgress.compile.status !== 'SUCCEEDED') {
+        blockers.add('COMPILE_NOT_SUCCEEDED');
+    }
+    if (release.publicationProgress.finalization.status !== 'SUCCEEDED') {
+        blockers.add('FINALIZATION_NOT_SUCCEEDED');
+    }
+    if (release.agentBranchVersion.identifierContract === 'LIVE_PROOF_PENDING') {
+        blockers.add('AGENT_BRANCH_VERSION_CONTRACT_UNVERIFIED');
+    }
+    if (release.procedureMappings.some(({ branchVersion }) => branchVersion.identifierContract === 'LIVE_PROOF_PENDING')) {
+        blockers.add('PROCEDURE_BRANCH_VERSION_CONTRACT_UNVERIFIED');
+    }
+}
+function evaluateWorkflow({ release, blockers }) {
+    const workflow = release.generatedWorkflow;
+    if (hashVoiceProviderEvidenceValue({ value: workflow.sanitizedDocument }) !==
+        workflow.documentHash)
+        blockers.add('GENERATED_WORKFLOW_HASH_INVALID');
+    const generatedRefs = workflow.normalized.procedures.map(({ localProcedureKey, providerProcedureId }) => ({ localProcedureKey, providerProcedureId }));
+    const releaseRefs = release.procedureMappings.map(({ localProcedureKey, providerProcedureId }) => ({ localProcedureKey, providerProcedureId }));
+    const desiredAliases = new Set(release.desiredConfiguration.configuration.toolAliases);
+    const procedureAliases = workflow.normalized.procedures
+        .flatMap(({ toolAliases }) => toolAliases);
+    if (release.desiredConfiguration.configuration.generatedWorkflowHash !== workflow.documentHash ||
+        !sameEvidence({ left: generatedRefs, right: releaseRefs }) ||
+        !sameEvidence({
+            left: workflow.normalized.toolAliases,
+            right: release.desiredConfiguration.configuration.toolAliases,
+        }) || procedureAliases.some((alias) => !desiredAliases.has(alias))) {
+        blockers.add('GENERATED_WORKFLOW_REFERENCE_MISMATCH');
+    }
+}
+function evaluateConfiguration({ release, blockers }) {
+    const desired = release.desiredConfiguration;
+    if (hashVoiceProviderEvidenceValue({ value: desired.configuration }) !==
+        desired.configurationHash)
+        blockers.add('DESIRED_CONFIGURATION_HASH_INVALID');
+    if (desired.configuration.providerAgentId !== release.providerAgentId ||
+        !sameEvidence({ left: desired.configuration.agentBranchVersion,
+            right: release.agentBranchVersion }) ||
+        !sameEvidence({ left: desired.configuration.procedureMappings,
+            right: release.procedureMappings }))
+        blockers.add('RELEASE_CONFIGURATION_MISMATCH');
+    const readback = release.readbackEvidence;
+    if (readback.status !== 'VERIFIED') {
+        blockers.add('READBACK_NOT_VERIFIED');
+        return;
+    }
+    if (hashVoiceProviderEvidenceValue({ value: readback.configuration }) !==
+        readback.configurationHash)
+        blockers.add('READBACK_CONFIGURATION_HASH_INVALID');
+    if (readback.configurationHash !== desired.configurationHash ||
+        !sameEvidence({ left: readback.configuration, right: desired.configuration })) {
+        blockers.add('DESIRED_READBACK_MISMATCH');
+    }
+}
+function evaluateCapabilities({ release, blockers }) {
+    const gates = release.capabilityGates;
+    if (gates.procedureLifecycle.status !== 'VERIFIED_SUPPORTED') {
+        blockers.add('PROCEDURE_LIFECYCLE_NOT_VERIFIED');
+    }
+    if (gates.durationEnforcement.status !== 'VERIFIED_SUPPORTED') {
+        blockers.add('DURATION_ENFORCEMENT_NOT_VERIFIED');
+    }
+    if (!release.desiredConfiguration.configuration.recordingEnabled)
+        return;
+    if (gates.recording.status !== 'VERIFIED_SUPPORTED') {
+        blockers.add('RECORDING_CAPABILITY_NOT_VERIFIED');
+    }
+    if (gates.unlimitedRecordingRetention.status !== 'VERIFIED_SUPPORTED') {
+        blockers.add('UNLIMITED_RECORDING_RETENTION_NOT_VERIFIED');
+    }
+    if (gates.audioRetrieval.status !== 'VERIFIED_SUPPORTED') {
+        blockers.add('AUDIO_RETRIEVAL_NOT_VERIFIED');
+    }
+}
+export function evaluateVoiceProviderReleaseReadiness({ release }) {
+    const blockers = new Set();
+    evaluateProgress({ release, blockers });
+    evaluateWorkflow({ release, blockers });
+    evaluateConfiguration({ release, blockers });
+    evaluateCapabilities({ release, blockers });
+    return { ready: blockers.size === 0, blockers: [...blockers] };
+}

package/dist/voice-provider.d.ts

@@ -0,0 +1,3 @@
+export * from './voice-provider-evidence.js';
+export * from './voice-provider-publication.js';
+export * from './voice-provider-release.js';

package/dist/voice-provider.js

@@ -0,0 +1,3 @@
+export * from './voice-provider-evidence.js';
+export * from './voice-provider-publication.js';
+export * from './voice-provider-release.js';