@sequenceholdings/agent-spec 0.1.1 → 0.1.3

package/dist/voice-runs-model.js

@@ -0,0 +1,199 @@
+import { z } from 'zod';
+import { sameVoiceResource } from './voice-authority-contracts.js';
+import { voiceAgentScopeSchema, voiceIdSchema, voiceTimestampSchema } from './voice-common.js';
+import { voiceCallDirectionSchema, voiceCallerIdentitySchema } from './voice-lifecycle.js';
+import { voiceCallDurationSnapshotSchema } from './voice-policy.js';
+import { voiceBusinessOutcomeSchema, voiceCompletionEventSchema, voiceRunEvidenceRetentionSchema, voiceRunEvidenceStatusSchema, voiceRunRecordingSchema, voiceRunWritebackStatusSchema, voiceSyntheticResourceEvidenceSchema, voiceTelephoneOutcomeSchema, voiceTranscriptSchema, } from './voice-runs-evidence.js';
+import { voiceMissingEvidenceSchema, voiceRunAuthenticationEvidenceSchema, voiceRunToolOutcomeSchema, } from './voice-runs-tooling.js';
+const summaryShape = {
+    schemaVersion: z.literal('1'),
+    scope: voiceAgentScopeSchema,
+    runId: voiceIdSchema,
+    sessionId: voiceIdSchema,
+    agentVersionId: voiceIdSchema,
+    releaseId: voiceIdSchema,
+    direction: voiceCallDirectionSchema,
+    callerIdentity: voiceCallerIdentitySchema,
+    runtimeAccountId: voiceIdSchema,
+    enablingOperatorPrincipalId: voiceIdSchema.nullable(),
+    admittedAt: voiceTimestampSchema,
+    startedAt: voiceTimestampSchema.nullable(),
+    endedAt: voiceTimestampSchema.nullable(),
+    durationSeconds: z.number().int().nonnegative().safe().nullable(),
+    telephoneOutcome: voiceTelephoneOutcomeSchema,
+    businessOutcome: voiceBusinessOutcomeSchema,
+    writebackStatus: voiceRunWritebackStatusSchema,
+    evidenceStatus: voiceRunEvidenceStatusSchema,
+    syntheticResource: voiceSyntheticResourceEvidenceSchema,
+    retention: voiceRunEvidenceRetentionSchema,
+    recording: voiceRunRecordingSchema,
+};
+function addIssue({ context, path, message }) {
+    context.addIssue({ code: 'custom', path, message });
+}
+function validateSummary({ value, context }) {
+    if (value.direction !== value.callerIdentity.direction) {
+        addIssue({ context, path: ['callerIdentity', 'direction'],
+            message: 'run direction must match caller identity direction' });
+    }
+    if (value.durationSeconds !== null && (value.startedAt === null || value.endedAt === null)) {
+        addIssue({ context, path: ['durationSeconds'],
+            message: 'duration requires connected start and end timestamps' });
+    }
+    if (value.startedAt !== null && Date.parse(value.startedAt) < Date.parse(value.admittedAt)) {
+        addIssue({ context, path: ['startedAt'], message: 'connected start cannot precede admission' });
+    }
+    if (value.endedAt !== null && Date.parse(value.endedAt) <
+        Date.parse(value.startedAt ?? value.admittedAt)) {
+        addIssue({ context, path: ['endedAt'], message: 'end cannot precede admission or connection' });
+    }
+}
+export const voiceCompletedRunSummarySchema = z.strictObject(summaryShape)
+    .superRefine((value, context) => validateSummary({ value, context }));
+const providerReferencesSchema = z.strictObject({
+    provider: z.literal('ELEVENLABS'),
+    providerAgentId: voiceIdSchema.nullable(),
+    providerConversationId: voiceIdSchema.nullable(),
+    conversationBindingStatus: z.enum([
+        'CORROBORATED', 'UNVERIFIED', 'MISSING', 'CONTRADICTORY',
+    ]),
+    twilioCallSid: voiceIdSchema.nullable(),
+}).superRefine((value, context) => {
+    if (value.conversationBindingStatus === 'CORROBORATED' &&
+        [value.providerAgentId, value.providerConversationId, value.twilioCallSid]
+            .some((field) => field === null)) {
+        context.addIssue({ code: 'custom', message: 'corroborated binding requires all provider IDs' });
+    }
+});
+const monetaryCostFactSchema = z.strictObject({
+    source: z.enum(['PROVIDER', 'TWILIO', 'ATLAS']),
+    category: z.enum(['CALL', 'MODEL', 'TELEPHONY', 'TOOL']),
+    currency: z.string().regex(/^[A-Z]{3}$/),
+    amountMinorUnits: z.number().int().nonnegative().safe(),
+});
+const costFactSchema = z.union([monetaryCostFactSchema, z.strictObject({
+        source: z.literal('PROVIDER'), category: z.literal('CALL'), unit: z.literal('CREDITS'),
+        amount: z.number().finite().nonnegative().max(1_000_000_000_000),
+    })]);
+const latencyFactSchema = z.strictObject({
+    source: z.enum(['PROVIDER', 'TWILIO', 'ATLAS']),
+    metric: z.enum([
+        'FIRST_AUDIBLE_RESPONSE', 'FIRST_SUBSTANTIVE_RESPONSE',
+        'TOOL_INVOCATION', 'COMPLETION_PROCESSING',
+    ]),
+    milliseconds: z.number().int().nonnegative().safe(),
+});
+const detailSchema = z.strictObject({
+    ...summaryShape,
+    callPolicy: voiceCallDurationSnapshotSchema,
+    providerReferences: providerReferencesSchema,
+    authentication: voiceRunAuthenticationEvidenceSchema,
+    toolOutcomes: z.array(voiceRunToolOutcomeSchema).max(200),
+    transcript: voiceTranscriptSchema,
+    completionEvent: voiceCompletionEventSchema.nullable(),
+    missingEvidence: z.array(voiceMissingEvidenceSchema).max(25),
+    costFacts: z.array(costFactSchema).max(20),
+    latencyFacts: z.array(latencyFactSchema).max(20),
+    terminationReason: z.enum([
+        'REMOTE_HANGUP', 'ATLAS_CANCELLED', 'DURATION_LIMIT', 'PROVIDER_FAILURE',
+        'TELEPHONY_FAILURE', 'ADMISSION_SHUTDOWN', 'UNKNOWN',
+    ]),
+});
+function validatePolicyAndBindings({ value, context }) {
+    if (Date.parse(value.callPolicy.admittedAt) !== Date.parse(value.admittedAt)) {
+        addIssue({ context, path: ['callPolicy', 'admittedAt'],
+            message: 'policy admission timestamp must match the run' });
+    }
+    const policyConnected = value.callPolicy.connectedAt === null
+        ? null : Date.parse(value.callPolicy.connectedAt);
+    const runConnected = value.startedAt === null ? null : Date.parse(value.startedAt);
+    if (policyConnected !== runConnected) {
+        addIssue({ context, path: ['callPolicy', 'connectedAt'],
+            message: 'policy connected timestamp must match the run' });
+    }
+    if (value.completionEvent !== null &&
+        value.completionEvent.logicalIdentity.sessionId !== value.sessionId) {
+        addIssue({ context, path: ['completionEvent', 'logicalIdentity', 'sessionId'],
+            message: 'completion event must identify the run session' });
+    }
+    if (value.completionEvent?.evidenceStatus === 'CONFIRMED' &&
+        (value.providerReferences.conversationBindingStatus !== 'CORROBORATED' ||
+            value.completionEvent.providerConversationId === null ||
+            value.completionEvent.providerConversationId !==
+                value.providerReferences.providerConversationId)) {
+        addIssue({ context, path: ['completionEvent', 'providerConversationId'],
+            message: 'confirmed event must match the corroborated provider conversation' });
+    }
+    const expectedAbsoluteExpiry = Date.parse(value.callPolicy.admittedAt) +
+        (value.callPolicy.setupAllowanceSeconds + value.callPolicy.maxCallDurationSeconds) * 1_000;
+    if (Date.parse(value.callPolicy.absoluteExpiresAt) !== expectedAbsoluteExpiry) {
+        addIssue({ context, path: ['callPolicy', 'absoluteExpiresAt'],
+            message: 'absolute expiry must match the admitted policy snapshot' });
+    }
+    if (policyConnected !== null) {
+        const expectedDeadline = Math.min(policyConnected + value.callPolicy.maxCallDurationSeconds * 1_000, expectedAbsoluteExpiry);
+        if (value.callPolicy.connectedDeadlineAt === null ||
+            Date.parse(value.callPolicy.connectedDeadlineAt) !== expectedDeadline) {
+            addIssue({ context, path: ['callPolicy', 'connectedDeadlineAt'],
+                message: 'connected deadline must match the admitted duration bound' });
+        }
+    }
+    else if (value.callPolicy.connectedDeadlineAt !== null) {
+        addIssue({ context, path: ['callPolicy', 'connectedDeadlineAt'],
+            message: 'an unconnected call cannot claim a connected deadline' });
+    }
+    if (value.authentication.outcome === 'verified' &&
+        (value.authentication.verifiedResource === null || value.syntheticResource.verifiedResource === null ||
+            !sameVoiceResource({ left: value.authentication.verifiedResource, right: value.syntheticResource.verifiedResource }))) {
+        addIssue({ context, path: ['authentication'],
+            message: 'verification and resource evidence must identify the same resource' });
+    }
+}
+function validateEvidenceStatus({ value, context }) {
+    if (value.enablingOperatorPrincipalId === null && !value.missingEvidence.some(({ kind }) => kind === 'ENABLING_OPERATOR')) {
+        addIssue({ context, path: ['enablingOperatorPrincipalId'], message: 'missing operator provenance requires an explicit indicator' });
+    }
+    if ((value.evidenceStatus === 'COMPLETE') !== (value.missingEvidence.length === 0)) {
+        addIssue({ context, path: ['missingEvidence'],
+            message: 'evidence status must agree with explicit missing-evidence indicators' });
+    }
+    if (value.transcript.status !== 'AVAILABLE' &&
+        !value.missingEvidence.some(({ kind }) => kind === 'TRANSCRIPT')) {
+        addIssue({ context, path: ['missingEvidence'],
+            message: 'unavailable transcript requires an explicit indicator' });
+    }
+    if (value.completionEvent === null &&
+        !value.missingEvidence.some(({ kind }) => kind === 'COMPLETION_EVENT')) {
+        addIssue({ context, path: ['missingEvidence'],
+            message: 'missing completion event requires an explicit indicator' });
+    }
+    if (value.businessOutcome === 'SUCCEEDED') {
+        const businessEvidence = value.toolOutcomes.filter(({ operationKind }) => operationKind !== 'AUTHENTICATION');
+        const hasTerminalSuccess = businessEvidence.some((outcome) => outcome.status === 'SUCCEEDED' &&
+            (outcome.operationKind !== 'BUSINESS_ACTION' ||
+                outcome.actionPhase === 'CONFIRM' || outcome.actionPhase === 'CANCEL'));
+        if (!hasTerminalSuccess || businessEvidence.some(({ status }) => status !== 'SUCCEEDED')) {
+            addIssue({ context, path: ['businessOutcome'],
+                message: 'SUCCEEDED business outcome requires successful business evidence with no failed or uncertain operation' });
+        }
+    }
+}
+export const voiceCompletedRunDetailSchema = detailSchema.superRefine((value, context) => {
+    validateSummary({ value, context });
+    validatePolicyAndBindings({ value, context });
+    validateEvidenceStatus({ value, context });
+});
+export const voiceCompletedRunListRequestSchema = z.strictObject({
+    scope: voiceAgentScopeSchema, cursor: z.string().trim().min(1).max(500).nullable(),
+    limit: z.number().int().min(1).max(100).safe(),
+    telephoneOutcome: voiceTelephoneOutcomeSchema.nullable(),
+    evidenceStatus: voiceRunEvidenceStatusSchema.nullable(),
+});
+export const voiceCompletedRunListResponseSchema = z.strictObject({
+    items: z.array(voiceCompletedRunSummarySchema).max(100),
+    nextCursor: z.string().trim().min(1).max(500).nullable(),
+});
+export const voiceCompletedRunDetailRequestSchema = z.strictObject({
+    scope: voiceAgentScopeSchema, runId: voiceIdSchema,
+});
+export const voiceCompletedRunDetailResponseSchema = voiceCompletedRunDetailSchema;

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

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+export declare const voiceRunAuthenticationEvidenceSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        unknown: "unknown";
+        verified: "verified";
+        locked: "locked";
+        rejected: "rejected";
+        not_attempted: "not_attempted";
+    }>;
+    authorityAtRunEnd: z.ZodEnum<{
+        unknown: "unknown";
+        expired: "expired";
+        revoked: "revoked";
+        active: "active";
+    }>;
+    method: z.ZodNullable<z.ZodString>;
+    attemptedAt: z.ZodNullable<z.ZodISODateTime>;
+    verifiedAt: z.ZodNullable<z.ZodISODateTime>;
+    verifiedResource: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+    verifierInvocationId: z.ZodNullable<z.ZodString>;
+    observedFunctionVersionId: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const voiceRunToolOutcomeSchema: z.ZodObject<{
+    toolInvocationId: z.ZodString;
+    providerToolCallId: z.ZodNullable<z.ZodString>;
+    functionInvocationId: z.ZodNullable<z.ZodString>;
+    actionIntentId: z.ZodNullable<z.ZodString>;
+    actionReceiptId: z.ZodNullable<z.ZodString>;
+    actionPhase: z.ZodNullable<z.ZodEnum<{
+        UNKNOWN: "UNKNOWN";
+        PREPARE: "PREPARE";
+        CONFIRM: "CONFIRM";
+        CANCEL: "CANCEL";
+    }>>;
+    actionResolution: z.ZodNullable<z.ZodEnum<{
+        CANCELLED: "CANCELLED";
+        COMMITTED: "COMMITTED";
+    }>>;
+    toolAlias: z.ZodString;
+    operationKind: z.ZodEnum<{
+        AUTHENTICATION: "AUTHENTICATION";
+        READ: "READ";
+        CALCULATION: "CALCULATION";
+        BUSINESS_ACTION: "BUSINESS_ACTION";
+    }>;
+    status: z.ZodEnum<{
+        FAILED: "FAILED";
+        SUCCEEDED: "SUCCEEDED";
+        UNKNOWN: "UNKNOWN";
+        CANCELLED: "CANCELLED";
+        DENIED: "DENIED";
+    }>;
+    startedAt: z.ZodISODateTime;
+    completedAt: z.ZodNullable<z.ZodISODateTime>;
+    observedFunctionVersionId: z.ZodNullable<z.ZodString>;
+    validatedArguments: z.ZodNullable<z.ZodJSONSchema>;
+    boundedResult: z.ZodNullable<z.ZodJSONSchema>;
+    sanitizedError: z.ZodNullable<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type VoiceRunToolOutcome = z.infer<typeof voiceRunToolOutcomeSchema>;
+export declare const voiceMissingEvidenceSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        TRANSCRIPT: "TRANSCRIPT";
+        COMPLETION_EVENT: "COMPLETION_EVENT";
+        RECORDING: "RECORDING";
+        AUTHENTICATION: "AUTHENTICATION";
+        RUNTIME_IDENTITY: "RUNTIME_IDENTITY";
+        ENABLING_OPERATOR: "ENABLING_OPERATOR";
+        PROVIDER_BINDING: "PROVIDER_BINDING";
+        CALL_TIMING: "CALL_TIMING";
+        ACTION_RESULT: "ACTION_RESULT";
+        WRITEBACK: "WRITEBACK";
+    }>;
+    status: z.ZodEnum<{
+        MISSING: "MISSING";
+        CONTRADICTORY: "CONTRADICTORY";
+        PENDING: "PENDING";
+    }>;
+    firstObservedAt: z.ZodISODateTime;
+    sanitizedDetail: z.ZodString;
+}, z.core.$strict>;
+export type VoiceMissingEvidence = z.infer<typeof voiceMissingEvidenceSchema>;

package/dist/voice-runs-tooling.js

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+import { voiceResourceReferenceSchema } from './voice-authority-contracts.js';
+import { voiceIdSchema, voiceLocalKeySchema, voiceTimestampSchema } from './voice-common.js';
+import { voiceBoundedRunEvidenceValueSchema, voiceRunSanitizedTextSchema, } from './voice-runs-evidence.js';
+export const voiceRunAuthenticationEvidenceSchema = z.strictObject({
+    outcome: z.enum(['not_attempted', 'verified', 'rejected', 'locked', 'unknown']),
+    authorityAtRunEnd: z.enum(['active', 'expired', 'revoked', 'unknown']),
+    method: voiceLocalKeySchema.nullable(),
+    attemptedAt: voiceTimestampSchema.nullable(),
+    verifiedAt: voiceTimestampSchema.nullable(),
+    verifiedResource: voiceResourceReferenceSchema.nullable(),
+    verifierInvocationId: voiceIdSchema.nullable(),
+    observedFunctionVersionId: voiceIdSchema.nullable(),
+}).superRefine((value, context) => {
+    const proof = [value.method, value.attemptedAt, value.verifiedAt,
+        value.verifiedResource, value.verifierInvocationId,
+        value.observedFunctionVersionId];
+    if (value.outcome === 'verified' && proof.some((field) => field === null)) {
+        context.addIssue({ code: 'custom', message: 'verified outcome requires verifier evidence' });
+    }
+    if (value.outcome === 'not_attempted' && proof.some((field) => field !== null)) {
+        context.addIssue({ code: 'custom', message: 'not-attempted outcome cannot carry verifier evidence' });
+    }
+});
+const toolOutcomeBaseSchema = z.strictObject({
+    toolInvocationId: voiceIdSchema,
+    providerToolCallId: voiceIdSchema.nullable(),
+    functionInvocationId: voiceIdSchema.nullable(),
+    actionIntentId: voiceIdSchema.nullable(),
+    actionReceiptId: voiceIdSchema.nullable(),
+    actionPhase: z.enum(['PREPARE', 'CONFIRM', 'CANCEL', 'UNKNOWN']).nullable(),
+    actionResolution: z.enum(['COMMITTED', 'CANCELLED']).nullable(),
+    toolAlias: voiceLocalKeySchema,
+    operationKind: z.enum(['AUTHENTICATION', 'READ', 'CALCULATION', 'BUSINESS_ACTION']),
+    status: z.enum(['SUCCEEDED', 'FAILED', 'DENIED', 'CANCELLED', 'UNKNOWN']),
+    startedAt: voiceTimestampSchema,
+    completedAt: voiceTimestampSchema.nullable(),
+    observedFunctionVersionId: voiceIdSchema.nullable(),
+    validatedArguments: voiceBoundedRunEvidenceValueSchema.nullable(),
+    boundedResult: voiceBoundedRunEvidenceValueSchema.nullable(),
+    sanitizedError: z.strictObject({
+        code: z.string().trim().min(1).max(100), message: voiceRunSanitizedTextSchema,
+    }).nullable(),
+});
+function validateExecutionEvidence({ value, context }) {
+    const executionProof = [value.completedAt, value.functionInvocationId,
+        value.observedFunctionVersionId, value.boundedResult];
+    if (value.status === 'SUCCEEDED' && executionProof.some((field) => field === null)) {
+        context.addIssue({ code: 'custom', message: 'successful tool outcome lacks execution evidence' });
+    }
+    if (value.status === 'UNKNOWN' && value.sanitizedError === null) {
+        context.addIssue({ code: 'custom', message: 'unknown outcome requires reconciliation reason' });
+    }
+}
+function validateActionEvidence({ value, context }) {
+    if (value.actionReceiptId !== null && value.actionIntentId === null) {
+        context.addIssue({ code: 'custom', message: 'action receipt requires an action intent' });
+    }
+    if ((value.actionReceiptId !== null || value.actionResolution !== null) &&
+        value.status !== 'SUCCEEDED') {
+        context.addIssue({ code: 'custom', message: 'only a successful action can claim resolution evidence' });
+    }
+    if (value.operationKind === 'BUSINESS_ACTION' && value.actionPhase === null) {
+        context.addIssue({ code: 'custom', message: 'business action requires an explicit phase' });
+    }
+    if (value.operationKind !== 'BUSINESS_ACTION' &&
+        [value.actionIntentId, value.actionReceiptId, value.actionPhase, value.actionResolution]
+            .some((field) => field !== null)) {
+        context.addIssue({ code: 'custom', message: 'non-action tool cannot claim action evidence' });
+    }
+    if (value.status === 'SUCCEEDED' && value.operationKind === 'BUSINESS_ACTION') {
+        if (value.actionPhase === 'UNKNOWN') {
+            context.addIssue({ code: 'custom', message: 'unclassified action cannot claim success' });
+        }
+        if (value.actionIntentId === null) {
+            context.addIssue({ code: 'custom', message: 'successful action phase requires an intent' });
+        }
+        const expectedResolution = value.actionPhase === 'CONFIRM' ? 'COMMITTED'
+            : value.actionPhase === 'CANCEL' ? 'CANCELLED' : null;
+        if (value.actionResolution !== expectedResolution ||
+            (value.actionPhase === 'CONFIRM' && value.actionReceiptId === null) ||
+            (value.actionPhase === 'PREPARE' && value.actionReceiptId !== null)) {
+            context.addIssue({ code: 'custom', message: 'action phase has invalid resolution evidence' });
+        }
+    }
+}
+export const voiceRunToolOutcomeSchema = toolOutcomeBaseSchema.superRefine((value, context) => {
+    validateExecutionEvidence({ value, context });
+    validateActionEvidence({ value, context });
+});
+export const voiceMissingEvidenceSchema = z.strictObject({
+    kind: z.enum([
+        'RUNTIME_IDENTITY', 'ENABLING_OPERATOR', 'PROVIDER_BINDING', 'CALL_TIMING',
+        'AUTHENTICATION', 'ACTION_RESULT', 'TRANSCRIPT', 'COMPLETION_EVENT',
+        'WRITEBACK', 'RECORDING',
+    ]),
+    status: z.enum(['PENDING', 'MISSING', 'CONTRADICTORY']),
+    firstObservedAt: voiceTimestampSchema,
+    sanitizedDetail: voiceRunSanitizedTextSchema,
+});

package/dist/voice-runs.d.ts

@@ -0,0 +1,4 @@
+export * from './voice-runs-evidence.js';
+export * from './voice-runs-tooling.js';
+export * from './voice-runs-model.js';
+export * from './voice-runs-audio.js';

package/dist/voice-runs.js

@@ -0,0 +1,4 @@
+export * from './voice-runs-evidence.js';
+export * from './voice-runs-tooling.js';
+export * from './voice-runs-model.js';
+export * from './voice-runs-audio.js';

package/dist/voice.d.ts

@@ -0,0 +1,13 @@
+export * from './voice-common.js';
+export * from './voice-access.js';
+export * from './voice-authoring.js';
+export * from './voice-drafts.js';
+export * from './voice-policy.js';
+export * from './voice-lifecycle.js';
+export * from './voice-authority.js';
+export * from './voice-grant.js';
+export * from './voice-actions.js';
+export * from './voice-provider.js';
+export * from './voice-release.js';
+export * from './voice-runs.js';
+export * from './voice-api.js';

package/dist/voice.js

@@ -0,0 +1,13 @@
+export * from './voice-common.js';
+export * from './voice-access.js';
+export * from './voice-authoring.js';
+export * from './voice-drafts.js';
+export * from './voice-policy.js';
+export * from './voice-lifecycle.js';
+export * from './voice-authority.js';
+export * from './voice-grant.js';
+export * from './voice-actions.js';
+export * from './voice-provider.js';
+export * from './voice-release.js';
+export * from './voice-runs.js';
+export * from './voice-api.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sequenceholdings/agent-spec",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Typed agent definition contract, compiler, hashing, and migration utilities",
   "license": "UNLICENSED",
   "repository": {
@@ -30,6 +30,11 @@
       "types": "./dist/yaml.d.ts",
       "import": "./dist/yaml.js",
       "default": "./dist/yaml.js"
+    },
+    "./voice-runs-audio": {
+      "types": "./dist/voice-runs-audio.d.ts",
+      "import": "./dist/voice-runs-audio.js",
+      "default": "./dist/voice-runs-audio.js"
     }
   },
   "files": [
@@ -37,14 +42,14 @@
     "README.md"
   ],
   "dependencies": {
-    "js-yaml": "^4.1.1",
+    "js-yaml": "^4.3.2",
     "typescript": "^5.6.0",
     "zod": "^4.1.13"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.0.0",
-    "vitest": "^4.1.5"
+    "vitest": "^4.1.11"
   },
   "engines": {
     "node": ">=20"