@sequenceholdings/agent-spec 0.1.1 → 0.1.3

package/dist/voice-provider-evidence.js

@@ -0,0 +1,115 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { canonicalJson } from './canonical-json.js';
+import { voiceHashSchema, voiceIdSchema, voiceLocalKeySchema, voiceTimestampSchema, } from './voice-common.js';
+export const MAX_VOICE_PROVIDER_DOCUMENT_BYTES = 128 * 1024;
+export const MAX_VOICE_PROVIDER_DOCUMENT_DEPTH = 12;
+export const MAX_VOICE_PROVIDER_DOCUMENT_NODES = 2_000;
+export const voiceProviderEvidenceReferenceSchema = z.string().trim().min(1).max(500);
+export const voiceSanitizedEvidenceTextSchema = z.string().trim().min(1).max(2_000);
+const SECRET_KEY = /(?:^|[_-])(authorization|credential|password|secret|token|api[_-]?key|call[_-]?grant)(?:$|[_-])/i;
+function inspectDocument({ value, path, depth, state, context, }) {
+    state.nodes += 1;
+    if (state.nodes > MAX_VOICE_PROVIDER_DOCUMENT_NODES) {
+        context.addIssue({ code: 'custom', message: 'sanitized provider document has too many nodes' });
+        return;
+    }
+    if (depth > MAX_VOICE_PROVIDER_DOCUMENT_DEPTH) {
+        context.addIssue({ code: 'custom', message: 'sanitized provider document is too deeply nested' });
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((entry, index) => inspectDocument({
+            value: entry,
+            path: `${path}[${index}]`,
+            depth: depth + 1,
+            state,
+            context,
+        }));
+        return;
+    }
+    if (value === null || typeof value !== 'object')
+        return;
+    for (const [key, entry] of Object.entries(value)) {
+        if (SECRET_KEY.test(key)) {
+            context.addIssue({
+                code: 'custom',
+                message: `${path}.${key} is a secret-bearing key and cannot be retained`,
+            });
+        }
+        inspectDocument({ value: entry, path: `${path}.${key}`, depth: depth + 1, state, context });
+    }
+}
+export const voiceSanitizedProviderDocumentSchema = z.json().superRefine((value, context) => {
+    if (Buffer.byteLength(JSON.stringify(value), 'utf8') > MAX_VOICE_PROVIDER_DOCUMENT_BYTES) {
+        context.addIssue({ code: 'custom', message: 'sanitized provider document is too large' });
+        return;
+    }
+    inspectDocument({ value, path: '(root)', depth: 0, state: { nodes: 0 }, context });
+});
+export function hashVoiceProviderEvidenceValue({ value }) {
+    return createHash('sha256').update(canonicalJson(value)).digest('hex');
+}
+export const voiceProviderBranchVersionSchema = z.strictObject({
+    identifierContract: z.enum([
+        'LIVE_PROOF_PENDING', 'NOT_USED', 'BRANCH_ONLY', 'VERSION_ONLY', 'BRANCH_AND_VERSION',
+    ]),
+    branchId: voiceIdSchema.nullable(),
+    versionId: voiceIdSchema.nullable(),
+    verifiedAt: voiceTimestampSchema.nullable(),
+    evidenceRef: voiceProviderEvidenceReferenceSchema.nullable(),
+}).superRefine((value, context) => {
+    const needsBranch = ['BRANCH_ONLY', 'BRANCH_AND_VERSION'].includes(value.identifierContract);
+    const needsVersion = ['VERSION_ONLY', 'BRANCH_AND_VERSION'].includes(value.identifierContract);
+    if (value.identifierContract === 'LIVE_PROOF_PENDING') {
+        if ([value.branchId, value.versionId, value.verifiedAt, value.evidenceRef]
+            .some((field) => field !== null)) {
+            context.addIssue({ code: 'custom', message: 'pending contract cannot claim verification' });
+        }
+        return;
+    }
+    if (value.verifiedAt === null || value.evidenceRef === null) {
+        context.addIssue({ code: 'custom', message: 'settled contract requires live proof' });
+    }
+    if (needsBranch !== (value.branchId !== null)) {
+        context.addIssue({ code: 'custom', path: ['branchId'], message: 'branchId contradicts contract' });
+    }
+    if (needsVersion !== (value.versionId !== null)) {
+        context.addIssue({ code: 'custom', path: ['versionId'], message: 'versionId contradicts contract' });
+    }
+});
+export const voiceProviderProcedureMappingSchema = z.strictObject({
+    localProcedureKey: voiceLocalKeySchema,
+    providerProcedureId: voiceIdSchema,
+    branchVersion: voiceProviderBranchVersionSchema,
+});
+export function isVoiceCanonicalList({ values }) {
+    return values.every((value, index) => index === 0 || (values[index - 1] ?? '') < value);
+}
+export const voiceCanonicalToolAliasesSchema = z.array(voiceLocalKeySchema).max(100)
+    .refine((values) => isVoiceCanonicalList({ values }), {
+    message: 'tool aliases must be unique and sorted in canonical order',
+});
+export const voiceCanonicalProcedureMappingsSchema = z.array(voiceProviderProcedureMappingSchema).max(100).refine((mappings) => isVoiceCanonicalList({ values: mappings.map(({ localProcedureKey }) => localProcedureKey) }) &&
+    new Set(mappings.map(({ providerProcedureId }) => providerProcedureId)).size === mappings.length, { message: 'procedureMappings must be sorted with unique local and provider IDs' });
+export const voiceGeneratedWorkflowEvidenceSchema = z.strictObject({
+    schemaVersion: z.literal('1'),
+    capturedAt: voiceTimestampSchema,
+    documentHash: voiceHashSchema,
+    sanitizedDocument: voiceSanitizedProviderDocumentSchema,
+    normalized: z.strictObject({
+        authoritySource: z.literal('ATLAS_RELEASE_BINDINGS'),
+        procedures: z.array(z.strictObject({
+            localProcedureKey: voiceLocalKeySchema,
+            providerProcedureId: voiceIdSchema,
+            toolAliases: voiceCanonicalToolAliasesSchema,
+            referencedProviderProcedureIds: z.array(voiceIdSchema).max(100)
+                .refine((values) => isVoiceCanonicalList({ values }), {
+                message: 'procedure references must be unique and sorted',
+            }),
+        })).max(100).refine((procedures) => isVoiceCanonicalList({
+            values: procedures.map(({ localProcedureKey }) => localProcedureKey),
+        }), { message: 'generated procedures must be unique and sorted' }),
+        toolAliases: voiceCanonicalToolAliasesSchema,
+    }),
+});

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

@@ -0,0 +1,319 @@
+import { z } from 'zod';
+export declare const voiceProviderOperationResultSchema: 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">;
+export type VoiceProviderOperationResult = z.infer<typeof voiceProviderOperationResultSchema>;
+export declare const voiceProviderPublicationProgressSchema: 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>;
+export type VoiceProviderPublicationProgress = z.infer<typeof voiceProviderPublicationProgressSchema>;
+export declare const voiceProviderNormalizedConfigurationSchema: 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>;
+export type VoiceProviderNormalizedConfiguration = z.infer<typeof voiceProviderNormalizedConfigurationSchema>;
+export declare const voiceProviderDesiredConfigurationSchema: 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>;
+export type VoiceProviderDesiredConfiguration = z.infer<typeof voiceProviderDesiredConfigurationSchema>;
+export declare const voiceProviderReadbackEvidenceSchema: 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">;
+export type VoiceProviderReadbackEvidence = z.infer<typeof voiceProviderReadbackEvidenceSchema>;
+export declare const voiceProviderCapabilityGateSchema: 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>;
+export type VoiceProviderCapabilityGate = z.infer<typeof voiceProviderCapabilityGateSchema>;

package/dist/voice-provider-publication.js

@@ -0,0 +1,117 @@
+import { z } from 'zod';
+import { voiceHashSchema, voiceIdSchema, voiceTimestampSchema } from './voice-common.js';
+import { voiceCanonicalProcedureMappingsSchema, voiceCanonicalToolAliasesSchema, voiceProviderBranchVersionSchema, voiceProviderEvidenceReferenceSchema, voiceSanitizedEvidenceTextSchema, } from './voice-provider-evidence.js';
+const operationIdSchema = z.string().trim().min(1).max(300);
+const operationBase = { operationId: operationIdSchema, startedAt: voiceTimestampSchema };
+export const voiceProviderOperationResultSchema = z.discriminatedUnion('status', [
+    z.strictObject({ status: z.literal('NOT_STARTED'), operationId: operationIdSchema }),
+    z.strictObject({
+        status: z.literal('IN_PROGRESS'), ...operationBase, lastObservedAt: voiceTimestampSchema,
+    }),
+    z.strictObject({
+        status: z.literal('SUCCEEDED'), ...operationBase, completedAt: voiceTimestampSchema,
+        receiptId: voiceIdSchema.nullable(),
+    }),
+    z.strictObject({
+        status: z.literal('FAILED'), ...operationBase, failedAt: voiceTimestampSchema,
+        errorCode: z.string().trim().min(1).max(100),
+        sanitizedMessage: voiceSanitizedEvidenceTextSchema,
+        retryable: z.boolean(),
+    }),
+    z.strictObject({
+        status: z.literal('UNKNOWN'), ...operationBase, observedAt: voiceTimestampSchema,
+        reconciliationKey: z.string().trim().min(1).max(500),
+        sanitizedReason: voiceSanitizedEvidenceTextSchema,
+    }),
+]);
+export const voiceProviderPublicationProgressSchema = z.strictObject({
+    phase: z.enum([
+        'CREATE_AGENT', 'CREATE_PROCEDURES', 'COMPILE', 'VALIDATE_GENERATED_WORKFLOW',
+        'FINALIZE', 'READBACK', 'COMPLETE', 'FAILED', 'RECONCILIATION_REQUIRED',
+    ]),
+    compile: voiceProviderOperationResultSchema,
+    finalization: voiceProviderOperationResultSchema,
+    updatedAt: voiceTimestampSchema,
+}).superRefine((value, context) => {
+    const unknown = value.compile.status === 'UNKNOWN' || value.finalization.status === 'UNKNOWN';
+    if (unknown && value.phase !== 'RECONCILIATION_REQUIRED') {
+        context.addIssue({ code: 'custom', message: 'unknown results require RECONCILIATION_REQUIRED' });
+    }
+    if (value.phase === 'COMPLETE' &&
+        (value.compile.status !== 'SUCCEEDED' || value.finalization.status !== 'SUCCEEDED')) {
+        context.addIssue({
+            code: 'custom', message: 'COMPLETE requires successful compile and finalization evidence',
+        });
+    }
+});
+export const voiceProviderNormalizedConfigurationSchema = z.strictObject({
+    providerAgentId: voiceIdSchema,
+    agentBranchVersion: voiceProviderBranchVersionSchema,
+    privacy: z.literal('PRIVATE'),
+    procedureMappings: voiceCanonicalProcedureMappingsSchema,
+    toolAliases: voiceCanonicalToolAliasesSchema,
+    generatedWorkflowHash: voiceHashSchema,
+    maxCallDurationSeconds: z.number().int().positive().safe(),
+    providerDurationCeilingSeconds: z.number().int().positive().safe(),
+    recordingEnabled: z.boolean(),
+    retentionDays: z.literal(-1),
+    telephonyConnection: z.literal('ATLAS_TWILIO_REGISTER_CALL'),
+    directProviderConversationAccess: z.literal(false),
+    transfersEnabled: z.literal(false),
+    authoritySource: z.literal('ATLAS_RELEASE_BINDINGS'),
+}).superRefine((value, context) => {
+    if (value.maxCallDurationSeconds > value.providerDurationCeilingSeconds) {
+        context.addIssue({
+            code: 'custom', path: ['maxCallDurationSeconds'],
+            message: 'call duration exceeds the verified provider release ceiling',
+        });
+    }
+});
+export const voiceProviderDesiredConfigurationSchema = z.strictObject({
+    configuration: voiceProviderNormalizedConfigurationSchema,
+    configurationHash: voiceHashSchema,
+    capturedAt: voiceTimestampSchema,
+});
+const verifiedReadbackSchema = z.strictObject({
+    status: z.literal('VERIFIED'),
+    configuration: voiceProviderNormalizedConfigurationSchema,
+    configurationHash: voiceHashSchema,
+    observedAt: voiceTimestampSchema,
+    evidenceRef: voiceProviderEvidenceReferenceSchema,
+    sanitizedDetail: voiceSanitizedEvidenceTextSchema.nullable(),
+});
+const unresolvedReadbackSchema = z.strictObject({
+    status: z.enum(['INCOMPLETE', 'CONTRADICTORY']),
+    configuration: voiceProviderNormalizedConfigurationSchema.nullable(),
+    configurationHash: voiceHashSchema.nullable(),
+    observedAt: voiceTimestampSchema,
+    evidenceRef: voiceProviderEvidenceReferenceSchema.nullable(),
+    sanitizedDetail: voiceSanitizedEvidenceTextSchema,
+});
+export const voiceProviderReadbackEvidenceSchema = z.discriminatedUnion('status', [
+    verifiedReadbackSchema, unresolvedReadbackSchema,
+]);
+export const voiceProviderCapabilityGateSchema = z.strictObject({
+    status: z.enum([
+        'LIVE_PROOF_PENDING', 'VERIFIED_SUPPORTED', 'VERIFIED_UNSUPPORTED', 'DEFERRED',
+    ]),
+    verifiedAt: voiceTimestampSchema.nullable(),
+    verifiedByPrincipalId: voiceIdSchema.nullable(),
+    evidenceRef: voiceProviderEvidenceReferenceSchema.nullable(),
+    sanitizedNote: voiceSanitizedEvidenceTextSchema.nullable(),
+}).superRefine((value, context) => {
+    const proof = [value.verifiedAt, value.verifiedByPrincipalId, value.evidenceRef];
+    if (value.status === 'LIVE_PROOF_PENDING') {
+        if (proof.some((field) => field !== null)) {
+            context.addIssue({ code: 'custom', message: 'pending gate cannot claim verification' });
+        }
+        return;
+    }
+    if (proof.some((field) => field === null)) {
+        context.addIssue({ code: 'custom', message: 'settled capability gate requires attribution' });
+    }
+    if (['VERIFIED_UNSUPPORTED', 'DEFERRED'].includes(value.status) &&
+        value.sanitizedNote === null) {
+        context.addIssue({ code: 'custom', message: 'unsupported/deferred gate requires a note' });
+    }
+});