@sequenceholdings/agent-spec 0.1.1 → 0.1.3

package/dist/voice-release.js

@@ -0,0 +1,110 @@
+import { z } from 'zod';
+import { hashAgentBundle, voiceAgentDefinitionSchema } from './agent-definition.js';
+import { voiceHashSchema, voiceIdSchema } from './voice-common.js';
+import { voicePublicationToolReviewSchema } from './voice-authority.js';
+import { voiceReleaseLifecycleSchema, voiceRuntimeBindingSchema } from './voice-lifecycle.js';
+import { evaluateVoiceProviderReleaseReadiness, voiceProviderReleaseEvidenceSchema } from './voice-provider.js';
+export const voiceDefinitionSnapshotSchema = z.strictObject({
+    agentVersionId: voiceIdSchema,
+    definition: voiceAgentDefinitionSchema,
+    authoredDefinitionHash: voiceHashSchema,
+}).refine((snapshot) => snapshot.authoredDefinitionHash === hashAgentBundle({ definitions: [snapshot.definition] }), { path: ['authoredDefinitionHash'], message: 'Snapshot hash must include the exact captured authored definition' });
+const voiceReleaseRecordBaseSchema = z.strictObject({
+    lifecycle: voiceReleaseLifecycleSchema,
+    snapshot: voiceDefinitionSnapshotSchema.nullable(),
+    runtimeBinding: voiceRuntimeBindingSchema.nullable(),
+    toolReviews: z.array(voicePublicationToolReviewSchema).max(64),
+    providerEvidence: voiceProviderReleaseEvidenceSchema.nullable(),
+});
+export const voiceReleaseRecordSchema = voiceReleaseRecordBaseSchema.superRefine((release, context) => {
+    const { lifecycle, snapshot, runtimeBinding, providerEvidence } = release;
+    const readyOrLater = ['READY', 'ACTIVE', 'RETIRED'].includes(lifecycle.state);
+    if (readyOrLater && (snapshot === null || runtimeBinding === null || providerEvidence === null)) {
+        context.addIssue({ code: 'custom', message: 'Prepared release state requires complete snapshot, runtime and provider evidence' });
+    }
+    if (readyOrLater && runtimeBinding?.accountStatus === 'DISABLED') {
+        context.addIssue({ code: 'custom', path: ['runtimeBinding', 'accountStatus'],
+            message: 'Prepared release must capture an active runtime account; current status is rechecked at execution' });
+    }
+    if (readyOrLater && providerEvidence !== null) {
+        const readiness = evaluateVoiceProviderReleaseReadiness({ release: providerEvidence });
+        if (!readiness.ready)
+            context.addIssue({ code: 'custom', path: ['providerEvidence'],
+                message: `Prepared release provider evidence is not ready: ${readiness.blockers.join(', ')}` });
+        validateAuthoredProviderReferences({ release, context });
+    }
+    if (snapshot !== null && snapshot.definition.id !== lifecycle.agentId) {
+        context.addIssue({ code: 'custom', path: ['snapshot'], message: 'Snapshot Agent identity mismatch' });
+    }
+    if (runtimeBinding !== null && (runtimeBinding.tenantId !== lifecycle.tenantId || runtimeBinding.environmentId !== lifecycle.environmentId)) {
+        context.addIssue({ code: 'custom', path: ['runtimeBinding'], message: 'Runtime binding scope mismatch' });
+    }
+    validateProviderLinks({ release, context });
+    validateReviewLinks({ release, context });
+});
+function sameReferences({ actual, expected }) {
+    const declared = new Set(expected);
+    return actual.length === declared.size && new Set(actual).size === actual.length && actual.every((key) => declared.has(key));
+}
+function validateAuthoredProviderReferences({ release, context }) {
+    const { snapshot, providerEvidence } = release;
+    if (snapshot === null || providerEvidence === null)
+        return;
+    const { voice } = snapshot.definition;
+    const declaredProcedureKeys = voice.procedures.map((procedure) => procedure.key);
+    const configuration = providerEvidence.desiredConfiguration.configuration;
+    if (!sameReferences({ actual: providerEvidence.procedureMappings.map((mapping) => mapping.localProcedureKey), expected: declaredProcedureKeys }) ||
+        !sameReferences({ actual: configuration.toolAliases, expected: voice.tools.map((tool) => tool.alias) })) {
+        context.addIssue({ code: 'custom', path: ['providerEvidence'],
+            message: 'Prepared provider references must match exactly the captured procedures and authored tools' });
+    }
+    const providerIds = new Map(providerEvidence.procedureMappings.map((mapping) => [mapping.localProcedureKey, mapping.providerProcedureId]));
+    for (const generated of providerEvidence.generatedWorkflow.normalized.procedures) {
+        const authored = voice.procedures.find((procedure) => procedure.key === generated.localProcedureKey);
+        if (authored === undefined)
+            continue;
+        const expectedProviderIds = authored.subprocedures.flatMap((key) => {
+            const id = providerIds.get(key);
+            return id === undefined ? [] : [id];
+        });
+        if (!sameReferences({ actual: generated.toolAliases, expected: authored.toolAliases }) ||
+            !sameReferences({ actual: generated.referencedProviderProcedureIds, expected: expectedProviderIds })) {
+            context.addIssue({ code: 'custom', path: ['providerEvidence', 'generatedWorkflow'],
+                message: `Generated procedure ${authored.key} dependencies must match its captured declaration` });
+        }
+    }
+}
+function validateProviderLinks({ release, context }) {
+    const { lifecycle, snapshot, providerEvidence } = release;
+    if (providerEvidence !== null && (providerEvidence.releaseId !== lifecycle.releaseId ||
+        providerEvidence.publicationOperationId !== lifecycle.publicationOperationId ||
+        providerEvidence.scope.agentId !== lifecycle.agentId || providerEvidence.scope.tenantId !== lifecycle.tenantId ||
+        providerEvidence.scope.environmentId !== lifecycle.environmentId ||
+        providerEvidence.agentVersionId !== snapshot?.agentVersionId ||
+        providerEvidence.inputEvidence.authoredDefinitionHash !== snapshot?.authoredDefinitionHash)) {
+        context.addIssue({ code: 'custom', path: ['providerEvidence'], message: 'Provider evidence must bind this release, scope and exact Agent version' });
+    }
+}
+function validateReviewLinks({ release, context }) {
+    const { lifecycle, snapshot, runtimeBinding, toolReviews } = release;
+    const readyOrLater = ['READY', 'ACTIVE', 'RETIRED'].includes(lifecycle.state);
+    for (const [index, review] of toolReviews.entries()) {
+        if (review.releaseId !== lifecycle.releaseId || review.scope.agentId !== lifecycle.agentId ||
+            review.scope.tenantId !== lifecycle.tenantId || review.scope.environmentId !== lifecycle.environmentId ||
+            review.binding.runtimeBinding.runtimeAccountId !== runtimeBinding?.runtimeAccountId) {
+            context.addIssue({ code: 'custom', path: ['toolReviews', index], message: 'Tool review release or runtime scope mismatch' });
+        }
+        const authored = snapshot?.definition.voice.tools.find((tool) => tool.alias === review.binding.toolAlias);
+        if (authored !== undefined && authored.managedFunction.operation !== review.binding.operation) {
+            context.addIssue({ code: 'custom', path: ['toolReviews', index, 'binding', 'operation'],
+                message: 'Reviewed operation must match the authored operation for this alias' });
+        }
+    }
+    const reviewedAliases = new Set(toolReviews.map((review) => review.binding.toolAlias));
+    if (reviewedAliases.size !== toolReviews.length)
+        context.addIssue({ code: 'custom', path: ['toolReviews'], message: 'Duplicate tool review alias' });
+    if (readyOrLater && snapshot !== null && (snapshot.definition.voice.tools.length !== reviewedAliases.size ||
+        snapshot.definition.voice.tools.some((tool) => !reviewedAliases.has(tool.alias)))) {
+        context.addIssue({ code: 'custom', path: ['toolReviews'], message: 'Prepared release requires reviews for exactly the authored tools' });
+    }
+}

package/dist/voice-runs-audio.d.ts

@@ -0,0 +1,157 @@
+import { z } from 'zod';
+export declare const voiceAudioCapabilitySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"LIVE_PROOF_PENDING">;
+    evidenceRef: z.ZodNull;
+    sanitizedReason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"SUPPORTED">;
+    verifiedAt: z.ZodISODateTime;
+    evidenceRef: z.ZodString;
+    byteRangeSupport: z.ZodEnum<{
+        LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+        VERIFIED_SUPPORTED: "VERIFIED_SUPPORTED";
+        VERIFIED_UNSUPPORTED: "VERIFIED_UNSUPPORTED";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"DEFERRED">;
+    decidedAt: z.ZodISODateTime;
+    evidenceRef: z.ZodString;
+    sanitizedReason: z.ZodString;
+}, z.core.$strict>], "status">;
+export type VoiceAudioCapability = z.infer<typeof voiceAudioCapabilitySchema>;
+export declare const voiceAudioReadRequestSchema: z.ZodObject<{
+    scope: z.ZodObject<{
+        tenantId: z.ZodString;
+        environmentId: z.ZodString;
+        agentId: z.ZodString;
+    }, z.core.$strict>;
+    runId: z.ZodString;
+    expectedSessionId: z.ZodString;
+    byteRange: z.ZodNullable<z.ZodObject<{
+        startByte: z.ZodNumber;
+        endByte: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type VoiceAudioReadRequest = z.infer<typeof voiceAudioReadRequestSchema>;
+export declare const voiceAudioReadResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"AVAILABLE">;
+    runId: z.ZodString;
+    sessionId: z.ZodString;
+    capability: z.ZodObject<{
+        status: z.ZodLiteral<"SUPPORTED">;
+        verifiedAt: z.ZodISODateTime;
+        evidenceRef: z.ZodString;
+        byteRangeSupport: z.ZodEnum<{
+            LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+            VERIFIED_SUPPORTED: "VERIFIED_SUPPORTED";
+            VERIFIED_UNSUPPORTED: "VERIFIED_UNSUPPORTED";
+        }>;
+    }, z.core.$strict>;
+    delivery: z.ZodLiteral<"ATLAS_AUTHORIZED_STREAM">;
+    contentType: z.ZodEnum<{
+        "audio/mpeg": "audio/mpeg";
+        "audio/wav": "audio/wav";
+        "audio/ogg": "audio/ogg";
+        "audio/webm": "audio/webm";
+    }>;
+    contentLengthBytes: z.ZodNumber;
+    deliveryPolicy: z.ZodObject<{
+        cacheControl: z.ZodLiteral<"private, no-store">;
+        maxBytes: z.ZodNumber;
+        timeoutMilliseconds: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"PENDING">;
+    runId: z.ZodString;
+    sessionId: z.ZodString;
+    capability: z.ZodObject<{
+        status: z.ZodLiteral<"SUPPORTED">;
+        verifiedAt: z.ZodISODateTime;
+        evidenceRef: z.ZodString;
+        byteRangeSupport: z.ZodEnum<{
+            LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+            VERIFIED_SUPPORTED: "VERIFIED_SUPPORTED";
+            VERIFIED_UNSUPPORTED: "VERIFIED_UNSUPPORTED";
+        }>;
+    }, z.core.$strict>;
+    retryAfterSeconds: z.ZodNumber;
+    sanitizedDetail: z.ZodString;
+    deliveryPolicy: z.ZodObject<{
+        cacheControl: z.ZodLiteral<"private, no-store">;
+        maxBytes: z.ZodNumber;
+        timeoutMilliseconds: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"DISABLED">;
+    runId: z.ZodString;
+    sessionId: z.ZodString;
+    capability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"LIVE_PROOF_PENDING">;
+        evidenceRef: z.ZodNull;
+        sanitizedReason: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"SUPPORTED">;
+        verifiedAt: z.ZodISODateTime;
+        evidenceRef: z.ZodString;
+        byteRangeSupport: z.ZodEnum<{
+            LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+            VERIFIED_SUPPORTED: "VERIFIED_SUPPORTED";
+            VERIFIED_UNSUPPORTED: "VERIFIED_UNSUPPORTED";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"DEFERRED">;
+        decidedAt: z.ZodISODateTime;
+        evidenceRef: z.ZodString;
+        sanitizedReason: z.ZodString;
+    }, z.core.$strict>], "status">;
+    sanitizedDetail: z.ZodString;
+    deliveryPolicy: z.ZodObject<{
+        cacheControl: z.ZodLiteral<"private, no-store">;
+        maxBytes: z.ZodNumber;
+        timeoutMilliseconds: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"UNAVAILABLE">;
+    runId: z.ZodString;
+    sessionId: z.ZodString;
+    capability: z.ZodObject<{
+        status: z.ZodLiteral<"SUPPORTED">;
+        verifiedAt: z.ZodISODateTime;
+        evidenceRef: z.ZodString;
+        byteRangeSupport: z.ZodEnum<{
+            LIVE_PROOF_PENDING: "LIVE_PROOF_PENDING";
+            VERIFIED_SUPPORTED: "VERIFIED_SUPPORTED";
+            VERIFIED_UNSUPPORTED: "VERIFIED_UNSUPPORTED";
+        }>;
+    }, z.core.$strict>;
+    reason: z.ZodEnum<{
+        PROVIDER_OUTAGE: "PROVIDER_OUTAGE";
+        NOT_FOUND: "NOT_FOUND";
+        UNVERIFIED_BINDING: "UNVERIFIED_BINDING";
+        TOO_LARGE: "TOO_LARGE";
+        UNSUPPORTED_CONTENT_TYPE: "UNSUPPORTED_CONTENT_TYPE";
+        TEMPORARY_FAILURE: "TEMPORARY_FAILURE";
+    }>;
+    sanitizedDetail: z.ZodString;
+    deliveryPolicy: z.ZodObject<{
+        cacheControl: z.ZodLiteral<"private, no-store">;
+        maxBytes: z.ZodNumber;
+        timeoutMilliseconds: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"DEFERRED">;
+    runId: z.ZodString;
+    sessionId: z.ZodString;
+    capability: z.ZodObject<{
+        status: z.ZodLiteral<"DEFERRED">;
+        decidedAt: z.ZodISODateTime;
+        evidenceRef: z.ZodString;
+        sanitizedReason: z.ZodString;
+    }, z.core.$strict>;
+    deliveryPolicy: z.ZodObject<{
+        cacheControl: z.ZodLiteral<"private, no-store">;
+        maxBytes: z.ZodNumber;
+        timeoutMilliseconds: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>], "status">;
+export type VoiceAudioReadResponse = z.infer<typeof voiceAudioReadResponseSchema>;

package/dist/voice-runs-audio.js

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import { voiceAgentScopeSchema, voiceIdSchema, voiceTimestampSchema } from './voice-common.js';
+import { voiceRunSanitizedTextSchema } from './voice-runs-evidence.js';
+const deliveryPolicySchema = z.strictObject({
+    cacheControl: z.literal('private, no-store'),
+    maxBytes: z.number().int().positive().max(100_000_000).safe(),
+    timeoutMilliseconds: z.number().int().positive().max(60_000).safe(),
+});
+const supportedCapability = z.strictObject({
+    status: z.literal('SUPPORTED'),
+    verifiedAt: voiceTimestampSchema,
+    evidenceRef: z.string().trim().min(1).max(500),
+    byteRangeSupport: z.enum([
+        'LIVE_PROOF_PENDING', 'VERIFIED_SUPPORTED', 'VERIFIED_UNSUPPORTED',
+    ]),
+});
+const deferredCapability = z.strictObject({
+    status: z.literal('DEFERRED'),
+    decidedAt: voiceTimestampSchema,
+    evidenceRef: z.string().trim().min(1).max(500),
+    sanitizedReason: voiceRunSanitizedTextSchema,
+});
+export const voiceAudioCapabilitySchema = z.discriminatedUnion('status', [
+    z.strictObject({
+        status: z.literal('LIVE_PROOF_PENDING'), evidenceRef: z.null(),
+        sanitizedReason: voiceRunSanitizedTextSchema,
+    }),
+    supportedCapability,
+    deferredCapability,
+]);
+const byteRangeSchema = z.strictObject({
+    startByte: z.number().int().nonnegative().safe(),
+    endByte: z.number().int().nonnegative().safe().nullable(),
+}).refine((value) => value.endByte === null || value.endByte >= value.startByte, {
+    message: 'endByte cannot precede startByte',
+});
+export const voiceAudioReadRequestSchema = z.strictObject({
+    scope: voiceAgentScopeSchema,
+    runId: voiceIdSchema,
+    expectedSessionId: voiceIdSchema,
+    byteRange: byteRangeSchema.nullable(),
+});
+export const voiceAudioReadResponseSchema = z.discriminatedUnion('status', [
+    z.strictObject({
+        status: z.literal('AVAILABLE'), runId: voiceIdSchema, sessionId: voiceIdSchema,
+        capability: supportedCapability, delivery: z.literal('ATLAS_AUTHORIZED_STREAM'),
+        contentType: z.enum(['audio/mpeg', 'audio/wav', 'audio/ogg', 'audio/webm']),
+        contentLengthBytes: z.number().int().nonnegative().safe(),
+        deliveryPolicy: deliveryPolicySchema,
+    }),
+    z.strictObject({
+        status: z.literal('PENDING'), runId: voiceIdSchema, sessionId: voiceIdSchema,
+        capability: supportedCapability,
+        retryAfterSeconds: z.number().int().positive().max(60).safe(),
+        sanitizedDetail: voiceRunSanitizedTextSchema,
+        deliveryPolicy: deliveryPolicySchema,
+    }),
+    z.strictObject({
+        status: z.literal('DISABLED'), runId: voiceIdSchema, sessionId: voiceIdSchema,
+        capability: voiceAudioCapabilitySchema, sanitizedDetail: voiceRunSanitizedTextSchema,
+        deliveryPolicy: deliveryPolicySchema,
+    }),
+    z.strictObject({
+        status: z.literal('UNAVAILABLE'), runId: voiceIdSchema, sessionId: voiceIdSchema,
+        capability: supportedCapability,
+        reason: z.enum([
+            'PROVIDER_OUTAGE', 'NOT_FOUND', 'UNVERIFIED_BINDING', 'TOO_LARGE',
+            'UNSUPPORTED_CONTENT_TYPE', 'TEMPORARY_FAILURE',
+        ]),
+        sanitizedDetail: voiceRunSanitizedTextSchema,
+        deliveryPolicy: deliveryPolicySchema,
+    }),
+    z.strictObject({
+        status: z.literal('DEFERRED'), runId: voiceIdSchema, sessionId: voiceIdSchema,
+        capability: deferredCapability, deliveryPolicy: deliveryPolicySchema,
+    }),
+]).superRefine((value, context) => {
+    if (value.status === 'AVAILABLE' &&
+        value.contentLengthBytes > value.deliveryPolicy.maxBytes) {
+        context.addIssue({
+            code: 'custom', path: ['contentLengthBytes'],
+            message: 'audio content exceeds the authorized response bound',
+        });
+    }
+});

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

@@ -0,0 +1,183 @@
+import { z } from 'zod';
+export declare const voiceRunSanitizedTextSchema: z.ZodString;
+export declare const voiceBoundedRunEvidenceValueSchema: z.ZodJSONSchema;
+export declare const voiceDetailedRunEvidenceValueSchema: z.ZodJSONSchema;
+export declare const voiceTranscriptEntrySchema: z.ZodObject<{
+    sequence: z.ZodNumber;
+    speaker: z.ZodEnum<{
+        AGENT: "AGENT";
+        CALLER: "CALLER";
+        TOOL: "TOOL";
+        SYSTEM: "SYSTEM";
+    }>;
+    text: z.ZodString;
+    startedAt: z.ZodNullable<z.ZodISODateTime>;
+    endedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export declare const voiceTranscriptSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"AVAILABLE">;
+    transcriptReferenceId: z.ZodString;
+    capturedAt: z.ZodISODateTime;
+    entries: z.ZodArray<z.ZodObject<{
+        sequence: z.ZodNumber;
+        speaker: z.ZodEnum<{
+            AGENT: "AGENT";
+            CALLER: "CALLER";
+            TOOL: "TOOL";
+            SYSTEM: "SYSTEM";
+        }>;
+        text: z.ZodString;
+        startedAt: z.ZodNullable<z.ZodISODateTime>;
+        endedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    sanitizedDetail: z.ZodNull;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodEnum<{
+        MISSING: "MISSING";
+        PENDING: "PENDING";
+    }>;
+    transcriptReferenceId: z.ZodNull;
+    capturedAt: z.ZodNullable<z.ZodISODateTime>;
+    entries: z.ZodArray<z.ZodObject<{
+        sequence: z.ZodNumber;
+        speaker: z.ZodEnum<{
+            AGENT: "AGENT";
+            CALLER: "CALLER";
+            TOOL: "TOOL";
+            SYSTEM: "SYSTEM";
+        }>;
+        text: z.ZodString;
+        startedAt: z.ZodNullable<z.ZodISODateTime>;
+        endedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    sanitizedDetail: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"CONTRADICTORY">;
+    transcriptReferenceId: z.ZodNullable<z.ZodString>;
+    capturedAt: z.ZodNullable<z.ZodISODateTime>;
+    entries: z.ZodArray<z.ZodObject<{
+        sequence: z.ZodNumber;
+        speaker: z.ZodEnum<{
+            AGENT: "AGENT";
+            CALLER: "CALLER";
+            TOOL: "TOOL";
+            SYSTEM: "SYSTEM";
+        }>;
+        text: z.ZodString;
+        startedAt: z.ZodNullable<z.ZodISODateTime>;
+        endedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    sanitizedDetail: z.ZodString;
+}, z.core.$strict>], "status">;
+export type VoiceTranscript = z.infer<typeof voiceTranscriptSchema>;
+export declare const voiceCompletionEventKindSchema: z.ZodLiteral<"CALL_COMPLETED">;
+export type VoiceCompletionEventKind = z.infer<typeof voiceCompletionEventKindSchema>;
+export declare const voiceLogicalCompletionEventIdentitySchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    kind: z.ZodLiteral<"CALL_COMPLETED">;
+}, z.core.$strict>;
+export type VoiceLogicalCompletionEventIdentity = z.infer<typeof voiceLogicalCompletionEventIdentitySchema>;
+export declare function voiceLogicalCompletionEventKey({ sessionId, kind }: VoiceLogicalCompletionEventIdentity): string;
+export declare const voiceCompletionEventSchema: z.ZodObject<{
+    eventId: z.ZodString;
+    logicalIdentity: z.ZodObject<{
+        sessionId: z.ZodString;
+        kind: z.ZodLiteral<"CALL_COMPLETED">;
+    }, z.core.$strict>;
+    providerDeliveryIds: z.ZodArray<z.ZodString>;
+    evidenceStatus: z.ZodEnum<{
+        CONTRADICTORY: "CONTRADICTORY";
+        PENDING: "PENDING";
+        CONFIRMED: "CONFIRMED";
+    }>;
+    persistedAt: z.ZodISODateTime;
+    providerConversationId: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type VoiceCompletionEvent = z.infer<typeof voiceCompletionEventSchema>;
+export declare const voiceTelephoneOutcomeSchema: z.ZodEnum<{
+    FAILED: "FAILED";
+    COMPLETED: "COMPLETED";
+    UNKNOWN: "UNKNOWN";
+    CANCELLED: "CANCELLED";
+}>;
+export declare const voiceBusinessOutcomeSchema: z.ZodEnum<{
+    FAILED: "FAILED";
+    SUCCEEDED: "SUCCEEDED";
+    UNKNOWN: "UNKNOWN";
+    PARTIAL: "PARTIAL";
+    NOT_REQUESTED: "NOT_REQUESTED";
+}>;
+export declare const voiceRunWritebackStatusSchema: z.ZodEnum<{
+    FAILED: "FAILED";
+    RECONCILIATION_REQUIRED: "RECONCILIATION_REQUIRED";
+    COMPLETE: "COMPLETE";
+    PENDING: "PENDING";
+}>;
+export declare const voiceRunEvidenceStatusSchema: z.ZodEnum<{
+    COMPLETE: "COMPLETE";
+    INCOMPLETE: "INCOMPLETE";
+    CONTRADICTORY: "CONTRADICTORY";
+    PENDING: "PENDING";
+}>;
+export declare const voiceSyntheticResourceEvidenceSchema: z.ZodObject<{
+    candidate: z.ZodNullable<z.ZodObject<{
+        fixtureId: z.ZodString;
+        syntheticResource: z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    verifiedResource: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+    verificationStatus: z.ZodEnum<{
+        FAILED: "FAILED";
+        UNKNOWN: "UNKNOWN";
+        VERIFIED: "VERIFIED";
+        NOT_VERIFIED: "NOT_VERIFIED";
+        LOCKED: "LOCKED";
+        EXPIRED: "EXPIRED";
+        REVOKED: "REVOKED";
+    }>;
+}, z.core.$strict>;
+export declare const voiceRunEvidenceRetentionSchema: z.ZodObject<{
+    policy: z.ZodLiteral<"UNLIMITED">;
+    ageBasedExpiry: z.ZodLiteral<false>;
+    appliesTo: z.ZodTuple<[z.ZodLiteral<"TRANSCRIPT">, z.ZodLiteral<"TOOL_EVIDENCE">, z.ZodLiteral<"COMPLETION_EVENT">, z.ZodLiteral<"RUN_METADATA">, z.ZodLiteral<"RECORDING">], null>;
+}, z.core.$strict>;
+export type VoiceRunEvidenceRetention = z.infer<typeof voiceRunEvidenceRetentionSchema>;
+export declare const voiceRunRecordingSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"DISABLED">;
+    enabled: z.ZodLiteral<false>;
+    providerRetention: z.ZodNull;
+    sanitizedDetail: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"PENDING">;
+    enabled: z.ZodLiteral<true>;
+    providerRetention: z.ZodObject<{
+        policy: z.ZodLiteral<"UNLIMITED">;
+        providerRetentionDays: z.ZodLiteral<-1>;
+        evidenceRef: z.ZodString;
+    }, z.core.$strict>;
+    sanitizedDetail: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"AVAILABLE">;
+    enabled: z.ZodLiteral<true>;
+    providerRetention: z.ZodObject<{
+        policy: z.ZodLiteral<"UNLIMITED">;
+        providerRetentionDays: z.ZodLiteral<-1>;
+        evidenceRef: z.ZodString;
+    }, z.core.$strict>;
+    sanitizedDetail: z.ZodNull;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"UNAVAILABLE">;
+    enabled: z.ZodLiteral<true>;
+    providerRetention: z.ZodObject<{
+        policy: z.ZodLiteral<"UNLIMITED">;
+        providerRetentionDays: z.ZodLiteral<-1>;
+        evidenceRef: z.ZodString;
+    }, z.core.$strict>;
+    sanitizedDetail: z.ZodString;
+}, z.core.$strict>], "status">;
+export type VoiceRunRecording = z.infer<typeof voiceRunRecordingSchema>;