@absolutejs/voice 0.0.22-beta.45 → 0.0.22-beta.46

package/dist/evalRoutes.d.ts

@@ -75,6 +75,7 @@ export type VoiceScenarioEvalDefinition = {
     requiredLifecycleTypes?: string[];
     requiredPayloadPaths?: string[];
     requiredTranscriptIncludes?: string[];
+    requiredWorkflowContracts?: string[];
     scenarioId?: string;
 };
 export type VoiceScenarioEvalSessionResult = {

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export { createVoiceAssistant, createVoiceExperiment, summarizeVoiceAssistantRun
 export { createVoiceAssistantHealthHTMLHandler, createVoiceAssistantHealthJSONHandler, createVoiceAssistantHealthRoutes, renderVoiceAssistantHealthHTML, summarizeVoiceAssistantHealth } from './assistantHealth';
 export { buildVoiceDiagnosticsMarkdown, createVoiceDiagnosticsRoutes, resolveVoiceDiagnosticsTraceFilter } from './diagnosticsRoutes';
 export { compareVoiceEvalBaseline, createVoiceFileEvalBaselineStore, createVoiceFileScenarioFixtureStore, createVoiceEvalRoutes, renderVoiceEvalBaselineHTML, renderVoiceEvalHTML, renderVoiceScenarioEvalHTML, renderVoiceScenarioFixtureEvalHTML, runVoiceScenarioEvals, runVoiceScenarioFixtureEvals, runVoiceSessionEvals } from './evalRoutes';
+export { createVoiceWorkflowContract, createVoiceWorkflowContractHandler, createVoiceWorkflowScenario, recordVoiceWorkflowContractTrace, validateVoiceWorkflowRouteResult } from './workflowContract';
 export { createVoiceSessionListRoutes, createVoiceSessionReplayHTMLHandler, createVoiceSessionReplayJSONHandler, createVoiceSessionReplayRoutes, createVoiceSessionsHTMLHandler, createVoiceSessionsJSONHandler, renderVoiceSessionsHTML, summarizeVoiceSessions, summarizeVoiceSessionReplay } from './sessionReplay';
 export { createVoiceAgent, createVoiceAgentSquad, createVoiceAgentTool } from './agent';
 export { createStoredVoiceCallReviewArtifact, createStoredVoiceExternalObjectMap, createStoredVoiceIntegrationEvent, createStoredVoiceOpsTask, createVoiceFileExternalObjectMapStore, createVoiceFileAssistantMemoryStore, createVoiceFileIntegrationEventStore, createVoiceFileReviewStore, createVoiceFileRuntimeStorage, createVoiceFileSessionStore, createVoiceFileTaskStore, createVoiceFileTraceSinkDeliveryStore, createVoiceFileTraceEventStore } from './fileStore';
@@ -41,6 +42,7 @@ export type { VoiceAssistantHealthFailure, VoiceAssistantHealthHTMLHandlerOption
 export type { VoiceAssistantMemoryBinding, VoiceAssistantMemoryHandle, VoiceAssistantMemoryOptions, VoiceAssistantMemoryRecord, VoiceAssistantMemoryStore } from './assistantMemory';
 export type { VoiceDiagnosticsRoutesOptions } from './diagnosticsRoutes';
 export type { VoiceEvalBaselineComparison, VoiceEvalBaselineComparisonOptions, VoiceEvalBaselineStore, VoiceEvalBaselineSummary, VoiceEvalLink, VoiceEvalReport, VoiceEvalRoutesOptions, VoiceEvalSessionReport, VoiceEvalStatus, VoiceEvalTrendBucket, VoiceScenarioEvalDefinition, VoiceScenarioEvalReport, VoiceScenarioEvalResult, VoiceScenarioEvalSessionResult, VoiceScenarioFixture, VoiceScenarioFixtureEvalReport, VoiceScenarioFixtureEvalResult, VoiceScenarioFixtureStore } from './evalRoutes';
+export type { VoiceWorkflowContract, VoiceWorkflowContractDefinition, VoiceWorkflowContractField, VoiceWorkflowContractFieldMatch, VoiceWorkflowContractTracePayload, VoiceWorkflowContractValidation, VoiceWorkflowContractValidationIssue, VoiceWorkflowOutcome } from './workflowContract';
 export type { VoiceSessionListHTMLHandlerOptions, VoiceSessionListItem, VoiceSessionListOptions, VoiceSessionListRoutesOptions, VoiceSessionListStatus, VoiceSessionReplay, VoiceSessionReplayHTMLHandlerOptions, VoiceSessionReplayOptions, VoiceSessionReplayRoutesOptions, VoiceSessionReplayTurn } from './sessionReplay';
 export type { AnthropicVoiceAssistantModelOptions, GeminiVoiceAssistantModelOptions, OpenAIVoiceAssistantModelOptions, VoiceProviderRouterEvent, VoiceProviderRouterFallbackMode, VoiceProviderRouterHealthOptions, VoiceProviderRouterOptions, VoiceProviderRouterPolicy, VoiceProviderRouterProviderHealth, VoiceProviderRouterProviderProfile, VoiceJSONAssistantModelHandler, VoiceJSONAssistantModelOptions } from './modelAdapters';
 export type { VoiceProviderHealthStatus, VoiceProviderHealthSummary, VoiceProviderHealthSummaryOptions } from './providerHealth';

package/dist/index.js

@@ -8078,6 +8078,7 @@ var evaluateScenarioSession = (scenario, sessionId, events) => {
   const turnCount = events.filter((event) => event.type === "turn.committed").length;
   const sessionErrorCount = events.filter((event) => event.type === "session.error").length;
   const providerErrorCount = countProviderErrors(events);
+  const workflowContractEvents = events.filter((event) => event.type === "workflow.contract");
   for (const missing of includesAll(committedText, scenario.requiredTranscriptIncludes ?? [])) {
     issues.push(`Missing transcript text: ${missing}`);
   }
@@ -8121,6 +8122,16 @@ var evaluateScenarioSession = (scenario, sessionId, events) => {
       issues.push(`Missing payload path: ${path}`);
     }
   }
+  for (const contractId of scenario.requiredWorkflowContracts ?? []) {
+    const matching = workflowContractEvents.filter((event) => getString6(event.payload.contractId) === contractId);
+    if (matching.length === 0) {
+      issues.push(`Missing workflow contract: ${contractId}`);
+      continue;
+    }
+    if (matching.some((event) => getString6(event.payload.status) !== "pass")) {
+      issues.push(`Workflow contract failed: ${contractId}`);
+    }
+  }
   return {
     eventCount: events.length,
     issues,
@@ -8443,6 +8454,154 @@ var createVoiceEvalRoutes = (options) => {
   });
   return routes;
 };
+// src/workflowContract.ts
+var getObject2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+var getPathValue2 = (value, path) => {
+  let current = value;
+  for (const part of path.split(".").filter(Boolean)) {
+    const record = getObject2(current);
+    if (!record || !(part in record)) {
+      return;
+    }
+    current = record[part];
+  }
+  return current;
+};
+var hasValue = (value, match) => {
+  switch (match) {
+    case "boolean":
+      return typeof value === "boolean";
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "string":
+      return typeof value === "string";
+    case "truthy":
+      return Boolean(value);
+    case "non-empty":
+    default:
+      return Array.isArray(value) ? value.length > 0 : typeof value === "string" ? value.trim().length > 0 : value !== undefined && value !== null;
+  }
+};
+var resolveOutcome2 = (routeResult) => {
+  if (routeResult.complete)
+    return "complete";
+  if (routeResult.transfer)
+    return "transfer";
+  if (routeResult.escalate)
+    return "escalate";
+  if (routeResult.voicemail)
+    return "voicemail";
+  if (routeResult.noAnswer)
+    return "no-answer";
+  return;
+};
+var validateVoiceWorkflowRouteResult = (definition, routeResult) => {
+  const issues = [];
+  const requiredFields = (definition.fields ?? []).filter((field) => field.required !== false).map((field) => field.path);
+  const missingFields = [];
+  const outcome = resolveOutcome2(routeResult);
+  if (definition.outcome && outcome !== definition.outcome) {
+    issues.push({
+      code: "workflow.outcome_mismatch",
+      message: `Expected workflow outcome ${definition.outcome}, saw ${outcome ?? "none"}.`
+    });
+  }
+  for (const field of definition.fields ?? []) {
+    if (field.required === false)
+      continue;
+    const paths = [field.path, ...field.aliases ?? []];
+    const present = paths.some((path) => hasValue(getPathValue2(routeResult.result, path), field.match ?? "non-empty"));
+    if (!present) {
+      missingFields.push(field.path);
+      issues.push({
+        code: "workflow.missing_field",
+        field: field.path,
+        message: `Missing required workflow field: ${field.label ?? field.path}.`
+      });
+    }
+  }
+  issues.push(...definition.validate?.({
+    result: routeResult.result,
+    routeResult
+  }) ?? []);
+  return {
+    contractId: definition.id,
+    issues,
+    missingFields,
+    outcome,
+    pass: issues.length === 0,
+    requiredFields
+  };
+};
+var createVoiceWorkflowScenario = (definition, overrides = {}) => ({
+  description: definition.description,
+  forbiddenHandoffActions: definition.forbiddenHandoffActions,
+  id: definition.id,
+  label: definition.label,
+  maxProviderErrors: definition.maxProviderErrors,
+  maxSessionErrors: definition.maxSessionErrors,
+  minSessions: definition.minSessions,
+  minTurns: definition.minTurns,
+  requiredAssistantIncludes: definition.requiredAssistantIncludes,
+  requiredDisposition: definition.requiredDisposition,
+  requiredHandoffActions: definition.requiredHandoffActions,
+  requiredLifecycleTypes: definition.requiredLifecycleTypes,
+  requiredTranscriptIncludes: definition.requiredTranscriptIncludes,
+  requiredWorkflowContracts: [definition.id],
+  scenarioId: definition.scenarioId,
+  ...overrides
+});
+var createVoiceWorkflowContract = (definition) => ({
+  assertRouteResult: (routeResult) => {
+    const validation = validateVoiceWorkflowRouteResult(definition, routeResult);
+    if (!validation.pass) {
+      throw new Error(`Voice workflow contract ${definition.id} failed: ${validation.issues.map((issue) => issue.message).join(" ")}`);
+    }
+  },
+  definition,
+  toScenarioEval: (overrides) => createVoiceWorkflowScenario(definition, overrides),
+  validateRouteResult: (routeResult) => validateVoiceWorkflowRouteResult(definition, routeResult)
+});
+var recordVoiceWorkflowContractTrace = async (input) => input.store.append({
+  at: input.at ?? Date.now(),
+  payload: {
+    contractId: input.contractId ?? input.validation.contractId,
+    issues: input.validation.issues,
+    missingFields: input.validation.missingFields,
+    outcome: input.validation.outcome,
+    requiredFields: input.validation.requiredFields,
+    status: input.validation.pass ? "pass" : "fail"
+  },
+  scenarioId: input.scenarioId,
+  sessionId: input.sessionId,
+  traceId: input.traceId,
+  turnId: input.turnId,
+  type: "workflow.contract"
+});
+var createVoiceWorkflowContractHandler = (input) => {
+  return async (session, turn, api, context) => {
+    const legacyHandler = input.handler;
+    const objectHandler = input.handler;
+    const result = input.handler.length >= 4 ? await legacyHandler(session, turn, api, context) : await objectHandler({ api, context, session, turn });
+    if (!result)
+      return result;
+    const resolved = input.resolveContract?.({ context, result, session, turn }) ?? input.contract;
+    if (!resolved)
+      return result;
+    const contract = "validateRouteResult" in resolved ? resolved : createVoiceWorkflowContract(resolved);
+    const validation = contract.validateRouteResult(result);
+    if (input.store) {
+      await recordVoiceWorkflowContractTrace({
+        scenarioId: session.scenarioId,
+        sessionId: session.id,
+        store: input.store,
+        turnId: turn.id,
+        validation
+      });
+    }
+    return result;
+  };
+};
 // src/sessionReplay.ts
 import { Elysia as Elysia8 } from "elysia";
 var getString7 = (value) => typeof value === "string" ? value : undefined;
@@ -13368,6 +13527,7 @@ export {
   withVoiceIntegrationEventId,
   voice,
   verifyVoiceOpsWebhookSignature,
+  validateVoiceWorkflowRouteResult,
   transcodeTwilioInboundPayloadToPCM16,
   transcodePCMToTwilioOutboundPayload,
   summarizeVoiceTraceSinkDeliveries,
@@ -13421,6 +13581,7 @@ export {
   redactVoiceTraceText,
   redactVoiceTraceEvents,
   redactVoiceTraceEvent,
+  recordVoiceWorkflowContractTrace,
   recordVoiceRuntimeOps,
   pruneVoiceTraceEvents,
   matchesVoiceOpsTaskAssignmentRule,
@@ -13446,6 +13607,9 @@ export {
   createVoiceZendeskTicketUpdateSink,
   createVoiceZendeskTicketSyncSinks,
   createVoiceZendeskTicketSink,
+  createVoiceWorkflowScenario,
+  createVoiceWorkflowContractHandler,
+  createVoiceWorkflowContract,
   createVoiceWebhookHandoffAdapter,
   createVoiceWebhookDeliveryWorkerLoop,
   createVoiceWebhookDeliveryWorker,

package/dist/trace.d.ts

@@ -1,4 +1,4 @@
-export type VoiceTraceEventType = 'assistant.guardrail' | 'assistant.memory' | 'assistant.run' | 'agent.handoff' | 'agent.model' | 'agent.result' | 'agent.tool' | 'call.handoff' | 'call.lifecycle' | 'session.error' | 'turn.assistant' | 'turn.committed' | 'turn.cost' | 'turn.transcript';
+export type VoiceTraceEventType = 'assistant.guardrail' | 'assistant.memory' | 'assistant.run' | 'agent.handoff' | 'agent.model' | 'agent.result' | 'agent.tool' | 'call.handoff' | 'call.lifecycle' | 'session.error' | 'turn.assistant' | 'turn.committed' | 'turn.cost' | 'turn.transcript' | 'workflow.contract';
 export type VoiceTraceEvent<TPayload extends Record<string, unknown> = Record<string, unknown>> = {
     at: number;
     id?: string;

package/dist/workflowContract.d.ts

@@ -0,0 +1,85 @@
+import type { VoiceScenarioEvalDefinition } from './evalRoutes';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+import type { VoiceOnTurnHandler, VoiceRouteResult, VoiceSessionRecord, VoiceTurnRecord } from './types';
+export type VoiceWorkflowOutcome = 'complete' | 'transfer' | 'escalate' | 'voicemail' | 'no-answer';
+export type VoiceWorkflowContractFieldMatch = 'boolean' | 'non-empty' | 'number' | 'string' | 'truthy';
+export type VoiceWorkflowContractField = {
+    aliases?: string[];
+    label?: string;
+    match?: VoiceWorkflowContractFieldMatch;
+    path: string;
+    required?: boolean;
+};
+export type VoiceWorkflowContractDefinition<TResult = unknown> = {
+    description?: string;
+    fields?: VoiceWorkflowContractField[];
+    forbiddenHandoffActions?: string[];
+    id: string;
+    label?: string;
+    maxProviderErrors?: number;
+    maxSessionErrors?: number;
+    minSessions?: number;
+    minTurns?: number;
+    outcome?: VoiceWorkflowOutcome;
+    requiredAssistantIncludes?: string[];
+    requiredDisposition?: string;
+    requiredHandoffActions?: string[];
+    requiredLifecycleTypes?: string[];
+    requiredTranscriptIncludes?: string[];
+    scenarioId?: string;
+    validate?: (input: {
+        result: TResult | undefined;
+        routeResult: VoiceRouteResult<TResult>;
+    }) => VoiceWorkflowContractValidationIssue[];
+};
+export type VoiceWorkflowContractValidationIssue = {
+    code: string;
+    field?: string;
+    message: string;
+};
+export type VoiceWorkflowContractValidation = {
+    contractId: string;
+    issues: VoiceWorkflowContractValidationIssue[];
+    missingFields: string[];
+    outcome?: VoiceWorkflowOutcome;
+    pass: boolean;
+    requiredFields: string[];
+};
+export type VoiceWorkflowContract<TResult = unknown> = {
+    assertRouteResult: (routeResult: VoiceRouteResult<TResult>) => void;
+    definition: VoiceWorkflowContractDefinition<TResult>;
+    toScenarioEval: (overrides?: Partial<VoiceScenarioEvalDefinition>) => VoiceScenarioEvalDefinition;
+    validateRouteResult: (routeResult: VoiceRouteResult<TResult>) => VoiceWorkflowContractValidation;
+};
+export type VoiceWorkflowContractTracePayload = {
+    contractId: string;
+    issues: VoiceWorkflowContractValidationIssue[];
+    missingFields: string[];
+    outcome?: VoiceWorkflowOutcome;
+    requiredFields: string[];
+    status: 'pass' | 'fail';
+};
+export declare const validateVoiceWorkflowRouteResult: <TResult = unknown>(definition: VoiceWorkflowContractDefinition<TResult>, routeResult: VoiceRouteResult<TResult>) => VoiceWorkflowContractValidation;
+export declare const createVoiceWorkflowScenario: <TResult = unknown>(definition: VoiceWorkflowContractDefinition<TResult>, overrides?: Partial<VoiceScenarioEvalDefinition>) => VoiceScenarioEvalDefinition;
+export declare const createVoiceWorkflowContract: <TResult = unknown>(definition: VoiceWorkflowContractDefinition<TResult>) => VoiceWorkflowContract<TResult>;
+export declare const recordVoiceWorkflowContractTrace: (input: {
+    at?: number;
+    contractId?: string;
+    scenarioId?: string;
+    sessionId: string;
+    store: VoiceTraceEventStore;
+    traceId?: string;
+    turnId?: string;
+    validation: VoiceWorkflowContractValidation;
+}) => Promise<StoredVoiceTraceEvent<VoiceWorkflowContractTracePayload>>;
+export declare const createVoiceWorkflowContractHandler: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(input: {
+    contract?: VoiceWorkflowContract<TResult> | VoiceWorkflowContractDefinition<TResult>;
+    handler: VoiceOnTurnHandler<TContext, TSession, TResult>;
+    resolveContract?: (args: {
+        context: TContext;
+        result: VoiceRouteResult<TResult>;
+        session: TSession;
+        turn: VoiceTurnRecord;
+    }) => VoiceWorkflowContract<TResult> | VoiceWorkflowContractDefinition<TResult> | undefined;
+    store?: VoiceTraceEventStore;
+}) => VoiceOnTurnHandler<TContext, TSession, TResult>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/voice",
-	"version": "0.0.22-beta.45",
+	"version": "0.0.22-beta.46",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",