@superpanel-sdk/runtime 0.5.0 → 0.7.0

package/dist/testing.js

@@ -0,0 +1,439 @@
+/**
+ * Test helpers for a company repository's unit tests (`sequences/<id>/tests/*.test.ts`): a fake `ctx`,
+ * a `db` that records its calls, a `fetch` that answers from routes, and the page rendered from rows the
+ * test gives. Everything runs in process: no server, no network, no model, nothing written.
+ *
+ * Only test files import this entry. The compile loads a repository from its entries, which never reach
+ * a test file, and refuses `@superpanel-sdk/runtime/testing` in any file it does load
+ * (`builder/company-imports.ts`).
+ */
+import { fork } from 'node:child_process';
+import { appendFileSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { after, afterEach, beforeEach } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { CONTEXT_PAGE_FUNCTION, functionKey, functionScriptFile } from './builder/types.js';
+import { apiUrl } from './cli/auth/http.js';
+import { openExecSession } from './cli/exec/session.js';
+import { openLogReader } from './cli/logs/index.js';
+import { openOverlay } from './cli/serve/index.js';
+import { openTextCall, testCustomer, testCustomerPhone } from './cli/calls/index.js';
+import { channelOf, readTurnExport, writeTurnExport } from './cli/turns/index.js';
+import { checkPageStart, emptyRuns } from './core/page/define.js';
+import { createMemoryReader } from './core/page/memory-reader.js';
+import { atCall, dayCall, partsCall, timeCall, timeOfCaller } from './core/page/page-host.js';
+import { renderDocument, RowNames } from './core/page/render.js';
+import { runInSandbox } from './core/page/sandbox.js';
+import { workspaceText } from './core/page/workspace.js';
+import { parseOfficeHours, resolveOfficeHours } from './core/office-hours/index.js';
+import { makeCaseOrchestratorCtx as makePlatformCaseOrchestratorCtx, makeCtx as makePlatformCtx } from './fn-context/make-ctx.js';
+import { shadowTurn } from './cli/turns/shadow.js';
+import { casesIn, writeDebugPackage } from './cli/debug/index.js';
+export { fakeTools, unfaked } from './fn-context/fake/index.js';
+/**
+ * A fake `ctx`, typed as the caller asks: `makeCtx<Ctx>()` for a function, with `Ctx` from the
+ * sequence's `__gen`. Data slice defaults: `today` 1970-01-01, `timezone` UTC. Any `api` call the test
+ * did not fake rejects, naming the call.
+ */
+export function makeCtx(overrides = {}) {
+    return makePlatformCtx(overrides);
+}
+/** A fake Orchestrator `ctx`, typed as the caller asks; `tools` fakes `ctx.api.tools`, `db` fakes `ctx.api.db`. */
+export async function makeCaseOrchestratorCtx(overrides = {}) {
+    return (await makePlatformCaseOrchestratorCtx(overrides));
+}
+/**
+ * A `db` that records every call in `calls`, in order, and answers from `handlers`. A call with no
+ * handler rejects, naming it, so a test sees every read and write the function makes.
+ */
+export function recordingDb(handlers = {}) {
+    const calls = [];
+    const db = new Proxy({}, {
+        get: (_, table) => new Proxy({}, {
+            get: (__, method) => async (args) => {
+                calls.push({ table: String(table), method: String(method), args });
+                const handler = handlers[String(table)]?.[String(method)];
+                if (!handler)
+                    throw new Error(`recordingDb: db.${String(table)}.${String(method)} has no handler`);
+                return handler(args);
+            },
+        }),
+    });
+    return { db, calls };
+}
+/**
+ * A row as `ctx.api.db` hands it out, for a `recordingDb` handler to return: `id` as given, every other
+ * field a slot (`{ value, state, reason, updatedAt, ref }`), `filled` when it has a value, `empty` when
+ * null. A test that returns plain values instead (`{ crm_id: null }`) checks code against a shape the
+ * platform never gives: `if (row.crm_id)` is then false in the test and always true for real.
+ */
+export function row(table, values) {
+    const out = { id: values.id };
+    for (const [field, value] of Object.entries(values)) {
+        if (field === 'id')
+            continue;
+        if (field === 'createdAt' || field === 'updatedAt') {
+            out[field] = value;
+            continue;
+        }
+        const empty = value === null || value === undefined;
+        out[field] = { value: empty ? null : value, state: empty ? 'empty' : 'filled', reason: null, updatedAt: null, ref: { table, id: values.id, field } };
+    }
+    return out;
+}
+/**
+ * Replaces the global `fetch` until `restore()`: each request goes to the first matching route; one
+ * that matches none rejects, so a test never reaches a real system (a CRM, a payment provider).
+ */
+export function mockFetch(routes) {
+    const original = globalThis.fetch;
+    const calls = [];
+    globalThis.fetch = async (input, init) => {
+        const request = new Request(input, init);
+        const body = request.body ? await request.clone().text() : null;
+        calls.push({ method: request.method, url: request.url, body });
+        const route = routes.find((r) => (!r.method || r.method.toUpperCase() === request.method) &&
+            (typeof r.url === 'string' ? r.url === request.url : r.url.test(request.url)));
+        if (!route)
+            throw new Error(`mockFetch: no route for ${request.method} ${request.url}`);
+        const answer = await route.respond(request);
+        if (answer instanceof Response)
+            return answer;
+        return new Response(JSON.stringify(answer), { status: 200, headers: { 'content-type': 'application/json' } });
+    };
+    return {
+        calls,
+        restore: () => {
+            globalThis.fetch = original;
+        },
+    };
+}
+/** A page script that failed: what the sandbox said, and where in the compiled page it threw. */
+export class PageTestError extends Error {
+    scriptStack;
+    constructor(message, scriptStack) {
+        super(message);
+        this.scriptStack = scriptStack;
+        this.name = 'PageTestError';
+        if (scriptStack)
+            this.stack = `${this.name}: ${message}\n${scriptStack}`;
+    }
+}
+/**
+ * Renders the sequence's page (`context.page.ts`) over `data`, as the platform renders it: the same
+ * compile, sandbox, `db` semantics and page building, with the rows read from `data` instead of the
+ * database. A read the platform refuses is refused here too.
+ */
+export async function renderPage(input) {
+    return runTestPage(input, 'render', (value, reader, schema, build, out) => {
+        const page = renderDocument({
+            document: value,
+            schema,
+            reads: { row: (id) => reader.rowInfo(id), parentsOf: (table) => reader.parentsOf(table) },
+            names: new RowNames(),
+            ...(input.channel ? { channel: input.channel } : {}),
+            ...(build.contextPage.functions ? { functions: build.contextPage.functions } : {}),
+            ...(build.contextPage.actions ? { actions: build.contextPage.actions } : {}),
+        });
+        return { page, text: page.auto ? '' : workspaceText(page), reads: reader.calls, console: out };
+    });
+}
+/**
+ * A turn's export (`turns export <turnId>`, `exportTurn`) as `renderPage`'s input: the moment the turn
+ * began — its rows, its `ctx`, and each `ctx.history` answer — to render with this repository's code now.
+ */
+export function fromTurn(dir, options = {}) {
+    const { turn, snapshot } = readTurnExport(path.resolve(options.repoRoot ?? process.cwd(), dir));
+    if (!snapshot?.context)
+        throw new Error(`${dir}: the turn's snapshot is not there (it is kept 30 days): only turn.json`);
+    const c = snapshot.context;
+    const caller = c.caller?.id;
+    return {
+        sequence: turn.sequence,
+        ...(options.repoRoot ? { repoRoot: options.repoRoot } : {}),
+        data: snapshot.data,
+        subject: String(c.subject ?? ''),
+        caller: typeof caller === 'string' ? caller : null,
+        channel: c.channel ?? channelOf(turn),
+        ...(c.now ? { now: c.now } : {}),
+        scheduledAction: c.scheduledAction ?? null,
+        officeHours: c.officeHours ?? null,
+        nextSteps: c.nextSteps ?? [],
+        ...(c.sms ? { sms: c.sms } : {}),
+        ...(c.email ? { email: c.email } : {}),
+        ...(c.call ? { call: c.call } : {}),
+        history: c.history ?? [],
+        session: c.session ?? null,
+        ...(c.runs ? { runs: c.runs } : {}),
+        conversation: c.conversation ?? null,
+        ...(c.instanceId ? { instanceId: c.instanceId } : {}),
+    };
+}
+/** What the page decides when the conversation starts (its `persona` and `faq`), over `data`. */
+export async function startPage(input) {
+    return runTestPage(input, 'start', (value) => checkPageStart(value));
+}
+const builds = new Map();
+/**
+ * The sequence compiled once per test process (the compile type-checks the repository), in a child
+ * process (`testing-compile-child.ts`): the company's code it loads stays out of the test's process and
+ * its coverage, which then counts only what the tests ran.
+ */
+function compiled(repoRoot, sequence) {
+    const key = `${repoRoot}\u0000${sequence}`;
+    let hit = builds.get(key);
+    if (!hit) {
+        hit = compileInChild(repoRoot, sequence);
+        builds.set(key, hit);
+        hit.catch(() => builds.delete(key));
+    }
+    return hit;
+}
+function compileInChild(repoRoot, sequence) {
+    const child = fileURLToPath(new URL('./testing-compile-child.js', import.meta.url));
+    const { NODE_V8_COVERAGE: _coverage, ...env } = process.env;
+    return new Promise((resolve, reject) => {
+        // `.js` next to this file when built; the runtime's own tests run the `.ts` source through tsx.
+        const script = existsSync(child) ? child : child.replace(/\.js$/, '.ts');
+        const proc = fork(script, [repoRoot, sequence], { env, execArgv: script.endsWith('.ts') ? ['--import', 'tsx'] : [], stdio: ['ignore', 'ignore', 'pipe', 'ipc'] });
+        let stderr = '';
+        let answered = false;
+        proc.stderr?.on('data', (chunk) => (stderr += String(chunk)));
+        proc.on('message', (message) => {
+            answered = true;
+            if (message.ok)
+                resolve({ build: message.build, schema: message.schema });
+            else
+                reject(new Error(message.error));
+            proc.kill();
+        });
+        proc.on('exit', (code) => {
+            if (!answered)
+                reject(new Error(`compiling sequences/${sequence} failed (exit ${code})${stderr ? `: ${stderr.trim()}` : ''}`));
+        });
+    });
+}
+async function runTestPage(input, mode, done) {
+    const repoRoot = path.resolve(input.repoRoot ?? process.cwd());
+    const { build, schema } = await compiled(repoRoot, input.sequence);
+    const now = new Date(input.now ?? '2026-01-01T15:00:00.000Z');
+    const reader = createMemoryReader({ schema, rows: input.data, now: now.getTime() });
+    const caller = input.caller ? reader.row('contact', input.caller) : null;
+    if (input.caller && !caller)
+        throw new Error(`renderPage: caller ${input.caller} is not in data.contact`);
+    const arg = {
+        mode,
+        channel: input.channel ?? null,
+        subject: input.subject,
+        instanceId: input.instanceId ?? 'test-instance',
+        caller: caller,
+        session: input.session ?? null,
+        conversation: input.conversation ?? null,
+        runs: input.runs ?? emptyRuns(),
+        scheduledAction: input.scheduledAction ?? null,
+        officeHours: input.officeHours ?? null,
+        nextSteps: input.nextSteps ?? [],
+        now: now.toISOString(),
+        time: timeOfCaller(caller, now),
+        env: input.env ?? {},
+        ...(input.sms ? { sms: input.sms } : {}),
+        ...(input.email ? { email: input.email } : {}),
+        ...(input.channel === 'call' ? { call: { previous: null, farEnd: null, phase: 'live', ...input.call } } : {}),
+    };
+    const out = [];
+    const history = input.history ?? {};
+    const answers = Array.isArray(history) ? history : null;
+    const counts = Array.isArray(history) ? {} : history;
+    const dispatch = async (calls) => {
+        const reads = [];
+        const results = calls.map((call, index) => {
+            if (call.fn === 'time')
+                return timeCall(call.args);
+            if (call.fn === 'day')
+                return dayCall(call.args);
+            if (call.fn === 'at')
+                return atCall(call.args);
+            if (call.fn === 'parts')
+                return partsCall(call.args);
+            if (call.fn === 'history') {
+                const [method, where] = call.args;
+                if (answers) {
+                    const key = JSON.stringify(where ?? null);
+                    const found = answers.find((a) => a.method === method && JSON.stringify(a.where ?? null) === key);
+                    return found ? found.result : { ok: false, error: `history.${String(method)}(${key}): not among the answers given (the turn's page asked something else)` };
+                }
+                if (method === 'timeline')
+                    return { ok: true, value: counts.timeline ?? [] };
+                if (method === 'sessionCount')
+                    return { ok: true, value: counts.sessionCount ?? 0 };
+                if (method === 'exchangeCount')
+                    return { ok: true, value: counts.exchangeCount ?? 0 };
+                return { ok: false, error: `history.${String(method)}: not a history count` };
+            }
+            if (call.fn !== 'records')
+                return { ok: false, error: `${call.fn}: not available here (a page only reads)` };
+            const [table, method, args] = call.args;
+            reads.push({ index, call: { table, method, args } });
+            return { ok: true, value: null };
+        });
+        const answered = await reader.execute(reads.map((r) => r.call));
+        reads.forEach((r, i) => (results[r.index] = answered[i]));
+        return results;
+    };
+    let sandbox;
+    try {
+        sandbox = await runInSandbox({
+            code: build.contextPage.code,
+            arg,
+            dispatch,
+            label: 'context.page.ts',
+            file: functionScriptFile(functionKey(input.sequence, CONTEXT_PAGE_FUNCTION)),
+            console: (level, text) => out.push({ level, text }),
+        });
+    }
+    catch (error) {
+        const stack = error.scriptStack;
+        throw new PageTestError(error instanceof Error ? error.message : String(error), typeof stack === 'string' ? stack : null);
+    }
+    return done(sandbox.value, reader, schema, build, out);
+}
+// ---------------------------------------------------------------------------------------------
+// Configuration: office hours, the sequence as compiled
+/**
+ * The office hours (`office-hours.ts`) at `at` (ISO 8601 or epoch ms), as the platform reads them: open
+ * or not, and today's windows. Office hours the platform would refuse fail with what is wrong.
+ */
+export function officeHoursAt(officeHours, at) {
+    const parsed = parseOfficeHours(officeHours);
+    if (!parsed.ok)
+        throw new Error(`office hours: ${parsed.issues.join('; ')}`);
+    const now = typeof at === 'number' ? at : Date.parse(at);
+    if (Number.isNaN(now))
+        throw new Error(`officeHoursAt: ${String(at)} is not a time`);
+    return resolveOfficeHours(parsed.value, now);
+}
+/**
+ * The sequence compiled as a release compiles it (`index.ts`, its variables, functions, events, office
+ * hours, Orchestrator and page), for a test that checks its configuration. A configuration the release
+ * would refuse rejects with the release's message. Compiled once per test run.
+ */
+export async function compileForTest(input) {
+    return (await compiled(path.resolve(input.repoRoot ?? process.cwd()), input.sequence)).build;
+}
+/**
+ * Connects a test file to an environment (`sandbox` when `env` is left out) as the CLI's login: this
+ * repository's code serves it (as `superpanel-sdk-runtime serve` does, its imports checked as a release
+ * checks them) until the file's tests are done, and `ctx` reads and writes the environment's real data.
+ * What a test writes is written.
+ */
+/**
+ * `debug`: when a test's debug package is written (68 §9, `.superpanel/tests/`): `failed` (the default),
+ * `always`, or `off`; `SUPERPANEL_TEST_DEBUG` overrides it.
+ */
+export async function connect(options = {}) {
+    const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
+    const openedAt = new Date();
+    // Kept on disk, not in memory: a long test file makes many calls.
+    const dir = path.join(repoRoot, '.superpanel', 'integration', `${openedAt.toISOString().replace(/[:.]/g, '-')}-${process.pid}`);
+    mkdirSync(dir, { recursive: true });
+    const callsFile = path.join(dir, 'calls.jsonl');
+    writeFileSync(callsFile, '');
+    const calls = [];
+    // The test running now: when it started, the cases it named or was answered with, its `ctx.api` calls.
+    let current = { startedAt: new Date().toISOString(), cases: new Set(), calls: [] };
+    const record = (call) => {
+        appendFileSync(callsFile, `${JSON.stringify(call)}\n`);
+        calls.push(call);
+        if (calls.length > 200)
+            calls.splice(0, calls.length - 200);
+        current.calls.push(call);
+        casesIn(call.input, current.cases);
+        casesIn(call.output, current.cases);
+    };
+    const session = await openExecSession(repoRoot, { env: options.env, url: options.url, record });
+    const readLogs = await openLogReader(repoRoot, options.url);
+    const overlay = await openOverlay(repoRoot, { backendUrl: session.backendUrl, token: session.loginToken, environmentId: session.run.environment.id });
+    let closed = false;
+    const close = async () => {
+        if (closed)
+            return;
+        closed = true;
+        session.close();
+        await overlay.close();
+    };
+    // A test file's process ends once nothing is open: the serving connection closes after its tests.
+    try {
+        after(close);
+    }
+    catch {
+        // not in a test run: the caller closes it
+    }
+    const debug = process.env.SUPERPANEL_TEST_DEBUG ?? options.debug ?? 'failed';
+    const debugRoot = path.join(repoRoot, '.superpanel', 'tests', path.basename(dir));
+    try {
+        beforeEach(() => {
+            current = { startedAt: new Date().toISOString(), cases: new Set(), calls: [] };
+        });
+        afterEach(async (t) => {
+            const test = current;
+            if (debug === 'off' || (debug === 'failed' && t.passed !== false))
+                return;
+            // The code's log lines reach the store a few seconds after they are written.
+            if (!t.passed)
+                await new Promise((resolve) => setTimeout(resolve, 3_000));
+            const written = await writeDebugPackage(debugRoot, { name: t.fullName, error: t.passed ? null : t.error, startedAt: test.startedAt, cases: [...test.cases], calls: test.calls }, {
+                caseDebug: (instanceId) => post('debug', { instanceId }),
+                readTurn: (turnId) => post('turns/read', { turnId }),
+                logs: async (instanceId, since) => (await readLogs({ env: session.run.environment.id, instance: instanceId, since, order: 'asc', limit: 500 })).lines,
+            });
+            console.log(`debug package: ${path.relative(repoRoot, written)}/summary.md`);
+        });
+    }
+    catch {
+        // not in a test run
+    }
+    const post = async (what, body) => {
+        // Waits as long as the backend may take: an Orchestrator run or a turn is slower than a request.
+        const send = async (force) => fetch(apiUrl(session.backendUrl, `cli-auth/exec/${what}`), {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${await session.token(force)}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(180_000),
+        });
+        let response = await send(false);
+        // Its token ran out after all (a process asleep past the renewal): renewed, sent once more.
+        if (response.status === 401)
+            response = await send(true);
+        const payload = (await response.json().catch(() => ({})));
+        casesIn(body, current.cases);
+        if (!response.ok)
+            throw new Error(`${what}: ${payload.error ?? `the backend answered ${response.status}`}`);
+        if (what !== 'debug')
+            casesIn(payload, current.cases);
+        return payload;
+    };
+    return {
+        environment: session.run.environment,
+        ctx: session.ctx,
+        calls,
+        callsFile,
+        logs: async (query = {}) => (await readLogs({ ...query, env: session.run.environment.id, since: query.since ?? openedAt.toISOString(), order: 'asc' })).lines,
+        renderPage: (input) => post('page', input),
+        runOrchestrator: (input) => post('orchestrator', input),
+        turn: (input) => shadowTurn(post, repoRoot, 'turn', input),
+        act: (input) => shadowTurn(post, repoRoot, 'act', input),
+        turns: async (query) => (await post('turns', query)).turns,
+        readTurn: (turnId) => post('turns/read', { turnId }),
+        sim: {
+            line: (name) => post('sim/line', name ? { name } : {}),
+            mailbox: (name) => post('sim/mailbox', name ? { name } : {}),
+            phone: testCustomerPhone,
+            customer: (input) => testCustomer(post, input),
+        },
+        runDue: (input) => post('run-due', input),
+        call: { inbound: (input) => openTextCall(post, { from: input.from, to: input.to ?? 'Main line' }) },
+        exportTurn: async (turnId, dir) => writeTurnExport(path.resolve(repoRoot, dir ?? path.join('.superpanel', 'turns', turnId)), await post('turns/read', { turnId })),
+        close,
+    };
+}
+//# sourceMappingURL=testing.js.map

package/dist/voice-service/actions.d.ts

@@ -1,18 +1,16 @@
-import type { CallEndEvent, CallRecordedEvent, CallStatusChangeEvent, ChatItemWithCallSid, FieldCollectResponse, IncomingOutgoingCall, TransferEvent } from './types.js';
+import type { CallEndEvent, CallRecordedEvent, CallStatusChangeEvent, IncomingOutgoingCall } from './types.js';
+import type * as VoiceProtocol from './protocol.js';
 /** Superpanel SDK-owned action dispatch types. Do not add to types.ts — that file is overwritten from Mars. */
-export type VoiceServiceActionName = 'fetchTwilioConfig' | 'onInbound' | 'onCallStart' | 'onCallEnd' | 'onCallStatusChanged' | 'onChatItem' | 'onOutbound' | 'onTransferEvents' | 'onFieldCollectCompleted' | 'onFarEnd' | 'onCallRecorded' | 'onSms';
+export type VoiceServiceActionName = 'fetchTwilioConfig' | 'onInbound' | 'onCallEnd' | 'onCallStatusChanged' | 'onOutbound' | 'onCallRecorded' | 'onCallEvents' | 'onSms';
 export type VoiceServiceActionMap = {
     fetchTwilioConfig: IncomingOutgoingCall;
     onInbound: IncomingOutgoingCall;
-    onCallStart: IncomingOutgoingCall;
     onCallEnd: CallEndEvent;
     onCallStatusChanged: CallStatusChangeEvent;
-    onChatItem: ChatItemWithCallSid & WithEventId;
     onOutbound: IncomingOutgoingCall;
-    onTransferEvents: TransferEvent & WithEventId;
-    onFieldCollectCompleted: FieldCollectResponse & WithEventId;
-    onFarEnd: FarEndEvent & WithEventId;
     onCallRecorded: CallRecordedEvent;
+    /** Upstream protocol events the call's socket never got acked: sent once the socket is gone. */
+    onCallEvents: VoiceProtocol.CallEventsBatch;
     onSms: {
         MessageSid: string;
         AccountSid: string;
@@ -31,31 +29,11 @@ export type WithEventId = {
     eventId?: string;
 };
 /**
- * A call event the voice service sends on the call's socket (`{ action: 'event', params }`), answered with
- * `eventAck` once handled and saved. Once the call's socket is gone it goes by HTTP as its own action.
+ * The voice service's word on who answered an outbound call (65 §3.1): `voicemail`, a voicemail greeting;
+ * `human`, a person after all — a voicemail verdict taken back before the message started. Anything else
+ * (a person, a call-screening assistant, a phone menu) is the page's model's to tell, from the words.
  */
-export type VoiceCallEvent = {
-    eventId: string;
-    name: 'chatItem';
-    payload: ChatItemWithCallSid;
-} | {
-    eventId: string;
-    name: 'fieldCollectCompleted';
-    payload: FieldCollectResponse;
-} | {
-    eventId: string;
-    name: 'transferEvent';
-    payload: TransferEvent;
-} | {
-    eventId: string;
-    name: 'farEnd';
-    payload: FarEndEvent;
-};
-/**
- * Who answered an outbound call (25 §13): a person, a voicemail greeting, a call-screening assistant
- * ("say your name and why you are calling"), or a phone menu. The voice service tells; the page decides.
- */
-export type FarEndKind = 'human' | 'voicemail' | 'screening' | 'ivr';
+export type FarEndKind = 'human' | 'voicemail';
 /** The voice service's verdict on the far end, with what it said. */
 export type FarEndEvent = {
     callSid: string;
@@ -63,14 +41,13 @@ export type FarEndEvent = {
     said: string;
 };
 /**
- * The backend's answer to a far end (25 §13): `handled` — the page took it (it leaves a message, speaks to
- * the screener, presses keys, ends), so the voice service does not do its own thing (and, screened,
- * waits longer in silence); `default` — the voice service does what it did before (hang up on a machine).
+ * The backend's answer to a voicemail (25 §13): `handled` — the page took it (it leaves a message or ends),
+ * so the voice service does not do its own thing; `default` — the voice service hangs up.
  */
 export type FarEndDecisionRequest = {
     callSid: string;
     type: 'far-end-decision';
-    kind: FarEndKind;
+    kind: 'voicemail';
     decision: 'default' | 'handled';
 };
 /** Leave this message on the voicemail, after its beep, word for word, then hang up (25 §13). */

package/dist/voice-service/index.d.ts

@@ -1,3 +1,5 @@
 export * from './types.js';
 export * from './actions.js';
+/** The call protocol with the voice service (copied from jupiter-voice-service `src/protocol/voice-protocol.ts`). */
+export * as VoiceProtocol from './protocol.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/voice-service/index.js

@@ -1,3 +1,5 @@
 export * from './types.js';
 export * from './actions.js';
+/** The call protocol with the voice service (copied from jupiter-voice-service `src/protocol/voice-protocol.ts`). */
+export * as VoiceProtocol from './protocol.js';
 //# sourceMappingURL=index.js.map