@sequenceholdings/agent-spec 0.1.1 → 0.1.3

package/dist/voice-policy-duration.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { type VoiceProviderDurationSettingMode } from './voice-policy-limits.js';
+export declare const VOICE_SETUP_ALLOWANCE_SECONDS = 120;
+export declare const voiceCallDurationSnapshotSchema: z.ZodObject<{
+    policyRevision: z.ZodNumber;
+    admittedAt: z.ZodISODateTime;
+    setupAllowanceSeconds: z.ZodLiteral<120>;
+    maxCallDurationSeconds: z.ZodNumber;
+    providerReleaseDurationCeilingSeconds: z.ZodNumber;
+    absoluteExpiresAt: z.ZodISODateTime;
+    connectedAt: z.ZodNullable<z.ZodISODateTime>;
+    connectedDeadlineAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type VoiceCallDurationSnapshot = z.infer<typeof voiceCallDurationSnapshotSchema>;
+export declare function createVoiceDurationSnapshot({ policyRevision, admittedAt, maxCallDurationSeconds, providerReleaseDurationCeilingSeconds, }: {
+    policyRevision: number;
+    admittedAt: string;
+    maxCallDurationSeconds: number;
+    providerReleaseDurationCeilingSeconds: number;
+}): VoiceCallDurationSnapshot;
+export declare function connectVoiceDurationSnapshot({ snapshot, connectedAt }: {
+    snapshot: VoiceCallDurationSnapshot;
+    connectedAt: string;
+}): VoiceCallDurationSnapshot;
+export declare const voiceDurationApplicationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"EFFECTIVE">;
+    configuredMaxCallDurationSeconds: z.ZodNumber;
+    effectiveMaxCallDurationSeconds: z.ZodNumber;
+    activeReleaseDurationCeilingSeconds: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"REPUBLICATION_REQUIRED">;
+    reason: z.ZodEnum<{
+        ACTIVE_RELEASE_DURATION_CEILING: "ACTIVE_RELEASE_DURATION_CEILING";
+        PROVIDER_SETTING_REQUIRES_REPUBLICATION: "PROVIDER_SETTING_REQUIRES_REPUBLICATION";
+    }>;
+    configuredMaxCallDurationSeconds: z.ZodNumber;
+    effectiveMaxCallDurationSeconds: z.ZodNumber;
+    activeReleaseDurationCeilingSeconds: z.ZodNumber;
+}, z.core.$strict>], "status">;
+export type VoiceDurationApplication = z.infer<typeof voiceDurationApplicationSchema>;
+export declare function assessVoiceDurationApplication({ configuredMaxCallDurationSeconds, previousEffectiveMaxCallDurationSeconds, activeReleaseDurationCeilingSeconds, durationSettingMode, }: {
+    configuredMaxCallDurationSeconds: number;
+    previousEffectiveMaxCallDurationSeconds: number;
+    activeReleaseDurationCeilingSeconds: number;
+    durationSettingMode: VoiceProviderDurationSettingMode;
+}): VoiceDurationApplication;

package/dist/voice-policy-duration.js

@@ -0,0 +1,166 @@
+import { z } from 'zod';
+import { voiceRevisionSchema, voiceTimestampSchema } from './voice-common.js';
+import { voiceProviderDurationSettingModeSchema, } from './voice-policy-limits.js';
+const durationSchema = z.number().int().positive().safe();
+export const VOICE_SETUP_ALLOWANCE_SECONDS = 120;
+export const voiceCallDurationSnapshotSchema = z.strictObject({
+    policyRevision: voiceRevisionSchema,
+    admittedAt: voiceTimestampSchema,
+    setupAllowanceSeconds: z.literal(VOICE_SETUP_ALLOWANCE_SECONDS),
+    maxCallDurationSeconds: durationSchema,
+    providerReleaseDurationCeilingSeconds: durationSchema,
+    absoluteExpiresAt: voiceTimestampSchema,
+    connectedAt: voiceTimestampSchema.nullable(),
+    connectedDeadlineAt: voiceTimestampSchema.nullable(),
+}).superRefine(validateDurationSnapshot);
+export function createVoiceDurationSnapshot({ policyRevision, admittedAt, maxCallDurationSeconds, providerReleaseDurationCeilingSeconds, }) {
+    const revision = voiceRevisionSchema.parse(policyRevision);
+    const admitted = voiceTimestampSchema.parse(admittedAt);
+    const duration = durationSchema.parse(maxCallDurationSeconds);
+    const providerCeiling = durationSchema.parse(providerReleaseDurationCeilingSeconds);
+    if (duration > providerCeiling) {
+        throw new Error('admitted call duration exceeds the verified provider release ceiling');
+    }
+    return voiceCallDurationSnapshotSchema.parse({
+        policyRevision: revision,
+        admittedAt: admitted,
+        setupAllowanceSeconds: VOICE_SETUP_ALLOWANCE_SECONDS,
+        maxCallDurationSeconds: duration,
+        providerReleaseDurationCeilingSeconds: providerCeiling,
+        absoluteExpiresAt: addSeconds({
+            timestamp: admitted, seconds: VOICE_SETUP_ALLOWANCE_SECONDS + duration,
+        }),
+        connectedAt: null,
+        connectedDeadlineAt: null,
+    });
+}
+export function connectVoiceDurationSnapshot({ snapshot, connectedAt }) {
+    const current = voiceCallDurationSnapshotSchema.parse(snapshot);
+    const connected = voiceTimestampSchema.parse(connectedAt);
+    if (current.connectedAt !== null) {
+        if (toMillis(current.connectedAt) !== toMillis(connected)) {
+            throw new Error('connected timestamp is immutable once recorded');
+        }
+        return current;
+    }
+    const admittedMillis = toMillis(current.admittedAt);
+    const connectedMillis = toMillis(connected);
+    if (connectedMillis < admittedMillis)
+        throw new Error('connection cannot occur before admission');
+    const setupDeadline = admittedMillis + current.setupAllowanceSeconds * 1_000;
+    if (connectedMillis > setupDeadline) {
+        throw new Error('connection occurred after the bounded setup allowance');
+    }
+    const absoluteExpiry = toMillis(current.absoluteExpiresAt);
+    if (connectedMillis >= absoluteExpiry) {
+        throw new Error('connection occurred at or after the absolute expiry');
+    }
+    const durationDeadline = addSeconds({
+        timestamp: connected, seconds: current.maxCallDurationSeconds,
+    });
+    const deadline = toMillis(durationDeadline) <= absoluteExpiry
+        ? durationDeadline
+        : current.absoluteExpiresAt;
+    return voiceCallDurationSnapshotSchema.parse({
+        ...current, connectedAt: connected, connectedDeadlineAt: deadline,
+    });
+}
+export const voiceDurationApplicationSchema = z.discriminatedUnion('status', [
+    z.strictObject({
+        status: z.literal('EFFECTIVE'),
+        configuredMaxCallDurationSeconds: durationSchema,
+        effectiveMaxCallDurationSeconds: durationSchema,
+        activeReleaseDurationCeilingSeconds: durationSchema,
+    }),
+    z.strictObject({
+        status: z.literal('REPUBLICATION_REQUIRED'),
+        reason: z.enum([
+            'ACTIVE_RELEASE_DURATION_CEILING',
+            'PROVIDER_SETTING_REQUIRES_REPUBLICATION',
+        ]),
+        configuredMaxCallDurationSeconds: durationSchema,
+        effectiveMaxCallDurationSeconds: durationSchema,
+        activeReleaseDurationCeilingSeconds: durationSchema,
+    }),
+]).superRefine((application, context) => {
+    if (application.effectiveMaxCallDurationSeconds > application.activeReleaseDurationCeilingSeconds) {
+        context.addIssue({
+            code: 'custom',
+            path: ['effectiveMaxCallDurationSeconds'],
+            message: 'effective duration exceeds the active release ceiling',
+        });
+    }
+});
+export function assessVoiceDurationApplication({ configuredMaxCallDurationSeconds, previousEffectiveMaxCallDurationSeconds, activeReleaseDurationCeilingSeconds, durationSettingMode, }) {
+    const configured = durationSchema.parse(configuredMaxCallDurationSeconds);
+    const previous = durationSchema.parse(previousEffectiveMaxCallDurationSeconds);
+    const ceiling = durationSchema.parse(activeReleaseDurationCeilingSeconds);
+    const settingMode = voiceProviderDurationSettingModeSchema.parse(durationSettingMode);
+    if (previous > ceiling) {
+        throw new Error('previous effective duration exceeds the active release ceiling');
+    }
+    if (configured > ceiling) {
+        return makePendingDuration({
+            configured, previous, ceiling, reason: 'ACTIVE_RELEASE_DURATION_CEILING',
+        });
+    }
+    if (configured !== previous && settingMode === 'REQUIRES_REPUBLICATION') {
+        return makePendingDuration({
+            configured, previous, ceiling,
+            reason: 'PROVIDER_SETTING_REQUIRES_REPUBLICATION',
+        });
+    }
+    return voiceDurationApplicationSchema.parse({
+        status: 'EFFECTIVE',
+        configuredMaxCallDurationSeconds: configured,
+        effectiveMaxCallDurationSeconds: configured,
+        activeReleaseDurationCeilingSeconds: ceiling,
+    });
+}
+function validateDurationSnapshot(snapshot, context) {
+    const admitted = toMillis(snapshot.admittedAt);
+    const absolute = toMillis(snapshot.absoluteExpiresAt);
+    const maximumAbsolute = admitted +
+        (snapshot.setupAllowanceSeconds + snapshot.maxCallDurationSeconds) * 1_000;
+    if (snapshot.maxCallDurationSeconds > snapshot.providerReleaseDurationCeilingSeconds) {
+        addIssue({ context, path: 'maxCallDurationSeconds', message: 'duration exceeds the verified provider release ceiling' });
+    }
+    if (absolute <= admitted || absolute > maximumAbsolute) {
+        addIssue({ context, path: 'absoluteExpiresAt', message: 'absolute expiry exceeds the admission duration bound' });
+    }
+    const hasConnectedAt = snapshot.connectedAt !== null;
+    if (hasConnectedAt !== (snapshot.connectedDeadlineAt !== null)) {
+        addIssue({ context, path: 'connectedDeadlineAt', message: 'connected timestamp and deadline must be recorded together' });
+        return;
+    }
+    if (snapshot.connectedAt === null || snapshot.connectedDeadlineAt === null)
+        return;
+    const connected = toMillis(snapshot.connectedAt);
+    const deadline = toMillis(snapshot.connectedDeadlineAt);
+    const setupDeadline = admitted + snapshot.setupAllowanceSeconds * 1_000;
+    const maximumDeadline = Math.min(connected + snapshot.maxCallDurationSeconds * 1_000, absolute);
+    if (connected < admitted || connected > setupDeadline) {
+        addIssue({ context, path: 'connectedAt', message: 'connection must occur during the bounded setup window' });
+    }
+    if (deadline <= connected || deadline > maximumDeadline) {
+        addIssue({ context, path: 'connectedDeadlineAt', message: 'connected deadline exceeds the call authority bound' });
+    }
+}
+function makePendingDuration({ configured, previous, ceiling, reason }) {
+    return voiceDurationApplicationSchema.parse({
+        status: 'REPUBLICATION_REQUIRED',
+        reason,
+        configuredMaxCallDurationSeconds: configured,
+        effectiveMaxCallDurationSeconds: previous,
+        activeReleaseDurationCeilingSeconds: ceiling,
+    });
+}
+function addIssue({ context, path, message }) {
+    context.addIssue({ code: 'custom', path: [path], message });
+}
+function toMillis(timestamp) {
+    return new Date(voiceTimestampSchema.parse(timestamp)).getTime();
+}
+function addSeconds({ timestamp, seconds }) {
+    return new Date(toMillis(timestamp) + durationSchema.parse(seconds) * 1_000).toISOString();
+}

package/dist/voice-policy-limits.d.ts

@@ -0,0 +1,174 @@
+import { z } from 'zod';
+import { type VoiceCallDirection } from './voice-lifecycle-states.js';
+export declare const voiceCallLimitsSchema: z.ZodObject<{
+    maxConcurrentCalls: z.ZodNumber;
+    maxDailyCallAttempts: z.ZodNumber;
+    maxDailyOutboundAttemptsPerPerson: z.ZodNumber;
+    maxDailyInboundAttemptsPerNumber: z.ZodDefault<z.ZodNumber>;
+    maxConcurrentInboundCallsPerNumber: z.ZodDefault<z.ZodNumber>;
+    maxCallDurationSeconds: z.ZodNumber;
+}, z.core.$strict>;
+export type VoiceCallLimits = z.infer<typeof voiceCallLimitsSchema>;
+export declare const VOICE_DEFAULT_CALL_LIMITS: VoiceCallLimits;
+export declare const voiceEngineeringLimitsSchema: z.ZodObject<{
+    maxToolAttemptsPerCall: z.ZodNumber;
+    toolInvocationTimeoutSeconds: z.ZodNumber;
+    maxPublicationsPerUtcDay: z.ZodNumber;
+    maxOwnedProviderAgents: z.ZodNumber;
+}, z.core.$strict>;
+export type VoiceEngineeringLimits = z.infer<typeof voiceEngineeringLimitsSchema>;
+export declare const VOICE_DEFAULT_ENGINEERING_LIMITS: VoiceEngineeringLimits;
+export declare const voiceProviderDurationSettingModeSchema: z.ZodEnum<{
+    PER_SESSION: "PER_SESSION";
+    REQUIRES_REPUBLICATION: "REQUIRES_REPUBLICATION";
+}>;
+export type VoiceProviderDurationSettingMode = z.infer<typeof voiceProviderDurationSettingModeSchema>;
+export declare const voiceProviderCapabilitiesSchema: z.ZodObject<{
+    verifiedMaxConcurrentCalls: z.ZodNumber;
+    verifiedMaxCallDurationSeconds: z.ZodNumber;
+    durationSettingMode: z.ZodEnum<{
+        PER_SESSION: "PER_SESSION";
+        REQUIRES_REPUBLICATION: "REQUIRES_REPUBLICATION";
+    }>;
+    verifiedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type VoiceProviderCapabilities = z.infer<typeof voiceProviderCapabilitiesSchema>;
+export declare const voiceOperatorPolicySchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    environmentId: z.ZodString;
+    revision: z.ZodNumber;
+    revocationGeneration: z.ZodNumber;
+    admissionEnabled: z.ZodBoolean;
+    limits: z.ZodObject<{
+        maxConcurrentCalls: z.ZodNumber;
+        maxDailyCallAttempts: z.ZodNumber;
+        maxDailyOutboundAttemptsPerPerson: z.ZodNumber;
+        maxDailyInboundAttemptsPerNumber: z.ZodDefault<z.ZodNumber>;
+        maxConcurrentInboundCallsPerNumber: z.ZodDefault<z.ZodNumber>;
+        maxCallDurationSeconds: z.ZodNumber;
+    }, z.core.$strict>;
+    engineeringLimits: z.ZodObject<{
+        maxToolAttemptsPerCall: z.ZodNumber;
+        toolInvocationTimeoutSeconds: z.ZodNumber;
+        maxPublicationsPerUtcDay: z.ZodNumber;
+        maxOwnedProviderAgents: z.ZodNumber;
+    }, z.core.$strict>;
+    updatedAt: z.ZodISODateTime;
+    updatedByPrincipalId: z.ZodString;
+}, z.core.$strict>;
+export type VoiceOperatorPolicy = z.infer<typeof voiceOperatorPolicySchema>;
+export declare const voiceUtcDaySchema: z.ZodISODate;
+export declare const voicePolicyUsageSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    environmentId: z.ZodString;
+    utcDay: z.ZodISODate;
+    activeReservations: z.ZodNumber;
+    admittedAttempts: z.ZodNumber;
+    outboundAttemptsByPrincipalId: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    measuredAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type VoicePolicyUsage = z.infer<typeof voicePolicyUsageSchema>;
+export declare function rollVoicePolicyUsageToUtcDay({ usage, measuredAt }: {
+    usage: VoicePolicyUsage;
+    measuredAt: string;
+}): {
+    usage: VoicePolicyUsage;
+    changed: boolean;
+};
+export declare const voicePolicyLimitUpdateSchema: z.ZodObject<{
+    expectedRevision: z.ZodNumber;
+    limits: z.ZodObject<{
+        maxConcurrentCalls: z.ZodNumber;
+        maxDailyCallAttempts: z.ZodNumber;
+        maxDailyOutboundAttemptsPerPerson: z.ZodNumber;
+        maxDailyInboundAttemptsPerNumber: z.ZodDefault<z.ZodNumber>;
+        maxConcurrentInboundCallsPerNumber: z.ZodDefault<z.ZodNumber>;
+        maxCallDurationSeconds: z.ZodNumber;
+    }, z.core.$strict>;
+    actorPrincipalId: z.ZodString;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type VoicePolicyLimitUpdate = z.infer<typeof voicePolicyLimitUpdateSchema>;
+export declare const voicePolicyLimitAuditSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    environmentId: z.ZodString;
+    previousRevision: z.ZodNumber;
+    nextRevision: z.ZodNumber;
+    actorPrincipalId: z.ZodString;
+    updatedAt: z.ZodISODateTime;
+    previousLimits: z.ZodObject<{
+        maxConcurrentCalls: z.ZodNumber;
+        maxDailyCallAttempts: z.ZodNumber;
+        maxDailyOutboundAttemptsPerPerson: z.ZodNumber;
+        maxDailyInboundAttemptsPerNumber: z.ZodDefault<z.ZodNumber>;
+        maxConcurrentInboundCallsPerNumber: z.ZodDefault<z.ZodNumber>;
+        maxCallDurationSeconds: z.ZodNumber;
+    }, z.core.$strict>;
+    nextLimits: z.ZodObject<{
+        maxConcurrentCalls: z.ZodNumber;
+        maxDailyCallAttempts: z.ZodNumber;
+        maxDailyOutboundAttemptsPerPerson: z.ZodNumber;
+        maxDailyInboundAttemptsPerNumber: z.ZodDefault<z.ZodNumber>;
+        maxConcurrentInboundCallsPerNumber: z.ZodDefault<z.ZodNumber>;
+        maxCallDurationSeconds: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type VoicePolicyLimitAudit = z.infer<typeof voicePolicyLimitAuditSchema>;
+export declare const voiceProviderLimitViolationSchema: z.ZodObject<{
+    field: z.ZodEnum<{
+        maxConcurrentCalls: "maxConcurrentCalls";
+        maxCallDurationSeconds: "maxCallDurationSeconds";
+    }>;
+    requested: z.ZodNumber;
+    verifiedMaximum: z.ZodNumber;
+}, z.core.$strict>;
+export type VoiceProviderLimitViolation = z.infer<typeof voiceProviderLimitViolationSchema>;
+export type VoiceProviderLimitValidation = {
+    ok: true;
+} | {
+    ok: false;
+    violations: VoiceProviderLimitViolation[];
+};
+export declare function validateVoiceCallLimitsAgainstProvider({ limits, providerCapabilities }: {
+    limits: VoiceCallLimits;
+    providerCapabilities: VoiceProviderCapabilities;
+}): VoiceProviderLimitValidation;
+export type VoicePolicyLimitUpdateResult = {
+    ok: true;
+    policy: VoiceOperatorPolicy;
+    usage: VoicePolicyUsage;
+    audit: VoicePolicyLimitAudit;
+} | {
+    ok: false;
+    reason: 'STALE_REVISION';
+    actualRevision: number;
+} | {
+    ok: false;
+    reason: 'PROVIDER_CAPABILITY_EXCEEDED';
+    violations: VoiceProviderLimitViolation[];
+};
+export declare function applyVoicePolicyLimitUpdate({ currentPolicy, currentUsage, update, providerCapabilities, }: {
+    currentPolicy: VoiceOperatorPolicy;
+    currentUsage: VoicePolicyUsage;
+    update: VoicePolicyLimitUpdate;
+    providerCapabilities: VoiceProviderCapabilities;
+}): VoicePolicyLimitUpdateResult;
+export declare const voiceAdmissionLimitReasonSchema: z.ZodEnum<{
+    ADMISSION_DISABLED: "ADMISSION_DISABLED";
+    CONCURRENT_LIMIT_REACHED: "CONCURRENT_LIMIT_REACHED";
+    ENVIRONMENT_DAILY_LIMIT_REACHED: "ENVIRONMENT_DAILY_LIMIT_REACHED";
+    PERSON_DAILY_LIMIT_REACHED: "PERSON_DAILY_LIMIT_REACHED";
+}>;
+export type VoiceAdmissionLimitReason = z.infer<typeof voiceAdmissionLimitReasonSchema>;
+export type VoiceCallAdmissionEvaluation = {
+    admitted: true;
+} | {
+    admitted: false;
+    reason: VoiceAdmissionLimitReason;
+};
+export declare function evaluateVoiceCallAdmission({ policy, usage, direction, initiatingStaffPrincipalId, }: {
+    policy: VoiceOperatorPolicy;
+    usage: VoicePolicyUsage;
+    direction: VoiceCallDirection;
+    initiatingStaffPrincipalId: string | null;
+}): VoiceCallAdmissionEvaluation;

package/dist/voice-policy-limits.js

@@ -0,0 +1,188 @@
+import { z } from 'zod';
+import { voiceCallDirectionSchema, } from './voice-lifecycle-states.js';
+import { voiceIdSchema, voiceRevisionSchema, voiceScopeSchema, voiceTimestampSchema, } from './voice-common.js';
+const positiveIntegerSchema = z.number().int().positive().safe();
+const counterSchema = z.number().int().nonnegative().safe();
+export const voiceCallLimitsSchema = z.strictObject({
+    maxConcurrentCalls: positiveIntegerSchema,
+    maxDailyCallAttempts: positiveIntegerSchema,
+    maxDailyOutboundAttemptsPerPerson: positiveIntegerSchema,
+    maxDailyInboundAttemptsPerNumber: positiveIntegerSchema.default(100),
+    maxConcurrentInboundCallsPerNumber: positiveIntegerSchema.default(2),
+    maxCallDurationSeconds: positiveIntegerSchema,
+});
+export const VOICE_DEFAULT_CALL_LIMITS = voiceCallLimitsSchema.parse({
+    maxConcurrentCalls: 20,
+    maxDailyCallAttempts: 200,
+    maxDailyOutboundAttemptsPerPerson: 100,
+    maxDailyInboundAttemptsPerNumber: 100,
+    maxConcurrentInboundCallsPerNumber: 2,
+    maxCallDurationSeconds: 900,
+});
+export const voiceEngineeringLimitsSchema = z.strictObject({
+    maxToolAttemptsPerCall: positiveIntegerSchema,
+    toolInvocationTimeoutSeconds: positiveIntegerSchema,
+    maxPublicationsPerUtcDay: positiveIntegerSchema,
+    maxOwnedProviderAgents: positiveIntegerSchema,
+});
+export const VOICE_DEFAULT_ENGINEERING_LIMITS = voiceEngineeringLimitsSchema.parse({
+    maxToolAttemptsPerCall: 20,
+    toolInvocationTimeoutSeconds: 10,
+    maxPublicationsPerUtcDay: 10,
+    maxOwnedProviderAgents: 20,
+});
+export const voiceProviderDurationSettingModeSchema = z.enum([
+    'PER_SESSION', 'REQUIRES_REPUBLICATION',
+]);
+export const voiceProviderCapabilitiesSchema = z.strictObject({
+    verifiedMaxConcurrentCalls: positiveIntegerSchema,
+    verifiedMaxCallDurationSeconds: positiveIntegerSchema,
+    durationSettingMode: voiceProviderDurationSettingModeSchema,
+    verifiedAt: voiceTimestampSchema,
+});
+export const voiceOperatorPolicySchema = voiceScopeSchema.extend({
+    revision: voiceRevisionSchema,
+    revocationGeneration: voiceRevisionSchema,
+    admissionEnabled: z.boolean(),
+    limits: voiceCallLimitsSchema,
+    engineeringLimits: voiceEngineeringLimitsSchema,
+    updatedAt: voiceTimestampSchema,
+    updatedByPrincipalId: voiceIdSchema,
+});
+export const voiceUtcDaySchema = z.iso.date();
+export const voicePolicyUsageSchema = voiceScopeSchema.extend({
+    utcDay: voiceUtcDaySchema,
+    activeReservations: counterSchema,
+    admittedAttempts: counterSchema,
+    outboundAttemptsByPrincipalId: z.record(voiceIdSchema, counterSchema),
+    measuredAt: voiceTimestampSchema,
+});
+export function rollVoicePolicyUsageToUtcDay({ usage, measuredAt }) {
+    const current = voicePolicyUsageSchema.parse(usage);
+    const observedAt = voiceTimestampSchema.parse(measuredAt);
+    const nextDay = voiceUtcDaySchema.parse(new Date(observedAt).toISOString().substring(0, 10));
+    if (nextDay < current.utcDay)
+        throw new Error('UTC usage buckets cannot roll backward');
+    if (nextDay === current.utcDay)
+        return { usage: current, changed: false };
+    return {
+        changed: true,
+        usage: voicePolicyUsageSchema.parse({
+            ...current,
+            utcDay: nextDay,
+            admittedAttempts: 0,
+            outboundAttemptsByPrincipalId: {},
+            measuredAt: observedAt,
+        }),
+    };
+}
+export const voicePolicyLimitUpdateSchema = z.strictObject({
+    expectedRevision: voiceRevisionSchema,
+    limits: voiceCallLimitsSchema,
+    actorPrincipalId: voiceIdSchema,
+    updatedAt: voiceTimestampSchema,
+});
+export const voicePolicyLimitAuditSchema = voiceScopeSchema.extend({
+    previousRevision: voiceRevisionSchema,
+    nextRevision: voiceRevisionSchema,
+    actorPrincipalId: voiceIdSchema,
+    updatedAt: voiceTimestampSchema,
+    previousLimits: voiceCallLimitsSchema,
+    nextLimits: voiceCallLimitsSchema,
+});
+export const voiceProviderLimitViolationSchema = z.strictObject({
+    field: z.enum(['maxConcurrentCalls', 'maxCallDurationSeconds']),
+    requested: positiveIntegerSchema,
+    verifiedMaximum: positiveIntegerSchema,
+});
+export function validateVoiceCallLimitsAgainstProvider({ limits, providerCapabilities }) {
+    const requested = voiceCallLimitsSchema.parse(limits);
+    const verified = voiceProviderCapabilitiesSchema.parse(providerCapabilities);
+    const violations = [];
+    if (requested.maxConcurrentCalls > verified.verifiedMaxConcurrentCalls) {
+        violations.push({
+            field: 'maxConcurrentCalls',
+            requested: requested.maxConcurrentCalls,
+            verifiedMaximum: verified.verifiedMaxConcurrentCalls,
+        });
+    }
+    if (requested.maxCallDurationSeconds > verified.verifiedMaxCallDurationSeconds) {
+        violations.push({
+            field: 'maxCallDurationSeconds',
+            requested: requested.maxCallDurationSeconds,
+            verifiedMaximum: verified.verifiedMaxCallDurationSeconds,
+        });
+    }
+    return violations.length === 0 ? { ok: true } : { ok: false, violations };
+}
+export function applyVoicePolicyLimitUpdate({ currentPolicy, currentUsage, update, providerCapabilities, }) {
+    const policy = voiceOperatorPolicySchema.parse(currentPolicy);
+    const usage = voicePolicyUsageSchema.parse(currentUsage);
+    const requested = voicePolicyLimitUpdateSchema.parse(update);
+    assertSameScope({ left: policy, right: usage });
+    if (requested.expectedRevision !== policy.revision) {
+        return { ok: false, reason: 'STALE_REVISION', actualRevision: policy.revision };
+    }
+    const capability = validateVoiceCallLimitsAgainstProvider({
+        limits: requested.limits, providerCapabilities,
+    });
+    if (!capability.ok) {
+        return { ok: false, reason: 'PROVIDER_CAPABILITY_EXCEEDED', violations: capability.violations };
+    }
+    const nextRevision = policy.revision + 1;
+    const nextPolicy = voiceOperatorPolicySchema.parse({
+        ...policy,
+        revision: nextRevision,
+        limits: requested.limits,
+        updatedAt: requested.updatedAt,
+        updatedByPrincipalId: requested.actorPrincipalId,
+    });
+    const audit = voicePolicyLimitAuditSchema.parse({
+        tenantId: policy.tenantId,
+        environmentId: policy.environmentId,
+        previousRevision: policy.revision,
+        nextRevision,
+        actorPrincipalId: requested.actorPrincipalId,
+        updatedAt: requested.updatedAt,
+        previousLimits: policy.limits,
+        nextLimits: nextPolicy.limits,
+    });
+    return { ok: true, policy: nextPolicy, usage, audit };
+}
+export const voiceAdmissionLimitReasonSchema = z.enum([
+    'ADMISSION_DISABLED', 'CONCURRENT_LIMIT_REACHED',
+    'ENVIRONMENT_DAILY_LIMIT_REACHED', 'PERSON_DAILY_LIMIT_REACHED',
+]);
+export function evaluateVoiceCallAdmission({ policy, usage, direction, initiatingStaffPrincipalId, }) {
+    const currentPolicy = voiceOperatorPolicySchema.parse(policy);
+    const currentUsage = voicePolicyUsageSchema.parse(usage);
+    const callDirection = voiceCallDirectionSchema.parse(direction);
+    assertSameScope({ left: currentPolicy, right: currentUsage });
+    if (callDirection === 'OUTBOUND' && initiatingStaffPrincipalId === null) {
+        throw new Error('outbound calls require an initiating staff principal');
+    }
+    if (callDirection === 'INBOUND' && initiatingStaffPrincipalId !== null) {
+        throw new Error('inbound calls cannot have an initiating staff principal');
+    }
+    if (!currentPolicy.admissionEnabled)
+        return { admitted: false, reason: 'ADMISSION_DISABLED' };
+    if (currentUsage.activeReservations >= currentPolicy.limits.maxConcurrentCalls) {
+        return { admitted: false, reason: 'CONCURRENT_LIMIT_REACHED' };
+    }
+    if (currentUsage.admittedAttempts >= currentPolicy.limits.maxDailyCallAttempts) {
+        return { admitted: false, reason: 'ENVIRONMENT_DAILY_LIMIT_REACHED' };
+    }
+    if (callDirection === 'OUTBOUND') {
+        const principalId = voiceIdSchema.parse(initiatingStaffPrincipalId);
+        const attempts = currentUsage.outboundAttemptsByPrincipalId[principalId] ?? 0;
+        if (attempts >= currentPolicy.limits.maxDailyOutboundAttemptsPerPerson) {
+            return { admitted: false, reason: 'PERSON_DAILY_LIMIT_REACHED' };
+        }
+    }
+    return { admitted: true };
+}
+function assertSameScope({ left, right }) {
+    if (left.tenantId !== right.tenantId || left.environmentId !== right.environmentId) {
+        throw new Error('Voice policy and usage must have the same scope');
+    }
+}

package/dist/voice-policy.d.ts

@@ -0,0 +1,2 @@
+export * from './voice-policy-duration.js';
+export * from './voice-policy-limits.js';

package/dist/voice-policy.js

@@ -0,0 +1,2 @@
+export * from './voice-policy-duration.js';
+export * from './voice-policy-limits.js';

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

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+export declare const MAX_VOICE_PROVIDER_DOCUMENT_BYTES: number;
+export declare const MAX_VOICE_PROVIDER_DOCUMENT_DEPTH = 12;
+export declare const MAX_VOICE_PROVIDER_DOCUMENT_NODES = 2000;
+export declare const voiceProviderEvidenceReferenceSchema: z.ZodString;
+export declare const voiceSanitizedEvidenceTextSchema: z.ZodString;
+export declare const voiceSanitizedProviderDocumentSchema: z.ZodJSONSchema;
+export declare function hashVoiceProviderEvidenceValue({ value }: {
+    value: unknown;
+}): string;
+export declare const voiceProviderBranchVersionSchema: 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>;
+export type VoiceProviderBranchVersion = z.infer<typeof voiceProviderBranchVersionSchema>;
+export declare const voiceProviderProcedureMappingSchema: 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>;
+export type VoiceProviderProcedureMapping = z.infer<typeof voiceProviderProcedureMappingSchema>;
+export declare function isVoiceCanonicalList({ values }: {
+    values: readonly string[];
+}): boolean;
+export declare const voiceCanonicalToolAliasesSchema: z.ZodArray<z.ZodString>;
+export declare const voiceCanonicalProcedureMappingsSchema: 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>>;
+export declare const voiceGeneratedWorkflowEvidenceSchema: 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>;
+export type VoiceGeneratedWorkflowEvidence = z.infer<typeof voiceGeneratedWorkflowEvidenceSchema>;