@superpanel-sdk/runtime 0.2.2 → 0.2.3

package/dist/core/stage/ivr-fields.js

@@ -0,0 +1,75 @@
+import { idField } from '../slot/schema.js';
+import { isResolved } from '../slot/field.js';
+import { getSingleField } from '../slot/snapshot.js';
+import { getCompiledTable } from '../slot/compile-schema.js';
+import { formatFieldPath } from '../slot/path.js';
+import { transferFieldKey } from './transfer-fields.js';
+const RESULT_ENUM = ['collected', 'failed'];
+function ivrFieldCore(label) {
+    return {
+        derived: false,
+        label,
+        dataType: 'string',
+        source: 'system',
+        extraction: 'Platform IVR result',
+        enum: [...RESULT_ENUM],
+        nullable: true,
+        identifier: null,
+        ref: null,
+    };
+}
+export function ivrResultField(nodeId) {
+    return formatFieldPath('session', `ivr_${transferFieldKey(nodeId)}_result`);
+}
+export function ivrAttempted(item, snapshot) {
+    return isResolved(getSingleField(snapshot, item.resultField));
+}
+export function collectIvrBlocks(blocks, nodes = []) {
+    const out = [];
+    const seen = new Set();
+    for (const block of Object.values(blocks)) {
+        if (block.kind === 'ivr' && !seen.has(block.id)) {
+            seen.add(block.id);
+            out.push(block);
+        }
+    }
+    visit(nodes);
+    return out;
+    function visit(list) {
+        for (const node of list) {
+            if (node.kind === 'ivr' && !seen.has(node.id)) {
+                seen.add(node.id);
+                out.push(node);
+            }
+            else if (node.kind === 'section' || node.kind === 'branch') {
+                visit(node.children);
+            }
+            else if (node.kind === 'switchOn') {
+                for (const children of Object.values(node.cases))
+                    visit(children);
+                if (node.otherwise)
+                    visit(node.otherwise);
+            }
+        }
+    }
+}
+export function registerIvrSessionFields(schema, ivrIds) {
+    const ids = [...new Set(ivrIds)];
+    if (ids.length === 0)
+        return schema;
+    const session = getCompiledTable(schema, 'session');
+    if (!session)
+        return schema;
+    const fields = { ...session.fields };
+    if (!fields.id)
+        fields.id = { ...idField, ref: null };
+    for (const id of ids) {
+        const name = `ivr_${transferFieldKey(id)}_result`;
+        if (!fields[name]) {
+            fields[name] = ivrFieldCore(`IVR ${id} result`);
+        }
+    }
+    const nextSession = { ...session, fields };
+    return { ...schema, session: nextSession };
+}
+//# sourceMappingURL=ivr-fields.js.map

package/dist/core/stage/transfer-fields.d.ts

@@ -5,10 +5,15 @@ import type { AgendaBlock, AuthoringNode, TransferBlock } from './types.js';
 export declare function transferFieldKey(nodeId: string): string;
 export declare function transferResultField(nodeId: string): FieldPath;
 export declare const LAST_TRANSFER_RESULT_FIELD: `${string}.${string}`;
+export declare const CASE_TRANSFER_ATTEMPT_COUNT: `${string}.${string}`;
+export declare const CASE_LAST_TRANSFER_RESULT: `${string}.${string}`;
+export declare const CASE_LAST_TRANSFER_AT: `${string}.${string}`;
 export declare function collectTransferBlocks(blocks: Record<string, AgendaBlock>, nodes?: AuthoringNode[]): TransferBlock[];
 /**
  * Register per-node `session.transfer_<id>_result` and `session.last_transfer_result`.
  * Existing session fields with the same name are left untouched.
  */
-export declare function registerTransferSessionFields(schema: CompiledSlotSchema, transferIds: Iterable<string>): CompiledSlotSchema;
+export declare function registerTransferSessionFields(schema: CompiledSlotSchema, transferIds: Iterable<string>, options?: {
+    lastResult?: boolean;
+}): CompiledSlotSchema;
 //# sourceMappingURL=transfer-fields.d.ts.map

package/dist/core/stage/transfer-fields.js

@@ -24,6 +24,9 @@ export function transferResultField(nodeId) {
     return formatFieldPath('session', `transfer_${transferFieldKey(nodeId)}_result`);
 }
 export const LAST_TRANSFER_RESULT_FIELD = formatFieldPath('session', 'last_transfer_result');
+export const CASE_TRANSFER_ATTEMPT_COUNT = formatFieldPath('case_file', 'transfer_attempt_count');
+export const CASE_LAST_TRANSFER_RESULT = formatFieldPath('case_file', 'last_transfer_result');
+export const CASE_LAST_TRANSFER_AT = formatFieldPath('case_file', 'last_transfer_at');
 export function collectTransferBlocks(blocks, nodes = []) {
     const out = [];
     const seen = new Set();
@@ -57,9 +60,9 @@ export function collectTransferBlocks(blocks, nodes = []) {
  * Register per-node `session.transfer_<id>_result` and `session.last_transfer_result`.
  * Existing session fields with the same name are left untouched.
  */
-export function registerTransferSessionFields(schema, transferIds) {
+export function registerTransferSessionFields(schema, transferIds, options) {
     const ids = [...new Set(transferIds)];
-    if (ids.length === 0)
+    if (ids.length === 0 && !options?.lastResult)
         return schema;
     const session = getCompiledTable(schema, 'session');
     if (!session)
@@ -73,16 +76,54 @@ export function registerTransferSessionFields(schema, transferIds) {
             fields[name] = transferFieldCore(`Transfer ${id} result`);
         }
     }
-    if (!fields.last_transfer_result) {
+    if ((ids.length > 0 || options?.lastResult) && !fields.last_transfer_result) {
         fields.last_transfer_result = transferFieldCore('Last transfer result');
     }
     const nextSession = {
         ...session,
         fields,
     };
+    const caseFile = getCompiledTable(schema, 'case_file');
+    let nextCase = caseFile;
+    if (caseFile && (ids.length > 0 || options?.lastResult)) {
+        const caseFields = { ...caseFile.fields };
+        if (!caseFields.id)
+            caseFields.id = { ...idField, ref: null };
+        if (!caseFields.transfer_attempt_count) {
+            caseFields.transfer_attempt_count = {
+                derived: false,
+                label: 'Transfer attempt count',
+                dataType: 'number',
+                source: 'system',
+                extraction: 'Platform transfer attempt count',
+                enum: null,
+                nullable: true,
+                identifier: null,
+                ref: null,
+            };
+        }
+        if (!caseFields.last_transfer_result) {
+            caseFields.last_transfer_result = transferFieldCore('Case last transfer result');
+        }
+        if (!caseFields.last_transfer_at) {
+            caseFields.last_transfer_at = {
+                derived: false,
+                label: 'Last transfer at',
+                dataType: 'datetime',
+                source: 'system',
+                extraction: 'Platform last transfer time',
+                enum: null,
+                nullable: true,
+                identifier: null,
+                ref: null,
+            };
+        }
+        nextCase = { ...caseFile, fields: caseFields };
+    }
     return {
         ...schema,
         session: nextSession,
+        ...(nextCase ? { case_file: nextCase } : {}),
     };
 }
 //# sourceMappingURL=transfer-fields.js.map

package/dist/core/stage/transfer-spec.d.ts

@@ -0,0 +1,48 @@
+import type { FieldPath } from '../slot/path.js';
+import type { RuntimeSlotsSnapshot, ValidationIssue } from '../slot/types.js';
+export type TransferMode = 'cold' | 'warm' | 'async-warm';
+export type TransferCallerIdShown = 'client' | 'service';
+export type TransferConfirmMethod = 'keypad' | 'llm';
+export type TransferConfirmKey = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '*' | '#';
+export type TransferSay = string | Record<string, string>;
+export type TransferFallbackAction = 'end-call' | 'restore-normal-call-state';
+/** mars-voice-service `TransferCallArgs`. String fields may contain `{{table.field}}`. */
+export type TransferArguments = {
+    sendDigits?: string;
+    sipUrl?: string;
+    sipUsername?: string;
+    sipPassword?: string;
+    transferCallerIdShown?: TransferCallerIdShown;
+};
+/** Shared dial config for agenda transfer nodes and interrupt transfer actions. */
+export type TransferDial = {
+    numbers: string[];
+    mode: TransferMode;
+    say?: TransferSay | null;
+    unsuccessfulSay?: TransferSay | null;
+    fallbackAction?: TransferFallbackAction | null;
+    arguments?: TransferArguments | null;
+    warmConfirmMode?: TransferConfirmMethod[] | null;
+    warmConfirmKeypad?: TransferConfirmKey | null;
+    warmConfirmTimeoutMs?: number | null;
+    warmLoopSay?: string | null;
+    warmBriefingPrompt?: string | null;
+    asyncWarmBridge?: {
+        targetSayTemplate?: string;
+        customerSayTemplate?: string;
+    } | null;
+};
+export declare const E164_NUMBER: RegExp;
+export declare const SIP_URI: RegExp;
+export declare function isTransferDestinationLiteral(value: string): boolean;
+export declare function interpolateTemplate(text: string, read: (path: FieldPath) => string | number | boolean | null | undefined): string;
+export declare function interpolateFromSnapshot(text: string, snapshot: RuntimeSlotsSnapshot): string;
+export declare function resolveTransferDestinations(numbers: string[], snapshot: RuntimeSlotsSnapshot): string[];
+export declare function resolveTransferSay(say: TransferSay | null | undefined, language: string | null | undefined, fallback: string): string;
+export declare function resolveTransferArguments(dial: TransferDial, snapshot: RuntimeSlotsSnapshot): TransferArguments;
+export declare function transferArgumentsJson(dial: TransferDial, snapshot: RuntimeSlotsSnapshot): string;
+export declare function validateTransferDestinations(numbers: string[], options: {
+    path: string;
+    code: string;
+}): ValidationIssue[];
+//# sourceMappingURL=transfer-spec.d.ts.map

package/dist/core/stage/transfer-spec.js

@@ -0,0 +1,113 @@
+import { parseFieldPath } from '../slot/path.js';
+import { getRowField } from '../slot/row.js';
+import { getSnapshotTable } from '../slot/snapshot.js';
+import { extractTemplateFields } from './condition.js';
+export const E164_NUMBER = /^\+[1-9]\d{7,14}$/;
+export const SIP_URI = /^sips?:[^@\s]+@[^@\s]+$/i;
+const TEMPLATE_RE = /\{\{\s*([A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g;
+export function isTransferDestinationLiteral(value) {
+    return E164_NUMBER.test(value) || SIP_URI.test(value);
+}
+export function interpolateTemplate(text, read) {
+    return text.replace(TEMPLATE_RE, (_all, path) => {
+        const value = read(path);
+        return value == null ? '' : String(value);
+    });
+}
+function boundRowId(tableName, current) {
+    if (!current)
+        return undefined;
+    if (tableName === 'contact')
+        return current.contactId;
+    if (tableName === 'case_contact')
+        return current.caseContactId;
+    if (tableName === 'case_file')
+        return current.caseFileId;
+    return undefined;
+}
+export function interpolateFromSnapshot(text, snapshot) {
+    return interpolateTemplate(text, (path) => {
+        const parsed = parseFieldPath(path);
+        if (!parsed)
+            return '';
+        const data = getSnapshotTable(snapshot, parsed.table);
+        if (!data)
+            return '';
+        if (!Array.isArray(data))
+            return getRowField(data, parsed.field)?.value ?? '';
+        const id = boundRowId(parsed.table, snapshot.current);
+        if (!id)
+            return '';
+        const row = data.find((entry) => entry.id === id);
+        return row ? (getRowField(row, parsed.field)?.value ?? '') : '';
+    });
+}
+export function resolveTransferDestinations(numbers, snapshot) {
+    const out = [];
+    for (const raw of numbers) {
+        const resolved = interpolateFromSnapshot(raw, snapshot).trim();
+        if (resolved)
+            out.push(resolved);
+    }
+    return out;
+}
+export function resolveTransferSay(say, language, fallback) {
+    if (say == null)
+        return fallback;
+    if (typeof say === 'string')
+        return say.trim() || fallback;
+    const key = language?.trim().toLowerCase() || 'english';
+    const picked = say[key] ?? say.english ?? Object.values(say).find((value) => value.trim().length > 0);
+    return picked?.trim() || fallback;
+}
+function interpolatedArg(value, snapshot) {
+    return value ? interpolateFromSnapshot(value, snapshot).trim() : '';
+}
+export function resolveTransferArguments(dial, snapshot) {
+    const src = dial.arguments;
+    if (!src)
+        return {};
+    const out = {};
+    const sendDigits = interpolatedArg(src.sendDigits, snapshot);
+    if (sendDigits)
+        out.sendDigits = sendDigits;
+    const sipUrl = interpolatedArg(src.sipUrl, snapshot);
+    if (sipUrl)
+        out.sipUrl = sipUrl;
+    const sipUsername = interpolatedArg(src.sipUsername, snapshot);
+    if (sipUsername)
+        out.sipUsername = sipUsername;
+    const sipPassword = interpolatedArg(src.sipPassword, snapshot);
+    if (sipPassword)
+        out.sipPassword = sipPassword;
+    if (src.transferCallerIdShown)
+        out.transferCallerIdShown = src.transferCallerIdShown;
+    return out;
+}
+export function transferArgumentsJson(dial, snapshot) {
+    return JSON.stringify(resolveTransferArguments(dial, snapshot));
+}
+export function validateTransferDestinations(numbers, options) {
+    const issues = [];
+    if (numbers.length === 0) {
+        issues.push({
+            code: options.code,
+            message: 'transfer numbers must not be empty',
+            path: options.path,
+        });
+        return issues;
+    }
+    for (const number of numbers) {
+        if (extractTemplateFields(number).length > 0)
+            continue;
+        if (!isTransferDestinationLiteral(number)) {
+            issues.push({
+                code: options.code,
+                message: `Transfer target must be E.164 or sip/sips URI: ${number}`,
+                path: options.path,
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=transfer-spec.js.map

package/dist/core/stage/types.d.ts

@@ -1,6 +1,7 @@
 import type { TopLevelCondition } from 'json-rules-engine';
 import type { FuncRef } from '../functions/func-ref.js';
 import type { FieldPath } from '../slot/path.js';
+import type { TransferDial, TransferFallbackAction } from './transfer-spec.js';
 export type Channel = 'call' | 'sms' | 'email' | 'webchat';
 /** Nested condition from the engine (`all` members): leaf or `TopLevelCondition`. */
 export type Condition = Extract<TopLevelCondition, {
@@ -40,6 +41,11 @@ export type FirstMessage = {
     kind: 'fn';
     fn: string;
 };
+export type TransferInterruptAction = {
+    type: 'transfer';
+    escalateCriteria?: string[];
+    noEscalationCriteria?: string[];
+} & TransferDial;
 export type Interrupt = {
     id: string;
     label: string;
@@ -47,11 +53,7 @@ export type Interrupt = {
         name: string;
         description: string;
     };
-    action: {
-        type: 'transfer';
-        numbers: string[];
-        mode: 'cold' | 'warm';
-    } | {
+    action: TransferInterruptAction | {
         type: 'switch-language';
         languages: string[];
     };
@@ -86,12 +88,32 @@ export type TransferBlock = {
     kind: 'transfer';
     id: string;
     label: string;
-    numbers: string[];
-    mode: 'cold' | 'warm';
-    say: string;
-    unsuccessfulSay: string | null;
-};
-export type AgendaBlock = TopicBlock | ActionBlock | TransferBlock;
+} & TransferDial;
+export type IvrDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '*' | '#';
+export type IvrFallbackAction = TransferFallbackAction;
+export type DtmfResult = {
+    result: IvrDigit[];
+    value: string;
+};
+export type IvrBlock = {
+    kind: 'ivr';
+    id: string;
+    label: string;
+    onDtmfResult: FuncRef;
+    finishWhen: FinishWhen;
+    fallbackAction: IvrFallbackAction;
+    confirmTimeoutMs: number;
+    pauseAfterSayMs: number;
+    loopSay: string;
+    enterSay: string | null;
+    succeedSay: string | null;
+    unsuccessSay: string | null;
+    finishOnKey?: IvrDigit | null;
+    minDigits?: number | null;
+    maxDigits?: number | null;
+    validateDigits?: IvrDigit[] | null;
+};
+export type AgendaBlock = TopicBlock | ActionBlock | TransferBlock | IvrBlock;
 export type CompiledTopicBlock = Omit<TopicBlock, 'fields' | 'finishWhen'> & {
     fields: FieldPath[];
     finishWhen: CompiledWhen;
@@ -104,7 +126,12 @@ export type CompiledTransferBlock = TransferBlock & {
     finishWhen: CompiledWhen;
     resultField: FieldPath;
 };
-export type CompiledAgendaBlock = CompiledTopicBlock | CompiledActionBlock | CompiledTransferBlock;
+export type CompiledIvrBlock = Omit<IvrBlock, 'onDtmfResult' | 'finishWhen'> & {
+    onDtmfResult: string;
+    finishWhen: CompiledWhen;
+    resultField: FieldPath;
+};
+export type CompiledAgendaBlock = CompiledTopicBlock | CompiledActionBlock | CompiledTransferBlock | CompiledIvrBlock;
 export type SectionPlacement = {
     kind: 'section';
     placementId: string;
@@ -136,7 +163,8 @@ export type FlatNodePlacement = {
 export type FlatTopicItem = CompiledTopicBlock & FlatNodePlacement;
 export type FlatActionItem = CompiledActionBlock & FlatNodePlacement;
 export type FlatTransferItem = CompiledTransferBlock & FlatNodePlacement;
-export type FlatAgendaItem = FlatTopicItem | FlatActionItem | FlatTransferItem;
+export type FlatIvrItem = CompiledIvrBlock & FlatNodePlacement;
+export type FlatAgendaItem = FlatTopicItem | FlatActionItem | FlatTransferItem | FlatIvrItem;
 export type CompiledAgenda = {
     header: AgendaHeader | null;
     flat: FlatAgendaItem[];
@@ -150,6 +178,9 @@ export type ActionNode = ActionBlock & {
 export type TransferNode = TransferBlock & {
     applyWhen: AuthoringWhen;
 };
+export type IvrNode = IvrBlock & {
+    applyWhen: AuthoringWhen;
+};
 export type SectionNode = {
     kind: 'section';
     id: string;
@@ -167,7 +198,7 @@ export type SwitchOnNode = {
     cases: Record<string, AuthoringNode[]>;
     otherwise?: AuthoringNode[];
 };
-export type AuthoringNode = TopicNode | ActionNode | TransferNode | SectionNode | BranchNode | SwitchOnNode;
+export type AuthoringNode = TopicNode | ActionNode | TransferNode | IvrNode | SectionNode | BranchNode | SwitchOnNode;
 export type AgendaTree = {
     kind: 'agenda';
     id: string;

package/dist/core/stage/validate.js

@@ -2,7 +2,9 @@ import { getCompiledTable } from '../slot/compile-schema.js';
 import { parseFieldPath } from '../slot/path.js';
 import { extractTemplateFields } from './condition.js';
 import { whenFields } from './finish-when.js';
+import { headerHasTransferInterrupt, validateInterrupts } from './interrupts.js';
 import { LAST_TRANSFER_RESULT_FIELD } from './transfer-fields.js';
+import { validateTransferDestinations } from './transfer-spec.js';
 function fieldExists(schema, path) {
     const parsed = parseFieldPath(path);
     if (!parsed)
@@ -28,6 +30,10 @@ function earlierCollected(items, index) {
             for (const field of item.fields)
                 collected.add(field);
         }
+        if (item.kind === 'ivr') {
+            for (const field of whenFields(item.finishWhen))
+                collected.add(field);
+        }
     }
     return collected;
 }
@@ -74,6 +80,13 @@ export function validateCompiledAgenda(compiled, options) {
     const seenPlacement = new Set();
     const transferByResult = transferIndexByResultField(items);
     const firstTransfer = firstTransferIndex(items);
+    const transferInterrupt = headerHasTransferInterrupt(compiled.header);
+    if (compiled.header) {
+        issues.push(...validateInterrupts(compiled.header.interrupts, {
+            schema,
+            agendaId: prefix,
+        }));
+    }
     if (compiled.header?.channel && compiled.header.channel !== 'call') {
         for (const item of items) {
             if (item.kind === 'transfer') {
@@ -83,6 +96,13 @@ export function validateCompiledAgenda(compiled, options) {
                     path: `${prefix}/${item.placementId}`,
                 });
             }
+            if (item.kind === 'ivr') {
+                issues.push({
+                    code: 'ivr-channel',
+                    message: `IVR ${item.id} is only valid on call agendas`,
+                    path: `${prefix}/${item.placementId}`,
+                });
+            }
         }
     }
     if (compiled.header?.firstMessage?.kind === 'template') {
@@ -128,7 +148,7 @@ export function validateCompiledAgenda(compiled, options) {
                 continue;
             }
             if (field === LAST_TRANSFER_RESULT_FIELD) {
-                if (firstTransfer < 0 || firstTransfer >= index) {
+                if (!transferInterrupt && (firstTransfer < 0 || firstTransfer >= index)) {
                     issues.push({
                         code: 'transfer-result-before-node',
                         message: `applyWhen reads ${LAST_TRANSFER_RESULT_FIELD} before any transfer`,
@@ -152,6 +172,56 @@ export function validateCompiledAgenda(compiled, options) {
             }
         }
         requireBoolWhen(item.applyWhen, functions, issues, `${path}/applyWhen`, 'applyWhen');
+        if (item.kind === 'ivr') {
+            requireBoolWhen(item.finishWhen, functions, issues, `${path}/finishWhen`, 'finishWhen');
+            if (item.finishWhen.kind === 'rules') {
+                requireFields(schema, whenFields(item.finishWhen), issues, `${path}/finishWhen`);
+            }
+            const run = functions?.[item.onDtmfResult];
+            if (functions && !run) {
+                issues.push({
+                    code: 'unknown-function',
+                    message: `IVR '${item.id}' onDtmfResult unknown function '${item.onDtmfResult}'. Custom functions: ${listedCustomFunctions(functions)}`,
+                    path: `${path}/onDtmfResult`,
+                });
+            }
+            else if (run && run.kind !== 'custom') {
+                issues.push({
+                    code: 'ivr-run-not-custom',
+                    message: `IVR '${item.id}' onDtmfResult '${item.onDtmfResult}' must be defineCustomFunc`,
+                    path: `${path}/onDtmfResult`,
+                });
+            }
+            if (!item.loopSay.trim()) {
+                issues.push({
+                    code: 'ivr-say-empty',
+                    message: 'ivr loopSay must not be empty',
+                    path: `${path}/loopSay`,
+                });
+            }
+            if (!(item.confirmTimeoutMs > 0) || !(item.pauseAfterSayMs >= 0)) {
+                issues.push({
+                    code: 'ivr-timing',
+                    message: 'ivr confirmTimeoutMs must be > 0 and pauseAfterSayMs must be >= 0',
+                    path: `${path}/timing`,
+                });
+            }
+            if (item.fallbackAction !== 'end-call' && item.fallbackAction !== 'restore-normal-call-state') {
+                issues.push({
+                    code: 'ivr-fallback',
+                    message: 'ivr fallbackAction must be end-call or restore-normal-call-state',
+                    path: `${path}/fallbackAction`,
+                });
+            }
+            const digits = (item.validateDigits ?? []).map((digit) => digit.trim()).filter(Boolean);
+            if (!item.finishOnKey && digits.length === 0) {
+                issues.push({
+                    code: 'ivr-digits-empty',
+                    message: 'ivr needs validateDigits when finishOnKey is not set',
+                    path: `${path}/validateDigits`,
+                });
+            }
+        }
         if (item.kind === 'topic') {
             requireFields(schema, item.fields, issues, `${path}/fields`);
             const referenced = whenFields(item.finishWhen);
@@ -194,6 +264,26 @@ export function validateCompiledAgenda(compiled, options) {
             for (const number of item.numbers) {
                 requireFields(schema, extractTemplateFields(number), issues, `${path}/numbers`);
             }
+            if (item.arguments) {
+                for (const key of ['sendDigits', 'sipUrl', 'sipUsername', 'sipPassword']) {
+                    const text = item.arguments[key];
+                    if (text) {
+                        requireFields(schema, extractTemplateFields(text), issues, `${path}/arguments/${key}`);
+                    }
+                }
+            }
+            if (typeof item.say === 'string') {
+                requireFields(schema, extractTemplateFields(item.say), issues, `${path}/say`);
+            }
+            else if (item.say) {
+                for (const text of Object.values(item.say)) {
+                    requireFields(schema, extractTemplateFields(text), issues, `${path}/say`);
+                }
+            }
+            issues.push(...validateTransferDestinations(item.numbers, {
+                path: `${path}/numbers`,
+                code: 'transfer-target',
+            }));
             requireFields(schema, [item.resultField, LAST_TRANSFER_RESULT_FIELD], issues, `${path}/result`);
         }
     }
@@ -215,10 +305,24 @@ const FATAL_AGENDA_CODES = new Set([
     'branch-no-explicit',
     'otherwise-unexpanded',
     'transfer-channel',
+    'ivr-channel',
+    'ivr-run-not-custom',
+    'ivr-fallback',
+    'ivr-timing',
+    'ivr-say-empty',
+    'ivr-digits-empty',
     'transfer-result-before-node',
     'action-run-not-custom',
     'duplicate-placement',
     'block-kind-mismatch',
+    'interrupt-tool-reserved',
+    'interrupt-tool-duplicate',
+    'interrupt-priority-tie',
+    'interrupt-languages-empty',
+    'interrupt-language-field',
+    'interrupt-transfer-number',
+    'interrupt-escalation-criteria',
+    'transfer-target',
 ]);
 export function fatalAgendaIssues(issues) {
     return issues.filter((issue) => FATAL_AGENDA_CODES.has(issue.code));

package/dist/core/stage/walk.d.ts

@@ -9,11 +9,16 @@ export type WalkSkip = {
     reason: WalkSkipReason;
 };
 export type WalkHitReason = 'sticky' | 'scan';
+export type WalkStats = {
+    durationMs: number;
+    evals: number;
+};
 export type WalkResult = {
     hit: FlatAgendaItem | null;
     reason: WalkHitReason | 'complete';
     skipped: WalkSkip[];
     decisions: WalkDecision[];
+    stats: WalkStats;
 };
 export type WalkDecision = {
     placementId: string;