@sequenceholdings/agent-spec 0.1.1 → 0.1.3

package/dist/voice-authoring.js

@@ -0,0 +1,132 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { canonicalJson } from './canonical-json.js';
+import { isReservedVoiceVariable, voiceHashSchema, voiceIdSchema, voiceLocalKeySchema } from './voice-common.js';
+const compareKeys = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+const fieldSchema = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,63}$/).refine((name) => !isReservedVoiceVariable({ name }) && !['__proto__', 'constructor', 'prototype'].includes(name), 'Reserved Voice field');
+const uniqueKeysSchema = z.array(voiceLocalKeySchema).max(64)
+    .refine((keys) => new Set(keys).size === keys.length, 'Duplicate references are not allowed')
+    .transform((keys) => [...keys].sort(compareKeys));
+export function hashVoiceSkillContent({ name, instructions }) {
+    return createHash('sha256').update('sequence-voice-skill-content-v1\0')
+        .update(canonicalJson({ name, instructions })).digest('hex');
+}
+export const capturedVoiceProcedureSchema = z.strictObject({
+    key: voiceLocalKeySchema,
+    name: z.string().trim().min(1).max(200),
+    instructions: z.string().min(1).max(100_000).refine((text) => text.trim().length > 0, 'Instructions must contain text'),
+    activationDescription: z.string().trim().max(4_000),
+    source: z.strictObject({ skillId: voiceIdSchema, contentHash: voiceHashSchema.optional() }),
+    toolAliases: uniqueKeysSchema.default([]),
+    subprocedures: uniqueKeysSchema.default([]),
+}).transform((procedure) => ({ ...procedure, source: {
+        skillId: procedure.source.skillId,
+        contentHash: hashVoiceSkillContent({ name: procedure.name, instructions: procedure.instructions }),
+    } }));
+export const voiceAuthoredToolSchema = z.strictObject({
+    alias: voiceLocalKeySchema.refine((name) => !isReservedVoiceVariable({ name }), 'Reserved Voice alias'),
+    description: z.string().trim().min(1).max(4_000),
+    managedFunction: z.strictObject({
+        ref: z.string().max(200).regex(/^[a-z0-9][a-z0-9_-]*(?:\/[a-z0-9][a-z0-9_-]*)*$/),
+        operation: voiceLocalKeySchema,
+    }),
+    inputMappings: z.array(z.strictObject({ argument: fieldSchema, parameter: fieldSchema })).max(64).default([]),
+    outputMappings: z.array(z.strictObject({ field: fieldSchema, result: fieldSchema })).max(64).default([]),
+}).superRefine((tool, context) => {
+    for (const [name, keys] of [
+        ['inputMappings', tool.inputMappings.map((item) => item.argument)],
+        ['inputMappings', tool.inputMappings.map((item) => item.parameter)],
+        ['outputMappings', tool.outputMappings.map((item) => item.field)],
+        ['outputMappings', tool.outputMappings.map((item) => item.result)],
+    ]) {
+        if (new Set(keys).size !== keys.length)
+            context.addIssue({ code: 'custom', path: [name], message: 'Duplicate mapping field' });
+    }
+}).transform((tool) => ({ ...tool,
+    inputMappings: [...tool.inputMappings].sort((a, b) => compareKeys(a.argument, b.argument)),
+    outputMappings: [...tool.outputMappings].sort((a, b) => compareKeys(a.result, b.result)),
+}));
+const voiceDeclarationBaseSchema = z.strictObject({
+    schemaVersion: z.literal('1'),
+    voice: voiceIdSchema,
+    language: z.string().regex(/^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/).max(35),
+    firstMessage: z.string().trim().min(1).max(4_000),
+    procedures: z.array(capturedVoiceProcedureSchema).max(32).default([]),
+    tools: z.array(voiceAuthoredToolSchema).max(64).default([]),
+});
+function validateProcedureDependencies({ voice, context, }) {
+    const keys = new Set(voice.procedures.map((item) => item.key));
+    const aliases = new Set(voice.tools.map((item) => item.alias));
+    const referencedProcedures = new Set(voice.procedures.flatMap((item) => item.subprocedures));
+    if (keys.size !== voice.procedures.length)
+        context.addIssue({ code: 'custom', path: ['procedures'], message: 'Duplicate procedure key' });
+    if (new Set(voice.procedures.map((item) => item.source.skillId)).size !== voice.procedures.length) {
+        context.addIssue({ code: 'custom', path: ['procedures'], message: 'Capture each native Skill once' });
+    }
+    if (aliases.size !== voice.tools.length)
+        context.addIssue({ code: 'custom', path: ['tools'], message: 'Duplicate tool alias' });
+    for (const [index, procedure] of voice.procedures.entries()) {
+        if (procedure.activationDescription === '' && !referencedProcedures.has(procedure.key)) {
+            context.addIssue({ code: 'custom', path: ['procedures', index, 'activationDescription'],
+                message: 'An empty activation description requires a reference from another procedure' });
+        }
+        for (const [field, references, declared] of [
+            ['toolAliases', procedure.toolAliases, aliases], ['subprocedures', procedure.subprocedures, keys],
+        ]) {
+            for (const reference of references)
+                if (!declared.has(reference)) {
+                    context.addIssue({ code: 'custom', path: ['procedures', index, field], message: `Undeclared reference: ${reference}` });
+                }
+        }
+    }
+    const byKey = new Map(voice.procedures.map((item) => [item.key, item]));
+    const visited = new Set();
+    const active = new Set();
+    function hasCycle(key) {
+        if (active.has(key))
+            return true;
+        if (visited.has(key))
+            return false;
+        active.add(key);
+        for (const child of byKey.get(key)?.subprocedures ?? [])
+            if (hasCycle(child))
+                return true;
+        active.delete(key);
+        visited.add(key);
+        return false;
+    }
+    if ([...keys].some(hasCycle))
+        context.addIssue({ code: 'custom', path: ['procedures'], message: 'Cyclic subprocedure reference' });
+}
+export const voiceDeclarationSchema = voiceDeclarationBaseSchema
+    .superRefine((voice, context) => validateProcedureDependencies({ voice, context }))
+    .transform((voice) => ({ ...voice,
+    procedures: [...voice.procedures].sort((a, b) => compareKeys(a.key, b.key)),
+    tools: [...voice.tools].sort((a, b) => compareKeys(a.alias, b.alias)),
+}));
+export const voiceSupportedAuthoringOptionsSchema = z.strictObject({
+    voices: z.array(voiceIdSchema),
+    languages: z.array(z.string().min(1)),
+    models: z.array(z.strictObject({ provider: voiceIdSchema, name: voiceIdSchema })),
+});
+export function validateVoiceAuthoringOptions({ voice, model, supported }) {
+    if (!supported.voices.includes(voice.voice))
+        throw new Error('Unsupported Voice selection');
+    if (!supported.languages.includes(voice.language))
+        throw new Error('Unsupported Voice language');
+    if (!supported.models.some((option) => option.provider === model.provider && option.name === model.name)) {
+        throw new Error('Unsupported Voice model');
+    }
+}
+export const VOICE_LOCAL_PROJECTION_VERSION = 'voice-free-form-v1';
+export const voiceProjectionInputSchema = z.strictObject({
+    systemPrompt: z.string().min(1).max(100_000),
+    model: z.strictObject({ provider: voiceIdSchema, name: voiceIdSchema }),
+    voice: voiceDeclarationSchema,
+});
+export function projectVoiceAuthoring(input) {
+    const captured = voiceProjectionInputSchema.parse(input);
+    const projection = { compilerVersion: VOICE_LOCAL_PROJECTION_VERSION, ...captured };
+    return { ...projection, digest: createHash('sha256').update('sequence-voice-local-projection-v1\0')
+            .update(canonicalJson(projection)).digest('hex') };
+}

package/dist/voice-authority-contracts.d.ts

@@ -0,0 +1,247 @@
+import { z } from 'zod';
+export declare const voiceCallSubjectSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    environmentId: z.ZodString;
+    agentId: z.ZodString;
+    sessionId: z.ZodString;
+    releaseId: z.ZodString;
+}, z.core.$strict>;
+export type VoiceCallSubject = z.infer<typeof voiceCallSubjectSchema>;
+export declare const voiceResourceReferenceSchema: z.ZodObject<{
+    kind: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strict>;
+export type VoiceResourceReference = z.infer<typeof voiceResourceReferenceSchema>;
+export declare function sameVoiceResource({ left, right }: {
+    left: VoiceResourceReference;
+    right: VoiceResourceReference;
+}): boolean;
+export declare const voiceToolOperationRequirementSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    authority: z.ZodLiteral<"public">;
+    effect: z.ZodLiteral<"pure_input_computation">;
+}, z.core.$strict>, z.ZodObject<{
+    authority: z.ZodLiteral<"public">;
+    effect: z.ZodLiteral<"unverified_write">;
+}, z.core.$strict>, z.ZodObject<{
+    authority: z.ZodLiteral<"authentication">;
+    effect: z.ZodLiteral<"resource_verification">;
+    resourceKind: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    authority: z.ZodLiteral<"protected">;
+    effect: z.ZodEnum<{
+        resource_read: "resource_read";
+        resource_write: "resource_write";
+    }>;
+    resourceKind: z.ZodString;
+}, z.core.$strict>], "effect">;
+export type VoiceToolOperationRequirement = z.infer<typeof voiceToolOperationRequirementSchema>;
+export declare function resolveVoiceToolOperationRequirement({ requirement, }: {
+    requirement: VoiceToolOperationRequirement | undefined;
+}): VoiceToolOperationRequirement;
+export declare const voiceToolBindingSchema: z.ZodObject<{
+    toolAlias: z.ZodString;
+    operation: z.ZodString;
+    managedFunctionId: z.ZodString;
+    functionVersionId: z.ZodString;
+    sourceHash: z.ZodString;
+    manifestHash: z.ZodString;
+    dataBinding: z.ZodObject<{
+        attachedIdentityId: z.ZodString;
+        dataScopeHash: z.ZodString;
+    }, z.core.$strict>;
+    runtimeBinding: z.ZodObject<{
+        runtimeAccountId: z.ZodString;
+        permissionHash: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type VoiceToolBinding = z.infer<typeof voiceToolBindingSchema>;
+export declare const voicePublicationToolReviewSchema: z.ZodObject<{
+    reviewId: z.ZodString;
+    releaseId: z.ZodString;
+    scope: z.ZodObject<{
+        tenantId: z.ZodString;
+        environmentId: z.ZodString;
+        agentId: z.ZodString;
+    }, z.core.$strict>;
+    reviewKind: z.ZodEnum<{
+        performed: "performed";
+        reused: "reused";
+    }>;
+    reusedFromReviewId: z.ZodNullable<z.ZodString>;
+    reviewerPrincipalId: z.ZodString;
+    reviewedAt: z.ZodISODateTime;
+    syntheticOnlyConfirmed: z.ZodLiteral<true>;
+    requirement: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        authority: z.ZodLiteral<"public">;
+        effect: z.ZodLiteral<"pure_input_computation">;
+    }, z.core.$strict>, z.ZodObject<{
+        authority: z.ZodLiteral<"public">;
+        effect: z.ZodLiteral<"unverified_write">;
+    }, z.core.$strict>, z.ZodObject<{
+        authority: z.ZodLiteral<"authentication">;
+        effect: z.ZodLiteral<"resource_verification">;
+        resourceKind: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        authority: z.ZodLiteral<"protected">;
+        effect: z.ZodEnum<{
+            resource_read: "resource_read";
+            resource_write: "resource_write";
+        }>;
+        resourceKind: z.ZodString;
+    }, z.core.$strict>], "effect">;
+    binding: z.ZodObject<{
+        toolAlias: z.ZodString;
+        operation: z.ZodString;
+        managedFunctionId: z.ZodString;
+        functionVersionId: z.ZodString;
+        sourceHash: z.ZodString;
+        manifestHash: z.ZodString;
+        dataBinding: z.ZodObject<{
+            attachedIdentityId: z.ZodString;
+            dataScopeHash: z.ZodString;
+        }, z.core.$strict>;
+        runtimeBinding: z.ZodObject<{
+            runtimeAccountId: z.ZodString;
+            permissionHash: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type VoicePublicationToolReview = z.infer<typeof voicePublicationToolReviewSchema>;
+export declare function isVoicePublicationToolReviewCurrent({ review, currentBinding, currentRequirement, }: {
+    review: VoicePublicationToolReview;
+    currentBinding: VoiceToolBinding;
+    currentRequirement: VoiceToolOperationRequirement;
+}): boolean;
+export declare const voiceVerificationStatusSchema: z.ZodEnum<{
+    unverified: "unverified";
+    verified: "verified";
+    locked: "locked";
+    expired: "expired";
+    revoked: "revoked";
+}>;
+export type VoiceVerificationStatus = z.infer<typeof voiceVerificationStatusSchema>;
+export declare const voiceVerificationStateSchema: z.ZodObject<{
+    subject: z.ZodObject<{
+        tenantId: z.ZodString;
+        environmentId: z.ZodString;
+        agentId: z.ZodString;
+        sessionId: z.ZodString;
+        releaseId: z.ZodString;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        unverified: "unverified";
+        verified: "verified";
+        locked: "locked";
+        expired: "expired";
+        revoked: "revoked";
+    }>;
+    attemptBudget: z.ZodObject<{
+        maxAttempts: z.ZodNumber;
+        usedAttempts: z.ZodNumber;
+    }, z.core.$strict>;
+    verifiedResource: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+    verificationId: z.ZodNullable<z.ZodString>;
+    verificationMethodKey: z.ZodNullable<z.ZodString>;
+    verificationExpiresAt: z.ZodNullable<z.ZodISODateTime>;
+    authorityExpiresAt: z.ZodISODateTime;
+    revision: z.ZodNumber;
+}, z.core.$strict>;
+export type VoiceVerificationState = z.infer<typeof voiceVerificationStateSchema>;
+export declare const voiceVerificationAttemptRequestSchema: z.ZodObject<{
+    attemptId: z.ZodString;
+    subject: z.ZodObject<{
+        tenantId: z.ZodString;
+        environmentId: z.ZodString;
+        agentId: z.ZodString;
+        sessionId: z.ZodString;
+        releaseId: z.ZodString;
+    }, z.core.$strict>;
+    candidateResource: z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    methodKey: z.ZodString;
+    idempotencyKey: z.ZodString;
+    requestDigest: z.ZodString;
+    attemptedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type VoiceVerificationAttemptRequest = z.infer<typeof voiceVerificationAttemptRequestSchema>;
+export declare const voiceVerificationAttemptSchema: z.ZodObject<{
+    attemptId: z.ZodString;
+    subject: z.ZodObject<{
+        tenantId: z.ZodString;
+        environmentId: z.ZodString;
+        agentId: z.ZodString;
+        sessionId: z.ZodString;
+        releaseId: z.ZodString;
+    }, z.core.$strict>;
+    candidateResource: z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    methodKey: z.ZodString;
+    idempotencyKey: z.ZodString;
+    requestDigest: z.ZodString;
+    attemptedAt: z.ZodISODateTime;
+    attemptNumber: z.ZodNumber;
+    status: z.ZodEnum<{
+        verified: "verified";
+        pending: "pending";
+        rejected: "rejected";
+        uncertain: "uncertain";
+    }>;
+    completedAt: z.ZodNullable<z.ZodISODateTime>;
+    verifierInvocationId: z.ZodNullable<z.ZodString>;
+    verificationId: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type VoiceVerificationAttempt = z.infer<typeof voiceVerificationAttemptSchema>;
+export declare const voiceTrustedVerifierResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    verificationExpiresAt: z.ZodISODateTime;
+    verificationId: z.ZodString;
+    attemptId: z.ZodString;
+    subject: z.ZodObject<{
+        tenantId: z.ZodString;
+        environmentId: z.ZodString;
+        agentId: z.ZodString;
+        sessionId: z.ZodString;
+        releaseId: z.ZodString;
+    }, z.core.$strict>;
+    candidateResource: z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    methodKey: z.ZodString;
+    idempotencyKey: z.ZodString;
+    requestDigest: z.ZodString;
+    verifierReviewId: z.ZodString;
+    verifierInvocationId: z.ZodString;
+    observedFunctionVersionId: z.ZodString;
+    completedAt: z.ZodISODateTime;
+    verdict: z.ZodLiteral<"verified">;
+}, z.core.$strict>, z.ZodObject<{
+    verificationId: z.ZodString;
+    attemptId: z.ZodString;
+    subject: z.ZodObject<{
+        tenantId: z.ZodString;
+        environmentId: z.ZodString;
+        agentId: z.ZodString;
+        sessionId: z.ZodString;
+        releaseId: z.ZodString;
+    }, z.core.$strict>;
+    candidateResource: z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    methodKey: z.ZodString;
+    idempotencyKey: z.ZodString;
+    requestDigest: z.ZodString;
+    verifierReviewId: z.ZodString;
+    verifierInvocationId: z.ZodString;
+    observedFunctionVersionId: z.ZodString;
+    completedAt: z.ZodISODateTime;
+    verdict: z.ZodLiteral<"rejected">;
+}, z.core.$strict>], "verdict">;
+export type VoiceTrustedVerifierResult = z.infer<typeof voiceTrustedVerifierResultSchema>;

package/dist/voice-authority-contracts.js

@@ -0,0 +1,177 @@
+import { z } from 'zod';
+import { voiceAgentScopeSchema, voiceHashSchema, voiceIdSchema, voiceLocalKeySchema, voiceRevisionSchema, voiceTimestampSchema, } from './voice-common.js';
+export const voiceCallSubjectSchema = voiceAgentScopeSchema.extend({
+    sessionId: voiceIdSchema,
+    releaseId: voiceIdSchema,
+});
+export const voiceResourceReferenceSchema = z.strictObject({
+    kind: voiceLocalKeySchema,
+    id: voiceIdSchema,
+});
+export function sameVoiceResource({ left, right }) {
+    return left.kind === right.kind && left.id === right.id;
+}
+const publicPureOperationSchema = z.strictObject({
+    authority: z.literal('public'),
+    effect: z.literal('pure_input_computation'),
+});
+const publicUnverifiedWriteOperationSchema = z.strictObject({
+    authority: z.literal('public'),
+    effect: z.literal('unverified_write'),
+});
+const authenticationOperationSchema = z.strictObject({
+    authority: z.literal('authentication'),
+    effect: z.literal('resource_verification'),
+    resourceKind: voiceLocalKeySchema,
+});
+const protectedOperationSchema = z.strictObject({
+    authority: z.literal('protected'),
+    effect: z.enum(['resource_read', 'resource_write']),
+    resourceKind: voiceLocalKeySchema,
+});
+export const voiceToolOperationRequirementSchema = z.discriminatedUnion('effect', [
+    publicPureOperationSchema,
+    publicUnverifiedWriteOperationSchema,
+    authenticationOperationSchema,
+    protectedOperationSchema,
+]);
+export function resolveVoiceToolOperationRequirement({ requirement, }) {
+    return voiceToolOperationRequirementSchema.parse(requirement);
+}
+export const voiceToolBindingSchema = z.strictObject({
+    toolAlias: voiceLocalKeySchema,
+    operation: voiceLocalKeySchema,
+    managedFunctionId: voiceIdSchema,
+    functionVersionId: voiceIdSchema,
+    sourceHash: voiceHashSchema,
+    manifestHash: voiceHashSchema,
+    dataBinding: z.strictObject({
+        attachedIdentityId: voiceIdSchema,
+        dataScopeHash: voiceHashSchema,
+    }),
+    runtimeBinding: z.strictObject({
+        runtimeAccountId: voiceIdSchema,
+        permissionHash: voiceHashSchema,
+    }),
+});
+export const voicePublicationToolReviewSchema = z
+    .strictObject({
+    reviewId: voiceIdSchema,
+    releaseId: voiceIdSchema,
+    scope: voiceAgentScopeSchema,
+    reviewKind: z.enum(['performed', 'reused']),
+    reusedFromReviewId: voiceIdSchema.nullable(),
+    reviewerPrincipalId: voiceIdSchema,
+    reviewedAt: voiceTimestampSchema,
+    syntheticOnlyConfirmed: z.literal(true),
+    requirement: voiceToolOperationRequirementSchema,
+    binding: voiceToolBindingSchema,
+})
+    .superRefine((review, context) => {
+    if (review.reviewKind === 'performed' && review.reusedFromReviewId !== null) {
+        context.addIssue({
+            code: 'custom', path: ['reusedFromReviewId'],
+            message: 'a performed review cannot reuse another review',
+        });
+    }
+    if (review.reviewKind === 'reused' && review.reusedFromReviewId === null) {
+        context.addIssue({
+            code: 'custom', path: ['reusedFromReviewId'],
+            message: 'a reused review must identify its source review',
+        });
+    }
+});
+function sameToolBinding({ left, right }) {
+    return left.toolAlias === right.toolAlias &&
+        left.operation === right.operation &&
+        left.managedFunctionId === right.managedFunctionId &&
+        left.functionVersionId === right.functionVersionId &&
+        left.sourceHash === right.sourceHash &&
+        left.manifestHash === right.manifestHash &&
+        left.dataBinding.attachedIdentityId === right.dataBinding.attachedIdentityId &&
+        left.dataBinding.dataScopeHash === right.dataBinding.dataScopeHash &&
+        left.runtimeBinding.runtimeAccountId === right.runtimeBinding.runtimeAccountId &&
+        left.runtimeBinding.permissionHash === right.runtimeBinding.permissionHash;
+}
+export function isVoicePublicationToolReviewCurrent({ review, currentBinding, currentRequirement, }) {
+    const parsedReview = voicePublicationToolReviewSchema.parse(review);
+    const parsedBinding = voiceToolBindingSchema.parse(currentBinding);
+    const parsedRequirement = voiceToolOperationRequirementSchema.parse(currentRequirement);
+    return sameToolBinding({ left: parsedReview.binding, right: parsedBinding }) &&
+        parsedReview.requirement.authority === parsedRequirement.authority &&
+        parsedReview.requirement.effect === parsedRequirement.effect &&
+        (parsedReview.requirement.authority === 'public' || (parsedRequirement.authority !== 'public' &&
+            parsedReview.requirement.resourceKind === parsedRequirement.resourceKind));
+}
+export const voiceVerificationStatusSchema = z.enum([
+    'unverified', 'verified', 'locked', 'expired', 'revoked',
+]);
+export const voiceVerificationStateSchema = z
+    .strictObject({
+    subject: voiceCallSubjectSchema,
+    status: voiceVerificationStatusSchema,
+    attemptBudget: z.strictObject({
+        maxAttempts: z.number().int().positive().max(100).safe(),
+        usedAttempts: z.number().int().nonnegative().max(100).safe(),
+    }),
+    verifiedResource: voiceResourceReferenceSchema.nullable(),
+    verificationId: voiceIdSchema.nullable(),
+    verificationMethodKey: voiceLocalKeySchema.nullable(),
+    verificationExpiresAt: voiceTimestampSchema.nullable(),
+    authorityExpiresAt: voiceTimestampSchema,
+    revision: voiceRevisionSchema,
+})
+    .superRefine((state, context) => {
+    if (state.attemptBudget.usedAttempts > state.attemptBudget.maxAttempts) {
+        context.addIssue({
+            code: 'custom', path: ['attemptBudget', 'usedAttempts'],
+            message: 'used verification attempts cannot exceed the shared budget',
+        });
+    }
+    const evidence = [state.verifiedResource, state.verificationId,
+        state.verificationMethodKey, state.verificationExpiresAt];
+    const incompleteVerified = state.status === 'verified' && evidence.some((value) => value === null);
+    const authorityOnInactive = state.status !== 'verified' && evidence.some((value) => value !== null);
+    if (incompleteVerified || authorityOnInactive) {
+        context.addIssue({
+            code: 'custom', path: ['status'],
+            message: 'only verified state may retain complete resource authority evidence',
+        });
+    }
+});
+export const voiceVerificationAttemptRequestSchema = z.strictObject({
+    attemptId: voiceIdSchema,
+    subject: voiceCallSubjectSchema,
+    candidateResource: voiceResourceReferenceSchema,
+    methodKey: voiceLocalKeySchema,
+    idempotencyKey: voiceIdSchema,
+    requestDigest: voiceHashSchema,
+    attemptedAt: voiceTimestampSchema,
+});
+export const voiceVerificationAttemptSchema = voiceVerificationAttemptRequestSchema.extend({
+    attemptNumber: z.number().int().positive().safe(),
+    status: z.enum(['pending', 'verified', 'rejected', 'uncertain']),
+    completedAt: voiceTimestampSchema.nullable(),
+    verifierInvocationId: voiceIdSchema.nullable(),
+    verificationId: voiceIdSchema.nullable(),
+});
+const verifierResultBase = {
+    verificationId: voiceIdSchema,
+    attemptId: voiceIdSchema,
+    subject: voiceCallSubjectSchema,
+    candidateResource: voiceResourceReferenceSchema,
+    methodKey: voiceLocalKeySchema,
+    idempotencyKey: voiceIdSchema,
+    requestDigest: voiceHashSchema,
+    verifierReviewId: voiceIdSchema,
+    verifierInvocationId: voiceIdSchema,
+    observedFunctionVersionId: voiceIdSchema,
+    completedAt: voiceTimestampSchema,
+};
+export const voiceTrustedVerifierResultSchema = z.discriminatedUnion('verdict', [
+    z.strictObject({
+        verdict: z.literal('verified'), ...verifierResultBase,
+        verificationExpiresAt: voiceTimestampSchema,
+    }),
+    z.strictObject({ verdict: z.literal('rejected'), ...verifierResultBase }),
+]);

package/dist/voice-authority-evaluation.d.ts

@@ -0,0 +1,29 @@
+import { type VoiceCallSubject, type VoicePublicationToolReview, type VoiceToolBinding, type VoiceToolOperationRequirement, type VoiceVerificationState, type VoiceResourceReference } from './voice-authority-contracts.js';
+export type VoiceAuthoritySubject = {
+    kind: 'public';
+} | {
+    kind: 'authentication';
+} | {
+    kind: 'unverified';
+} | {
+    kind: 'verified_resource';
+    resource: VoiceResourceReference;
+    verificationId: string;
+};
+type AuthorityDenial = 'resource_verification_expired' | 'resource_verification_required' | 'invalid_verification_binding' | 'publication_review_required' | 'verification_locked' | 'verification_revoked';
+export type VoiceToolAuthorityDecision = {
+    allowed: true;
+    authoritySubject: VoiceAuthoritySubject;
+} | {
+    allowed: false;
+    reason: AuthorityDenial;
+};
+export declare function evaluateVoiceToolAuthority({ requirement, subject, verification, publicationReview, currentBinding, now, }: {
+    requirement: VoiceToolOperationRequirement | undefined;
+    subject: VoiceCallSubject;
+    verification: VoiceVerificationState | null;
+    publicationReview: VoicePublicationToolReview | null;
+    currentBinding: VoiceToolBinding | null;
+    now: string;
+}): VoiceToolAuthorityDecision;
+export {};

package/dist/voice-authority-evaluation.js

@@ -0,0 +1,80 @@
+import { voiceTimestampSchema } from './voice-common.js';
+import { isVoicePublicationToolReviewCurrent, resolveVoiceToolOperationRequirement, voiceCallSubjectSchema, voicePublicationToolReviewSchema, voiceVerificationStateSchema, } from './voice-authority-contracts.js';
+function sameSubject({ left, right }) {
+    return left.tenantId === right.tenantId &&
+        left.environmentId === right.environmentId &&
+        left.agentId === right.agentId &&
+        left.sessionId === right.sessionId &&
+        left.releaseId === right.releaseId;
+}
+function reviewMatchesOperation({ review, binding, requirement, subject }) {
+    return review.releaseId === subject.releaseId &&
+        review.scope.tenantId === subject.tenantId &&
+        review.scope.environmentId === subject.environmentId &&
+        review.scope.agentId === subject.agentId &&
+        isVoicePublicationToolReviewCurrent({
+            review, currentBinding: binding, currentRequirement: requirement,
+        });
+}
+function inactiveVerificationDecision({ state, now }) {
+    if (state.status === 'revoked') {
+        return { allowed: false, reason: 'verification_revoked' };
+    }
+    if (state.status === 'locked') {
+        return { allowed: false, reason: 'verification_locked' };
+    }
+    const expired = state.status === 'expired' ||
+        Date.parse(now) >= Date.parse(state.authorityExpiresAt);
+    return expired ? { allowed: false, reason: 'resource_verification_expired' } : null;
+}
+export function evaluateVoiceToolAuthority({ requirement, subject, verification, publicationReview, currentBinding, now, }) {
+    if (requirement === undefined)
+        return { allowed: false, reason: 'publication_review_required' };
+    const policy = resolveVoiceToolOperationRequirement({ requirement });
+    const call = voiceCallSubjectSchema.parse(subject);
+    const parsedNow = voiceTimestampSchema.parse(now);
+    if (publicationReview === null || currentBinding === null) {
+        return { allowed: false, reason: 'publication_review_required' };
+    }
+    const review = voicePublicationToolReviewSchema.parse(publicationReview);
+    if (!reviewMatchesOperation({ review, binding: currentBinding, requirement: policy,
+        subject: call })) {
+        return { allowed: false, reason: 'publication_review_required' };
+    }
+    if (policy.authority === 'public') {
+        const kind = policy.effect === 'unverified_write'
+            ? 'unverified'
+            : 'public';
+        return { allowed: true, authoritySubject: { kind } };
+    }
+    if (verification === null) {
+        return policy.authority === 'authentication'
+            ? { allowed: true, authoritySubject: { kind: 'authentication' } }
+            : { allowed: false, reason: 'resource_verification_required' };
+    }
+    const state = voiceVerificationStateSchema.parse(verification);
+    if (!sameSubject({ left: call, right: state.subject })) {
+        return { allowed: false, reason: 'invalid_verification_binding' };
+    }
+    const inactive = inactiveVerificationDecision({ state, now: parsedNow });
+    if (inactive !== null)
+        return inactive;
+    if (policy.authority === 'authentication') {
+        return { allowed: true, authoritySubject: { kind: 'authentication' } };
+    }
+    if (state.status !== 'verified' || state.verifiedResource === null ||
+        state.verifiedResource.kind !== policy.resourceKind ||
+        state.verificationId === null || state.verificationExpiresAt === null) {
+        return { allowed: false, reason: 'resource_verification_required' };
+    }
+    if (Date.parse(parsedNow) >= Date.parse(state.verificationExpiresAt)) {
+        return { allowed: false, reason: 'resource_verification_expired' };
+    }
+    return {
+        allowed: true,
+        authoritySubject: {
+            kind: 'verified_resource', resource: state.verifiedResource,
+            verificationId: state.verificationId,
+        },
+    };
+}