@superpanel-sdk/runtime 0.2.2 → 0.5.0

package/dist/core/stage/index.js

@@ -1,10 +0,0 @@
-export { collectJsonRulesFacts, evaluateJsonRules, extractTemplateFields, isOtherwise, jsonRules, looksLikeJsonRules, normalizeJsonRules, otherwise, parseJsonRules, } from './condition.js';
-export { andCompiledWhen, compileAuthoringWhen, compileFinishWhen, compileWhen, evaluateFinishWhen, evaluateWhen, finishWhenFields, notAnyWhen, whenFields, } from './finish-when.js';
-export { action, agenda, branch, section, switchOn, topic, transfer } from './builders.js';
-export { extractBlocksFromTree, flattenAgendaConfig, flattenAgendaPlacements, flattenAgendaTree, isAgendaTree, isSequenceAgendas, normalizeSequenceAgendas, treeToPlacements, } from './flatten.js';
-export { LAST_TRANSFER_RESULT_FIELD, collectTransferBlocks, registerTransferSessionFields, transferFieldKey, transferResultField, } from './transfer-fields.js';
-export { fatalAgendaIssues, validateCompiledAgenda } from './validate.js';
-export { unresolvedFinishWhenFields, walkAgenda, } from './walk.js';
-export { simulateAgenda } from './simulate.js';
-export { DEFAULT_MAX_ACTIONS_PER_TURN, advanceAgenda, driveAgenda, transferWrites, watchdogHint, } from './drive.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,24 +0,0 @@
-import type { ComputeHost } from '../../compute-host/compute-host.js';
-import type { RuntimeSlotsSnapshot } from '../slot/types.js';
-import { type WalkResult } from './walk.js';
-import type { FlatAgendaItem } from './types.js';
-export type SimulatedItemStatus = 'folded' | 'done' | 'selected' | 'open';
-export type SimulatedItem = {
-    placementId: string;
-    blockId: string;
-    kind: FlatAgendaItem['kind'];
-    groupPath: string[];
-    status: SimulatedItemStatus;
-    applyWhen: boolean;
-    finishWhen: boolean | null;
-};
-export type SimulateResult = {
-    selected: FlatAgendaItem | null;
-    walk: WalkResult;
-    items: SimulatedItem[];
-};
-export declare function simulateAgenda(items: FlatAgendaItem[], snapshot: RuntimeSlotsSnapshot, options?: {
-    currentPlacementId?: string | null;
-    compute?: ComputeHost;
-}): Promise<SimulateResult>;
-//# sourceMappingURL=simulate.d.ts.map

package/dist/core/stage/simulate.js

@@ -1,33 +0,0 @@
-import { evaluateWhen } from './finish-when.js';
-import { walkAgenda } from './walk.js';
-export async function simulateAgenda(items, snapshot, options = {}) {
-    const walk = await walkAgenda(items, snapshot, {
-        currentPlacementId: options.currentPlacementId,
-        compute: options.compute,
-    });
-    const simulated = [];
-    for (const item of items) {
-        const applies = (await evaluateWhen(item.applyWhen, snapshot, options.compute)).pass;
-        const finished = applies ? (await evaluateWhen(item.finishWhen, snapshot, options.compute)).done : null;
-        let status;
-        if (!applies)
-            status = 'folded';
-        else if (finished)
-            status = 'done';
-        else if (walk.hit?.placementId === item.placementId)
-            status = 'selected';
-        else
-            status = 'open';
-        simulated.push({
-            placementId: item.placementId,
-            blockId: item.id,
-            kind: item.kind,
-            groupPath: item.groupPath,
-            status,
-            applyWhen: applies,
-            finishWhen: finished,
-        });
-    }
-    return { selected: walk.hit, walk, items: simulated };
-}
-//# sourceMappingURL=simulate.js.map

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

@@ -1,14 +0,0 @@
-import type { FieldPath } from '../slot/path.js';
-import type { CompiledSlotSchema } from '../slot/types.js';
-import type { AgendaBlock, AuthoringNode, TransferBlock } from './types.js';
-/** Sanitize a transfer node id into a session field fragment. */
-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 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;
-//# sourceMappingURL=transfer-fields.d.ts.map

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

@@ -1,88 +0,0 @@
-import { idField } from '../slot/schema.js';
-import { getCompiledTable } from '../slot/compile-schema.js';
-import { formatFieldPath } from '../slot/path.js';
-const RESULT_ENUM = ['connected', 'failed'];
-function transferFieldCore(label) {
-    return {
-        derived: false,
-        label,
-        dataType: 'string',
-        source: 'system',
-        extraction: 'Platform transfer result',
-        enum: [...RESULT_ENUM],
-        nullable: true,
-        identifier: null,
-        ref: null,
-    };
-}
-/** Sanitize a transfer node id into a session field fragment. */
-export function transferFieldKey(nodeId) {
-    const cleaned = nodeId.replace(/[^A-Za-z0-9_]/g, '_');
-    return cleaned.length > 0 ? cleaned : 'node';
-}
-export function transferResultField(nodeId) {
-    return formatFieldPath('session', `transfer_${transferFieldKey(nodeId)}_result`);
-}
-export const LAST_TRANSFER_RESULT_FIELD = formatFieldPath('session', 'last_transfer_result');
-export function collectTransferBlocks(blocks, nodes = []) {
-    const out = [];
-    const seen = new Set();
-    for (const block of Object.values(blocks)) {
-        if (block.kind === 'transfer' && !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 === 'transfer' && !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);
-            }
-        }
-    }
-}
-/**
- * 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) {
-    const ids = [...new Set(transferIds)];
-    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 = `transfer_${transferFieldKey(id)}_result`;
-        if (!fields[name]) {
-            fields[name] = transferFieldCore(`Transfer ${id} result`);
-        }
-    }
-    if (!fields.last_transfer_result) {
-        fields.last_transfer_result = transferFieldCore('Last transfer result');
-    }
-    const nextSession = {
-        ...session,
-        fields,
-    };
-    return {
-        ...schema,
-        session: nextSession,
-    };
-}
-//# sourceMappingURL=transfer-fields.js.map

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

@@ -1,177 +0,0 @@
-import type { TopLevelCondition } from 'json-rules-engine';
-import type { FuncRef } from '../functions/func-ref.js';
-import type { FieldPath } from '../slot/path.js';
-export type Channel = 'call' | 'sms' | 'email' | 'webchat';
-/** Nested condition from the engine (`all` members): leaf or `TopLevelCondition`. */
-export type Condition = Extract<TopLevelCondition, {
-    all: unknown;
-}>['all'][number];
-export type JsonRulesCondition = Condition;
-/**
- * Shared by applyWhen and finishWhen:
- * json-rules object, JSON string, boolFunction, or null (always).
- */
-export type When = FuncRef | Condition | Condition[] | null;
-export type ApplyWhen = When;
-export type FinishWhen = When;
-/** Compile-time sentinel for branch()/switchOn(); expanded before flatten. */
-export type OtherwiseSentinel = {
-    op: 'otherwise';
-    notAny?: When[];
-};
-export type AuthoringWhen = When | OtherwiseSentinel;
-export type CompiledWhen = {
-    kind: 'always';
-} | {
-    kind: 'fn';
-    fn: string;
-} | {
-    kind: 'rules';
-    condition: JsonRulesCondition;
-};
-export type OnNoProgress = {
-    maxTurns: number;
-    action: 'move-on' | 'handoff' | 'schedule-callback';
-};
-export type FirstMessage = {
-    kind: 'template';
-    text: string;
-} | {
-    kind: 'fn';
-    fn: string;
-};
-export type Interrupt = {
-    id: string;
-    label: string;
-    tool: {
-        name: string;
-        description: string;
-    };
-    action: {
-        type: 'transfer';
-        numbers: string[];
-        mode: 'cold' | 'warm';
-    } | {
-        type: 'switch-language';
-        languages: string[];
-    };
-    priority: number;
-};
-export type AgendaHeader = {
-    channel: Channel;
-    systemPrompt: string | null;
-    firstMessage: FirstMessage | null;
-    firstMessageMode: 'assistant-speaks-first' | 'user-speaks-first' | null;
-    voicemailPrompt: string | null;
-    interrupts: Interrupt[];
-};
-export type TopicBlock = {
-    kind: 'topic';
-    id: string;
-    label: string;
-    instructions: string;
-    fields: FieldPath[] | null;
-    finishWhen: FinishWhen;
-    onNoProgress: OnNoProgress | null;
-};
-export type ActionBlock = {
-    kind: 'action';
-    id: string;
-    label: string;
-    run: FuncRef;
-    finishWhen: FinishWhen;
-    say: string | null;
-};
-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;
-export type CompiledTopicBlock = Omit<TopicBlock, 'fields' | 'finishWhen'> & {
-    fields: FieldPath[];
-    finishWhen: CompiledWhen;
-};
-export type CompiledActionBlock = Omit<ActionBlock, 'run' | 'finishWhen'> & {
-    run: string;
-    finishWhen: CompiledWhen;
-};
-export type CompiledTransferBlock = TransferBlock & {
-    finishWhen: CompiledWhen;
-    resultField: FieldPath;
-};
-export type CompiledAgendaBlock = CompiledTopicBlock | CompiledActionBlock | CompiledTransferBlock;
-export type SectionPlacement = {
-    kind: 'section';
-    placementId: string;
-    label: string;
-    applyWhen: AuthoringWhen;
-    children: Placement[];
-};
-export type NodePlacement = {
-    kind: 'node';
-    placementId: string;
-    blockId: string;
-    applyWhen: AuthoringWhen;
-};
-export type Placement = SectionPlacement | NodePlacement;
-export type AgendaConfig = {
-    id: string;
-    header: AgendaHeader | null;
-    placements: Placement[];
-};
-export type SequenceAgendas = {
-    blocks: Record<string, AgendaBlock>;
-    agendas: Record<string, AgendaConfig>;
-};
-export type FlatNodePlacement = {
-    placementId: string;
-    applyWhen: CompiledWhen;
-    groupPath: string[];
-};
-export type FlatTopicItem = CompiledTopicBlock & FlatNodePlacement;
-export type FlatActionItem = CompiledActionBlock & FlatNodePlacement;
-export type FlatTransferItem = CompiledTransferBlock & FlatNodePlacement;
-export type FlatAgendaItem = FlatTopicItem | FlatActionItem | FlatTransferItem;
-export type CompiledAgenda = {
-    header: AgendaHeader | null;
-    flat: FlatAgendaItem[];
-};
-export type TopicNode = TopicBlock & {
-    applyWhen: AuthoringWhen;
-};
-export type ActionNode = ActionBlock & {
-    applyWhen: AuthoringWhen;
-};
-export type TransferNode = TransferBlock & {
-    applyWhen: AuthoringWhen;
-};
-export type SectionNode = {
-    kind: 'section';
-    id: string;
-    label: string;
-    applyWhen: AuthoringWhen;
-    children: AuthoringNode[];
-};
-export type BranchNode = {
-    kind: 'branch';
-    children: AuthoringNode[];
-};
-export type SwitchOnNode = {
-    kind: 'switchOn';
-    field: FieldPath;
-    cases: Record<string, AuthoringNode[]>;
-    otherwise?: AuthoringNode[];
-};
-export type AuthoringNode = TopicNode | ActionNode | TransferNode | SectionNode | BranchNode | SwitchOnNode;
-export type AgendaTree = {
-    kind: 'agenda';
-    id: string;
-    header: AgendaHeader | null;
-    tree: AuthoringNode[];
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/core/stage/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

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

@@ -1,11 +0,0 @@
-import type { FuncMap } from '../functions/types.js';
-import type { CompiledSlotSchema, ValidationIssue, ValidationResult } from '../slot/types.js';
-import type { CompiledAgenda } from './types.js';
-export type ValidateAgendaOptions = {
-    schema: CompiledSlotSchema;
-    functions?: FuncMap;
-    agendaId?: string;
-};
-export declare function validateCompiledAgenda(compiled: CompiledAgenda, options: ValidateAgendaOptions): ValidationResult;
-export declare function fatalAgendaIssues(issues: ValidationIssue[]): ValidationIssue[];
-//# sourceMappingURL=validate.d.ts.map

package/dist/core/stage/validate.js

@@ -1,226 +0,0 @@
-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 { LAST_TRANSFER_RESULT_FIELD } from './transfer-fields.js';
-function fieldExists(schema, path) {
-    const parsed = parseFieldPath(path);
-    if (!parsed)
-        return false;
-    return getCompiledTable(schema, parsed.table)?.fields[parsed.field] != null;
-}
-function requireFields(schema, fields, issues, path, code = 'unknown-field') {
-    for (const field of fields) {
-        if (!parseFieldPath(field)) {
-            issues.push({ code: 'invalid-field-path', message: `Invalid field path: ${field}`, path: `${path}:${field}` });
-            continue;
-        }
-        if (!fieldExists(schema, field)) {
-            issues.push({ code, message: `Unknown field: ${field}`, path: `${path}:${field}` });
-        }
-    }
-}
-function earlierCollected(items, index) {
-    const collected = new Set();
-    for (let i = 0; i < index; i++) {
-        const item = items[i];
-        if (item.kind === 'topic') {
-            for (const field of item.fields)
-                collected.add(field);
-        }
-    }
-    return collected;
-}
-function transferIndexByResultField(items) {
-    const map = new Map();
-    items.forEach((item, index) => {
-        if (item.kind === 'transfer') {
-            map.set(item.resultField, index);
-        }
-    });
-    return map;
-}
-function listedCustomFunctions(functions) {
-    const names = Object.entries(functions)
-        .filter(([, def]) => def.kind === 'custom')
-        .map(([name]) => name)
-        .sort((a, b) => a.localeCompare(b));
-    return names.length > 0 ? names.join(', ') : 'none';
-}
-function requireBoolWhen(when, functions, issues, path, label) {
-    if (when.kind === 'fn') {
-        const def = functions?.[when.fn];
-        if (functions && !def) {
-            issues.push({ code: 'unknown-function', message: `${label} fn not found: ${when.fn}`, path });
-        }
-        else if (def && def.kind !== 'boolCompute') {
-            issues.push({
-                code: label === 'applyWhen' ? 'apply-when-not-bool' : 'finish-when-not-bool',
-                message: `${label} fn '${when.fn}' must be defineBoolComputeFunc`,
-                path,
-            });
-        }
-        return;
-    }
-}
-function firstTransferIndex(items) {
-    return items.findIndex((item) => item.kind === 'transfer');
-}
-export function validateCompiledAgenda(compiled, options) {
-    const issues = [];
-    const { schema, functions } = options;
-    const prefix = options.agendaId ?? 'agenda';
-    const items = compiled.flat;
-    const seenPlacement = new Set();
-    const transferByResult = transferIndexByResultField(items);
-    const firstTransfer = firstTransferIndex(items);
-    if (compiled.header?.channel && compiled.header.channel !== 'call') {
-        for (const item of items) {
-            if (item.kind === 'transfer') {
-                issues.push({
-                    code: 'transfer-channel',
-                    message: `Transfer ${item.id} is only valid on call agendas`,
-                    path: `${prefix}/${item.placementId}`,
-                });
-            }
-        }
-    }
-    if (compiled.header?.firstMessage?.kind === 'template') {
-        requireFields(schema, extractTemplateFields(compiled.header.firstMessage.text), issues, `${prefix}/header/firstMessage`);
-    }
-    if (compiled.header?.firstMessage?.kind === 'fn') {
-        const name = compiled.header.firstMessage.fn;
-        const def = functions?.[name];
-        if (functions && !def) {
-            issues.push({
-                code: 'unknown-function',
-                message: `firstMessage fn not found: ${name}`,
-                path: `${prefix}/header/firstMessage`,
-            });
-        }
-        else if (def && def.kind !== 'system') {
-            issues.push({
-                code: 'invalid-function-kind',
-                message: `firstMessage fn must be a system function: ${name}`,
-                path: `${prefix}/header/firstMessage`,
-            });
-        }
-    }
-    for (let index = 0; index < items.length; index++) {
-        const item = items[index];
-        const path = `${prefix}/${item.placementId}`;
-        if (seenPlacement.has(item.placementId)) {
-            issues.push({ code: 'duplicate-placement', message: `Duplicate placementId: ${item.placementId}`, path });
-        }
-        seenPlacement.add(item.placementId);
-        requireFields(schema, whenFields(item.applyWhen), issues, `${path}/applyWhen`);
-        const collected = earlierCollected(items, index);
-        for (const field of whenFields(item.applyWhen)) {
-            if (field.startsWith('session.transfer_') && field.endsWith('_result')) {
-                const writer = transferByResult.get(field);
-                if (writer == null || writer >= index) {
-                    issues.push({
-                        code: 'transfer-result-before-node',
-                        message: `applyWhen reads ${field} before the transfer node`,
-                        path: `${path}/applyWhen`,
-                    });
-                }
-                continue;
-            }
-            if (field === LAST_TRANSFER_RESULT_FIELD) {
-                if (firstTransfer < 0 || firstTransfer >= index) {
-                    issues.push({
-                        code: 'transfer-result-before-node',
-                        message: `applyWhen reads ${LAST_TRANSFER_RESULT_FIELD} before any transfer`,
-                        path: `${path}/applyWhen`,
-                    });
-                }
-                continue;
-            }
-            const parsed = parseFieldPath(field);
-            const def = parsed ? getCompiledTable(schema, parsed.table)?.fields[parsed.field] : undefined;
-            if (def?.derived)
-                continue;
-            if (def && !def.derived && def.source === 'system')
-                continue;
-            if (!collected.has(field)) {
-                issues.push({
-                    code: 'fork-field-not-collected',
-                    message: `applyWhen field ${field} is not collected by an earlier topic`,
-                    path: `${path}/applyWhen`,
-                });
-            }
-        }
-        requireBoolWhen(item.applyWhen, functions, issues, `${path}/applyWhen`, 'applyWhen');
-        if (item.kind === 'topic') {
-            requireFields(schema, item.fields, issues, `${path}/fields`);
-            const referenced = whenFields(item.finishWhen);
-            requireFields(schema, referenced, issues, `${path}/finishWhen`);
-            requireBoolWhen(item.finishWhen, functions, issues, `${path}/finishWhen`, 'finishWhen');
-            if (item.finishWhen.kind !== 'fn') {
-                for (const field of referenced) {
-                    if (!item.fields.includes(field)) {
-                        issues.push({
-                            code: 'finish-when-not-in-fields',
-                            message: `finishWhen field ${field} is not in topic fields`,
-                            path: `${path}/finishWhen`,
-                        });
-                    }
-                }
-            }
-        }
-        if (item.kind === 'action') {
-            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.run];
-            if (functions && !run) {
-                issues.push({
-                    code: 'unknown-function',
-                    message: `Action '${item.id}' runs unknown function '${item.run}'. Custom functions: ${listedCustomFunctions(functions)}`,
-                    path: `${path}/run`,
-                });
-            }
-            else if (run && run.kind !== 'custom') {
-                issues.push({
-                    code: 'action-run-not-custom',
-                    message: `Action '${item.id}' runs '${item.run}', which is ${run.kind}. Actions must use defineCustomFunc.`,
-                    path: `${path}/run`,
-                });
-            }
-        }
-        if (item.kind === 'transfer') {
-            for (const number of item.numbers) {
-                requireFields(schema, extractTemplateFields(number), issues, `${path}/numbers`);
-            }
-            requireFields(schema, [item.resultField, LAST_TRANSFER_RESULT_FIELD], issues, `${path}/result`);
-        }
-    }
-    return issues.length === 0 ? { ok: true } : { ok: false, issues };
-}
-const FATAL_AGENDA_CODES = new Set([
-    'unknown-block',
-    'unknown-field',
-    'invalid-field-path',
-    'invalid-finish-when',
-    'unknown-function',
-    'finish-when-not-bool',
-    'apply-when-not-bool',
-    'invalid-apply-when',
-    'finish-when-not-in-fields',
-    'fork-field-not-collected',
-    'otherwise-not-unique',
-    'otherwise-not-last',
-    'branch-no-explicit',
-    'otherwise-unexpanded',
-    'transfer-channel',
-    'transfer-result-before-node',
-    'action-run-not-custom',
-    'duplicate-placement',
-    'block-kind-mismatch',
-]);
-export function fatalAgendaIssues(issues) {
-    return issues.filter((issue) => FATAL_AGENDA_CODES.has(issue.code));
-}
-//# sourceMappingURL=validate.js.map

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

@@ -1,34 +0,0 @@
-import type { ComputeHost } from '../../compute-host/compute-host.js';
-import type { FieldPath } from '../slot/path.js';
-import type { RuntimeSlotsSnapshot } from '../slot/types.js';
-import type { FlatAgendaItem } from './types.js';
-export type WalkSkipReason = 'folded' | 'done' | 'skipped';
-export type WalkSkip = {
-    placementId: string;
-    blockId: string;
-    reason: WalkSkipReason;
-};
-export type WalkHitReason = 'sticky' | 'scan';
-export type WalkResult = {
-    hit: FlatAgendaItem | null;
-    reason: WalkHitReason | 'complete';
-    skipped: WalkSkip[];
-    decisions: WalkDecision[];
-};
-export type WalkDecision = {
-    placementId: string;
-    blockId: string;
-    status: 'folded' | 'done' | 'hit' | 'skipped';
-    via: WalkHitReason;
-    applyWhen: boolean | null;
-    finishWhen: boolean | null;
-};
-export type WalkOptions = {
-    currentPlacementId?: string | null;
-    /** This-tick skips (action returned null). */
-    skipPlacementIds?: ReadonlySet<string>;
-    compute?: ComputeHost;
-};
-export declare function walkAgenda(items: FlatAgendaItem[], snapshot: RuntimeSlotsSnapshot, options?: WalkOptions): Promise<WalkResult>;
-export declare function unresolvedFinishWhenFields(item: FlatAgendaItem, snapshot: RuntimeSlotsSnapshot, compute?: ComputeHost): Promise<FieldPath[]>;
-//# sourceMappingURL=walk.d.ts.map