@superpanel-sdk/runtime 0.5.0 → 0.7.0

package/dist/cli/turns/shadow.d.ts

@@ -0,0 +1,112 @@
+import type { TextCallEvent } from '../calls/index.js';
+import type { TurnSummary } from './index.js';
+export type TurnInput = {
+    /** The case; left out with `from` (the turn's). */
+    instanceId?: string;
+    channel?: 'sms' | 'email' | 'call';
+    /** What the customer writes or says; with `from`, in place of what they said then. */
+    say?: string;
+    /** The conversation's contact; the case's subject when it is a contact and none is named. */
+    caller?: string;
+    /** The conversation so far, by hand, oldest first; the case's real one when left out. */
+    history?: Array<{
+        customer?: string;
+        ai?: string;
+    }>;
+    /** Start where a turn started: its id, or the directory it was exported to (relative to the repository). */
+    from?: string;
+    /** Run it this many times (1–10), each from the same start: the model answers differently each time. */
+    repeat?: number;
+    /** Results for the company's functions the turn presses, by name; a recorded call (`from`) is replayed first. */
+    functions?: {
+        results?: Record<string, unknown>;
+    };
+};
+/** One run of the turn. */
+export type ShadowRun = {
+    runId: string | null;
+    /** A text or email run: how it ended (`reply` with its `text`, not sent). A call's turn: null. */
+    outcome: {
+        kind: 'reply';
+        text: string;
+        email?: {
+            subject?: string;
+            cc?: string[];
+        };
+        steps: number;
+    } | {
+        kind: 'noReply' | 'handoff' | 'abnormal';
+        reason: string;
+        steps: number;
+    } | null;
+    /** What the AI said, or would have sent. */
+    said: string[];
+    /** `act`: what the platform told the model after running the actions. */
+    stepResult?: string;
+    actions: Array<{
+        name: string;
+        kind: string;
+        args: unknown;
+        status: string;
+        error: string | null;
+        result: unknown;
+    }>;
+    /** Each field it wrote: its row, table and field, the value and state it took, and what it was. */
+    writes: Array<{
+        rowId: string;
+        table: string;
+        field: string;
+        value: unknown;
+        state: string | null;
+        from: {
+            value: unknown;
+            state: string | null;
+        };
+        reason: string | null;
+    }>;
+    /** A call: what it did on the line (a keypad, a transfer, a voicemail). */
+    events: TextCallEvent[];
+    /** A call the AI ended in this turn. */
+    ended: boolean;
+    turns: TurnSummary[];
+    /** Each company function the turn pressed: `replayed` (as it ran then), `given` (yours), `unrecorded` (not run), `skipped` (an event handler). */
+    functions: Array<{
+        name: string;
+        args: unknown;
+        how: 'replayed' | 'given' | 'unrecorded' | 'skipped';
+        result?: unknown;
+        error?: string;
+    }>;
+    /** What it would have done outside the database (a text, an email, an Orchestrator run): none of it happened. */
+    held: string[];
+    /** Where it could not start exactly as asked (a row gone since). */
+    warnings: string[];
+    /** Whether it pressed the button with this run key (or name). */
+    clicked(key: string): boolean;
+    /** Whether it wrote `table.field` (to `value`, when given). */
+    wrote(field: string, value?: unknown): boolean;
+};
+/** What a `turn` or an `act` did: its first run's, and every run with `repeat`. */
+export type RunResult = ShadowRun & {
+    runs: ShadowRun[];
+    /** The turn it started from. */
+    from: {
+        turnId: string;
+        kind: string;
+        heard: string | null;
+    } | null;
+    /** The share of runs `check` holds for, 0–1. */
+    rate(check: (run: ShadowRun) => boolean): number;
+};
+type Post = <T>(what: string, body: unknown) => Promise<T>;
+/** `from` as the backend takes it: a turn id as it is, a directory's files read. */
+export declare function fromOf(repoRoot: string, from: string): string | {
+    turn: unknown;
+    history: unknown;
+    data: unknown;
+};
+export declare function shadowTurn(post: Post, repoRoot: string, what: 'turn' | 'act', input: TurnInput & {
+    actions?: unknown[];
+}): Promise<RunResult>;
+export {};
+//# sourceMappingURL=shadow.d.ts.map

package/dist/cli/turns/shadow.js

@@ -0,0 +1,54 @@
+/**
+ * A single turn, always a shadow (68 §8): `sandbox.turn` / `sandbox.act` and `superpanel-sdk-runtime turn`.
+ * The backend runs it on a shadow of the environment's database, rolled back afterwards; what it did comes
+ * back. `from` names a turn by id, or the directory `turns export` wrote it to (kept in the repository,
+ * it outlives the 30 days a turn's snapshot is kept): its files are sent as they are.
+ */
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+/** `from` as the backend takes it: a turn id as it is, a directory's files read. */
+export function fromOf(repoRoot, from) {
+    const dir = path.resolve(repoRoot, from);
+    const isDir = (() => {
+        try {
+            return statSync(dir).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    })();
+    if (!isDir) {
+        if (/[\\/]/.test(from))
+            throw new Error(`turn: from ${from}: no such directory`);
+        return from;
+    }
+    const json = (name, required) => {
+        const file = path.join(dir, name);
+        if (!existsSync(file)) {
+            if (required)
+                throw new Error(`turn: ${from} has no ${name} (export a turn with \`turns export <turnId>\`)`);
+            return null;
+        }
+        return JSON.parse(readFileSync(file, 'utf8'));
+    };
+    return { turn: json('turn.json', true), history: json('history.json', true), data: json('data.json', false) ?? {} };
+}
+function withChecks(run) {
+    return {
+        ...run,
+        clicked: (key) => run.actions.some((a) => a.status !== 'failed' && (a.name === key || run.turns.some((t) => t.actions.some((ta) => ta.key === key && ta.status !== 'failed')))),
+        wrote: (field, ...value) => run.writes.some((w) => `${w.table}.${w.field}` === field && (value.length === 0 || JSON.stringify(w.value) === JSON.stringify(value[0]))),
+    };
+}
+export async function shadowTurn(post, repoRoot, what, input) {
+    const body = { ...input, ...(input.from ? { from: fromOf(repoRoot, input.from) } : {}) };
+    const wire = await post(what, body);
+    const runs = wire.runs.map(withChecks);
+    return {
+        ...runs[0],
+        runs,
+        from: wire.from,
+        rate: (check) => (runs.length ? runs.filter(check).length / runs.length : 0),
+    };
+}
+//# sourceMappingURL=shadow.js.map

package/dist/cli/type-gen/index.js

@@ -9,7 +9,6 @@ async function runOnce(repoRoot, sequenceIds) {
     }
     for (const result of results) {
         console.log(`wrote ${path.relative(repoRoot, result.outPath)}`);
-        console.log(`wrote ${path.relative(repoRoot, result.caseContextOutPath)}`);
         console.log(`wrote ${path.relative(repoRoot, result.indexOutPath)}`);
     }
 }

package/dist/compute-host/compute-host.d.ts

@@ -1,5 +1,5 @@
 /**
- * Pluggable host for sequence functions (case / noCase / orchestrator functions).
+ * Pluggable host for sequence functions: every one is `(ctx, args)` (38 §2.1); the host builds `ctx`.
  *
  * - Local unit tests / company CI: {@link createLocalComputeHost} (direct JS call)
  * - Author FuncMap: `createSourceComputeHost`
@@ -11,18 +11,17 @@ export interface ComputeHost {
     /** Release host-owned resources. No-op when the host has nothing to free. */
     dispose(): void;
 }
-/** Input for case, noCase and orchestrator functions. */
+/** What a function is called with besides `ctx`: its `args`, one object (`{}` when left out). */
 export type FunctionInvocation = {
-    caseContext?: unknown;
-    params?: object;
+    args?: object;
 };
 export type ComputeInvocation = FunctionInvocation;
 export declare function parseComputeInvocation(value: unknown): ComputeInvocation | null;
 /**
- * Name → plain function of `caseContext` (local tests stand in sequence functions with these).
+ * Name → plain function of `args` (local tests stand in sequence functions with these).
  * Parameter typed as `never` so company-narrowed maps remain assignable (TS contravariance).
  */
-export type ComputeFnMap = Record<string, (caseContext: never) => unknown | Promise<unknown>>;
+export type ComputeFnMap = Record<string, (args: never) => unknown | Promise<unknown>>;
 export type ComputeHostOrFns = ComputeHost | ComputeFnMap;
 export declare function createLocalComputeHost(fns: ComputeFnMap): ComputeHost;
 /** Accept either a host or a name→fn map (map is wrapped as local host). */

package/dist/compute-host/compute-host.js

@@ -2,24 +2,15 @@ export function parseComputeInvocation(value) {
     if (typeof value !== 'object' || value === null || Array.isArray(value))
         return null;
     const record = value;
-    if (record.params !== undefined &&
-        (typeof record.params !== 'object' || record.params === null || Array.isArray(record.params))) {
+    if (record.args !== undefined &&
+        (typeof record.args !== 'object' || record.args === null || Array.isArray(record.args))) {
         return null;
     }
-    return {
-        ...(Object.hasOwn(record, 'caseContext') ? { caseContext: record.caseContext } : {}),
-        ...(record.params !== undefined ? { params: record.params } : {}),
-    };
+    return record.args !== undefined ? { args: record.args } : {};
 }
 function isComputeHost(value) {
     return typeof value.execute === 'function';
 }
-function requireCaseContext(name, invocation) {
-    if (!Object.hasOwn(invocation, 'caseContext')) {
-        throw new Error(`Function ${name}: caseContext required`);
-    }
-    return invocation.caseContext;
-}
 export function createLocalComputeHost(fns) {
     return {
         async execute(name, invocation = {}) {
@@ -27,7 +18,7 @@ export function createLocalComputeHost(fns) {
             if (!fn) {
                 throw new Error(`Missing function implementation: ${name}`);
             }
-            return fn(requireCaseContext(name, invocation));
+            return fn((invocation.args ?? {}));
         },
         dispose() { },
     };

package/dist/compute-host/source-compute-host.d.ts

@@ -4,11 +4,11 @@ import type { ComputeHost } from './compute-host.js';
 import type { ActionDataSlice, ApiHost, CaseOrchestratorApiHost } from '../fn-context/types.js';
 export type SourceComputeHostOptions = {
     functions: FuncMap;
-    /** Company `events` export; handlers are registered under the event name with the table-fixed kind. */
+    /** Company `events` export; handlers are registered under the event name. */
     events?: AnyEventHandlers;
     /** Override ApiHost; default Fake, or Rpc when runToken + data.config.backendUrl. */
     apiHost?: ApiHost & CaseOrchestratorApiHost;
-    /** ActionDataSlice used to build ctx for case / noCase / orchestrator. */
+    /** ActionDataSlice used to build every function's ctx. */
     data?: ActionDataSlice;
     /** When set with data.config.backendUrl, uses Http RpcApiHost. */
     runToken?: string;
@@ -23,15 +23,13 @@ export type SourceComputeHostOptions = {
 };
 export interface SourceComputeHost extends ComputeHost {
 }
-/** Company `events` handlers as DefinedFunc entries (kind from the platform event table). */
+/** Company `events` handlers, by event name. */
 export declare function eventsToFuncMap(events: AnyEventHandlers | undefined): FuncMap;
 /**
  * Local host: call author FuncMap implementations directly (no SequenceBuild.code).
  *
- * Lookup by name, then dispatch on `kind`:
- * - case: `fn(caseContext, { ...ctx, params })`; caseContext required.
- * - orchestrator: same, with the Case Orchestrator ctx.
- * - noCase: `fn({ ...ctx, params })`; caseContext must be absent.
+ * Lookup by name, then `fn(ctx, args)` (38 §2.1): the Orchestrator gets its own ctx (with `api.tools`),
+ * every other function a function's.
  */
 export declare function createSourceComputeHost(options: SourceComputeHostOptions): SourceComputeHost;
 //# sourceMappingURL=source-compute-host.d.ts.map

package/dist/compute-host/source-compute-host.js

@@ -1,4 +1,5 @@
-import { isSystemEventName, systemEventKind } from '../core/functions/events.js';
+import { isSystemEventName } from '../core/functions/events.js';
+import { ORCHESTRATOR_FUNCTION } from '../core/case-orchestrator/types.js';
 import { buildActionContext, buildCaseOrchestratorContext } from '../fn-context/build-context.js';
 import { resolveFnParams } from '../fn-context/fn-params.js';
 import { createFakeApiHost } from '../fn-context/fake/index.js';
@@ -6,28 +7,20 @@ import { createRpcApiHost } from '../fn-context/rpc/index.js';
 import { makeCaseOrchestratorCtx, makeCtx } from '../fn-context/make-ctx.js';
 import { getLogger } from '../logger.js';
 const logger = getLogger(['runtime', 'source']);
-function requireCaseContext(name, invocation) {
-    if (!Object.hasOwn(invocation, 'caseContext'))
-        throw new Error(`Function ${name}: caseContext required`);
-    return invocation.caseContext;
-}
-/** Company `events` handlers as DefinedFunc entries (kind from the platform event table). */
+/** Company `events` handlers, by event name. */
 export function eventsToFuncMap(events) {
     const out = {};
     for (const [name, handler] of Object.entries(events ?? {})) {
-        if (!isSystemEventName(name) || typeof handler !== 'function')
-            continue;
-        out[name] = { kind: systemEventKind(name), main: handler };
+        if (isSystemEventName(name) && typeof handler === 'function')
+            out[name] = handler;
     }
     return out;
 }
 /**
  * Local host: call author FuncMap implementations directly (no SequenceBuild.code).
  *
- * Lookup by name, then dispatch on `kind`:
- * - case: `fn(caseContext, { ...ctx, params })`; caseContext required.
- * - orchestrator: same, with the Case Orchestrator ctx.
- * - noCase: `fn({ ...ctx, params })`; caseContext must be absent.
+ * Lookup by name, then `fn(ctx, args)` (38 §2.1): the Orchestrator gets its own ctx (with `api.tools`),
+ * every other function a function's.
  */
 export function createSourceComputeHost(options) {
     const { functions, data } = options;
@@ -47,30 +40,16 @@ export function createSourceComputeHost(options) {
     }
     return {
         async execute(name, invocation = {}) {
-            const def = registry[name];
-            if (!def) {
+            const fn = registry[name];
+            if (!fn) {
                 throw new Error(`Missing function: ${name}`);
             }
-            const functionInvocation = invocation;
-            const params = resolveFnParams(functionInvocation.params);
-            if (def.kind === 'case') {
-                const caseContext = requireCaseContext(name, functionInvocation);
-                const ctx = await systemContext();
-                return def.main(caseContext, { ...ctx, params });
-            }
-            if (def.kind === 'orchestrator') {
-                const caseContext = requireCaseContext(name, functionInvocation);
-                const ctx = await caseOrchestratorContext();
-                return def.main(caseContext, { ...ctx, params: params });
-            }
-            if (Object.hasOwn(functionInvocation, 'caseContext')) {
-                throw new Error(`Function ${name}: noCase function must not receive caseContext`);
-            }
+            const args = resolveFnParams(invocation.args);
             const contextStarted = Date.now();
-            const ctx = await systemContext();
+            const ctx = name === ORCHESTRATOR_FUNCTION ? await caseOrchestratorContext() : await systemContext();
             logger.info('context built', { name, durationMs: Date.now() - contextStarted });
             const functionStarted = Date.now();
-            const result = await def.main({ ...ctx, params });
+            const result = await fn(ctx, args);
             logger.info('function executed', { name, durationMs: Date.now() - functionStarted });
             return result;
         },

package/dist/core/case-orchestrator/contact-hours.d.ts

@@ -24,7 +24,18 @@ export type ContactHours = {
         date: string;
         hours: ContactHoursRange[];
     }[];
+    /**
+     * Whose hours: left out, the company's contact-hours rules; `contact_schedule`, a contact's own
+     * (`contactScheduleHours`); `cadence`, the code's own pacing (one call a day: today closed once it had
+     * its call), which holds whatever an environment being tested lets go (`ctx.time.ignore`).
+     */
+    source?: 'contact_schedule' | 'cadence';
 };
+/** What does not hold while the environment is tested (`ctx.time.ignore`, 68 §6.2). */
+export type ContactHoursIgnore = Readonly<{
+    contactHours: boolean;
+    contactSchedule: boolean;
+}>;
 /** The contact's own `contact_schedule` value (when they said they may be reached). */
 export type ContactScheduleValue = {
     weekly: Record<ContactHoursWeekday, ContactHoursRange[]> | null;
@@ -39,12 +50,21 @@ export declare function everyDay(hours: ContactHoursRange[]): Record<ContactHour
 export declare function contactScheduleHours(schedule: ContactScheduleValue | null | undefined): ContactHours;
 /** The hours on a local date (`YYYY-MM-DD`): an override, else a holiday, else the weekday. */
 export declare function contactHoursOn(hours: ContactHours, day: string): ContactHoursRange[];
-/** Whether `at` (a Date, ISO string or epoch ms) falls inside `hours` (one, or a list that must all allow it) in `timezone`. */
-export declare function withinContactHours(hours: ContactHours | readonly ContactHours[], at: Date | string | number, timezone: string): boolean;
 /**
- * The first time at or after `from` (a Date, ISO string or epoch ms, e.g. `ctx.time.now`) inside `hours` (one, or a list that must all allow it: the
- * company's rules and the contact's own schedule), in `timezone`, as an ISO string for `at`; null
- * when there is none within `days` (default 14).
+ * Whether `at` (a Date, ISO string or epoch ms) falls inside `hours` (one, or a list that must all allow it)
+ * in `timezone`. `ignore` (`ctx.time.ignore`): what does not hold while the environment is tested; when
+ * nothing is left to hold, any time is.
  */
-export declare function nextContactTime(hours: ContactHours | readonly ContactHours[], from: Date | string | number, timezone: string, days?: number): string | null;
+export declare function withinContactHours(hours: ContactHours | readonly ContactHours[], at: Date | string | number, timezone: string, ignore?: ContactHoursIgnore): boolean;
+/**
+ * The first time at or after `from` inside `hours` (one, or a list that must all allow it: the company's
+ * rules and the contact's own schedule), in `timezone`, as an ISO string for `at`; null when there is none
+ * within `days` (default 14). `from` is `ctx.time` (its `now`, and what does not hold while the environment
+ * is tested: `ctx.time.ignore`, 68 §6.2), or a Date, ISO string or epoch ms. When nothing is left to hold,
+ * `from` itself.
+ */
+export declare function nextContactTime(hours: ContactHours | readonly ContactHours[], from: Date | string | number | {
+    now: number;
+    ignore?: ContactHoursIgnore;
+}, timezone: string, days?: number): string | null;
 //# sourceMappingURL=contact-hours.d.ts.map

package/dist/core/case-orchestrator/contact-hours.js

@@ -17,8 +17,15 @@ export function contactScheduleHours(schedule) {
     return {
         week: schedule?.weekly ?? everyDay(ALL_DAY),
         overrides: (schedule?.dateOverrides ?? []).flatMap((override) => override.dates.map((date) => ({ date, hours: override.windows }))),
+        source: 'contact_schedule',
     };
 }
+/** `hours` without what `ignore` lets go: the company's rules, the contact's own schedule; never a cadence. */
+function held(hours, ignore) {
+    if (!ignore)
+        return hours;
+    return hours.filter((entry) => entry.source === 'cadence' ? true : entry.source === 'contact_schedule' ? !ignore.contactSchedule : !ignore.contactHours);
+}
 /** The hours on a local date (`YYYY-MM-DD`): an override, else a holiday, else the weekday. */
 export function contactHoursOn(hours, day) {
     const override = hours.overrides?.find((entry) => entry.date === day);
@@ -78,21 +85,33 @@ function addDays(day, count) {
 function list(hours) {
     return Array.isArray(hours) ? hours : [hours];
 }
-/** Whether `at` (a Date, ISO string or epoch ms) falls inside `hours` (one, or a list that must all allow it) in `timezone`. */
-export function withinContactHours(hours, at, timezone) {
+/**
+ * Whether `at` (a Date, ISO string or epoch ms) falls inside `hours` (one, or a list that must all allow it)
+ * in `timezone`. `ignore` (`ctx.time.ignore`): what does not hold while the environment is tested; when
+ * nothing is left to hold, any time is.
+ */
+export function withinContactHours(hours, at, timezone, ignore) {
+    const kept = held(list(hours), ignore);
+    if (kept.length === 0)
+        return true;
     const local = localParts(new Date(at), timezone);
-    return rangesOn(list(hours), local.day).some((range) => local.minute >= minutes(range.start) && local.minute < minutes(range.end));
+    return rangesOn(kept, local.day).some((range) => local.minute >= minutes(range.start) && local.minute < minutes(range.end));
 }
 /**
- * The first time at or after `from` (a Date, ISO string or epoch ms, e.g. `ctx.time.now`) inside `hours` (one, or a list that must all allow it: the
- * company's rules and the contact's own schedule), in `timezone`, as an ISO string for `at`; null
- * when there is none within `days` (default 14).
+ * The first time at or after `from` inside `hours` (one, or a list that must all allow it: the company's
+ * rules and the contact's own schedule), in `timezone`, as an ISO string for `at`; null when there is none
+ * within `days` (default 14). `from` is `ctx.time` (its `now`, and what does not hold while the environment
+ * is tested: `ctx.time.ignore`, 68 §6.2), or a Date, ISO string or epoch ms. When nothing is left to hold,
+ * `from` itself.
  */
 export function nextContactTime(hours, from, timezone, days = 14) {
-    const start = new Date(from).getTime();
+    const time = typeof from === 'object' && !(from instanceof Date) ? from : null;
+    const start = new Date(time ? time.now : from).getTime();
     if (!Number.isFinite(start))
         throw new Error('nextContactTime: from must be a time');
-    const all = list(hours);
+    const all = held(list(hours), time?.ignore);
+    if (all.length === 0)
+        return new Date(start).toISOString();
     const today = localParts(new Date(start), timezone).day;
     for (let offset = 0; offset <= days; offset += 1) {
         const day = addDays(today, offset);

package/dist/core/case-orchestrator/index.d.ts

@@ -1,6 +1,3 @@
-export { ACTIVITY_RECENT_LIMIT, ORCHESTRATOR_ENTRY, ORCHESTRATOR_CONTACTS_FUNCTION, ORCHESTRATOR_FUNCTION, CASE_ORCHESTRATOR_TOOL_NAMES, EMPTY_CASE_ACTIVITY, RECENT_AGREED_ACTIONS_DAYS, type ActivityStats, type AgentRequest, type AgreementFields, type CaseActivity, type CaseOrchestrator, type CaseOrchestratorApi, type CaseOrchestratorContacts, type CaseOrchestratorContactsContext, type CaseOrchestratorContext, type CaseInput, type CaseOrchestratorInput, type CaseOrchestratorManifest, type CaseOrchestratorParams, type CaseOrchestratorResult, type CaseOrchestratorToolName, type CaseOrchestratorTools, type ChannelAvailability, type ChannelUnavailableReason, type ExchangeEntry, type ExchangeEvent, type ExchangeSearchHit, type ContactActionInput, type ContactActionView, type ContactChannel, type PartyContactHours, type FinalOrchestrationResult, type FinishedAgreedActionView, type PartyActivity, type ReadExchangeResult, type ResolvedAgentRequest, type RescheduledResult, type RunTrigger, type RunTriggerType, type ScheduleUpdateSlotsInput, type SlotFieldWriteInput, type SlotInsertInput, type SlotWriteInput, type ScheduleTiming, type ScheduledActionInput, type ScheduledActionInputs, type ScheduledActionKind, type ScheduledActionTiming, type ScheduledActionView, type SearchExchangesResult, type ToolCallArgs, type ToolCallOptions, type ToolCallResult, type ToolResult, type ToolRef, type UpdateSlotsActionInput, type UpdateSlotsActionView, type ScheduleWakeInput, type WakeActionInput, type WakeActionView, type WakeResult, } from './types.js';
+export { ACTIVITY_RECENT_LIMIT, ORCHESTRATOR_ENTRY, ORCHESTRATOR_FUNCTION, CASE_ORCHESTRATOR_TOOL_NAMES, EMPTY_CASE_ACTIVITY, RECENT_AGREED_ACTIONS_DAYS, type ActivityStats, type AgreementFields, type CaseActivity, type CaseOrchestrator, type CaseOrchestratorApi, type CaseOrchestratorArgs, type CaseOrchestratorContext, type CaseOrchestratorManifest, type CaseOrchestratorParams, type CaseOrchestratorToolName, type CaseOrchestratorTools, type ChannelAvailability, type ChannelUnavailableReason, type ExchangeEntry, type ExchangeEvent, type ExchangeSearchHit, type ContactActionInput, type ContactActionView, type ContactChannel, type PartyContactHours, type FinishedAgreedActionView, type PartyActivity, type ReadExchangeResult, type RescheduledResult, type RunTrigger, type RunTriggerType, type ScheduleUpdateSlotsInput, type SlotFieldWriteInput, type SlotInsertInput, type SlotWriteInput, type ScheduleTiming, type ScheduledActionInput, type ScheduledActionInputs, type ScheduledActionKind, type ScheduledActionTiming, type ScheduledActionView, type SearchExchangesResult, type ToolCallArgs, type ToolCallResult, type ToolResult, type UpdateSlotsActionInput, type UpdateSlotsActionView, type ScheduleWakeInput, type WakeActionInput, type WakeActionView, type WakeResult, } from './types.js';
 export { localDateTime, localDay, render, zonedIso, type ConversationOptions, type TimelineOptions } from './render.js';
-export { tools } from './tools.js';
-export { followUps } from './follow-ups.js';
-export { validateCaseOrchestratorResult, type CaseOrchestratorResultCheck } from './validate.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/case-orchestrator/index.js

@@ -1,6 +1,3 @@
-export { ACTIVITY_RECENT_LIMIT, ORCHESTRATOR_ENTRY, ORCHESTRATOR_CONTACTS_FUNCTION, ORCHESTRATOR_FUNCTION, CASE_ORCHESTRATOR_TOOL_NAMES, EMPTY_CASE_ACTIVITY, RECENT_AGREED_ACTIONS_DAYS, } from './types.js';
+export { ACTIVITY_RECENT_LIMIT, ORCHESTRATOR_ENTRY, ORCHESTRATOR_FUNCTION, CASE_ORCHESTRATOR_TOOL_NAMES, EMPTY_CASE_ACTIVITY, RECENT_AGREED_ACTIONS_DAYS, } from './types.js';
 export { localDateTime, localDay, render, zonedIso } from './render.js';
-export { tools } from './tools.js';
-export { followUps } from './follow-ups.js';
-export { validateCaseOrchestratorResult } from './validate.js';
 //# sourceMappingURL=index.js.map

package/dist/core/case-orchestrator/render.d.ts

@@ -55,7 +55,7 @@ export type ConversationOptions = {
  */
 declare function conversation(result: ReadExchangeResult, timezone: string, options?: ConversationOptions): string;
 /**
- * Text for company prompts (docs/design/08-case-orchestrator.md §5.3), in the mars next-step
+ * Text for company code to show or log (docs/design/08-case-orchestrator.md §5.3), in the mars next-step
  * format. Party functions take one contact's activity (`activity.byContact[contactId]`) and
  * write its local wall-clock times.
  */

package/dist/core/case-orchestrator/render.js

@@ -158,20 +158,22 @@ function pendingActions(actions, timezone) {
     return actions
         .map((action) => {
         const head = `- ${action.id}: ${action.kind} at ${localDateTime(action.scheduledFor, timezone)}`;
+        const why = action.reason ? ` (${action.reason})` : '';
         if (action.kind === 'update_slots') {
-            const { timing, writes, reason } = action.input;
-            return `${head} (${reason}) ${JSON.stringify({ timing, writes })}`;
+            const { timing, writes } = action.input;
+            return `${head}${why} ${JSON.stringify({ timing, writes })}`;
         }
         if (action.kind === 'next_sequence') {
-            const { timing, sequence, subjectRecordId, reason } = action.input;
-            return `${head} (${reason}) ${JSON.stringify({ timing, sequence, ...(subjectRecordId ? { subjectRecordId } : {}) })}`;
+            const { timing, sequence, subjectRecordId } = action.input;
+            return `${head}${why} ${JSON.stringify({ timing, sequence, ...(subjectRecordId ? { subjectRecordId } : {}) })}`;
         }
         if (action.kind === 'wake') {
-            const { timing, name, note } = action.input;
-            return `${head} ${name}${note ? ` (${note})` : ''} ${JSON.stringify({ timing })}`;
+            const { timing } = action.input;
+            const name = action.name;
+            return `${head} ${name}${why} ${JSON.stringify({ timing })}`;
         }
-        const { timing, note } = action.input;
-        return `${head}${agreedMark(action, timezone)}${note ? ` (${note})` : ''} ${JSON.stringify({ timing })}`;
+        const { timing } = action.input;
+        return `${head}${agreedMark(action, timezone)}${why} ${JSON.stringify({ timing })}`;
     })
         .join('\n');
 }
@@ -190,6 +192,9 @@ function wakeUps(triggers, timezone) {
             return [`- external ${trigger.reason} at ${at}`];
         if (trigger.type === 'inbound.paused')
             return [`- inbound ${trigger.channel} ${trigger.exchangeId} at ${at}, not answered: the case was paused`];
+        if (trigger.type === 'scheduled_action.ended') {
+            return [`- scheduled ${trigger.kind} ${trigger.scheduledActionId} at ${at}: ${trigger.outcome === 'not_sent' ? `not sent (${trigger.reason ?? 'decided'})` : 'slots written'}`];
+        }
         return [];
     });
     return lines.length > 0 ? lines.join('\n') : '(none)';
@@ -202,7 +207,7 @@ function recentAgreedActions(actions, timezone) {
     if (actions.length === 0)
         return '(none)';
     return actions
-        .map((action) => `- ${action.id}: ${action.kind} at ${localDateTime(action.scheduledFor, timezone)}${agreedMark(action, timezone)}, ${action.status} at ${localDateTime(action.finishedAt, timezone)}${action.input.note ? ` (${action.input.note})` : ''}`)
+        .map((action) => `- ${action.id}: ${action.kind} at ${localDateTime(action.scheduledFor, timezone)}${agreedMark(action, timezone)}, ${action.status} at ${localDateTime(action.finishedAt, timezone)}${action.reason ? ` (${action.reason})` : ''}`)
         .join('\n');
 }
 /**
@@ -220,7 +225,7 @@ function conversation(result, timezone, options = {}) {
     return `${head}\n${earlier}${lines.join('\n')}`;
 }
 /**
- * Text for company prompts (docs/design/08-case-orchestrator.md §5.3), in the mars next-step
+ * Text for company code to show or log (docs/design/08-case-orchestrator.md §5.3), in the mars next-step
  * format. Party functions take one contact's activity (`activity.byContact[contactId]`) and
  * write its local wall-clock times.
  */