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

package/dist/angular/index.d.ts

@@ -1,3 +1,4 @@
 export { VoiceStreamService } from './voice-stream.service';
 export { VoiceControllerService } from './voice-controller.service';
 export { VoiceProviderStatusService } from './voice-provider-status.service';
+export { VoiceWorkflowStatusService } from './voice-workflow-status.service';

package/dist/angular/index.js

@@ -1457,7 +1457,132 @@ VoiceProviderStatusService = __decorateElement(_init, 0, "VoiceProviderStatusSer
 __runInitializers(_init, 1, VoiceProviderStatusService);
 __decoratorMetadata(_init, VoiceProviderStatusService);
 let _VoiceProviderStatusService = VoiceProviderStatusService;
+// src/angular/voice-workflow-status.service.ts
+import { computed as computed4, Injectable as Injectable4, signal as signal4 } from "@angular/core";
+
+// src/client/workflowStatus.ts
+var fetchVoiceWorkflowStatus = async (path = "/evals/scenarios/json", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice workflow status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceWorkflowStatusStore = (path = "/evals/scenarios/json", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const report = await fetchVoiceWorkflowStatus(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        report,
+        updatedAt: Date.now()
+      };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (typeof window !== "undefined" && options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/angular/voice-workflow-status.service.ts
+var _dec = [
+  Injectable4({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceWorkflowStatusService {
+  connect(path = "/evals/scenarios/json", options = {}) {
+    const store = createVoiceWorkflowStatusStore(path, options);
+    const errorSignal = signal4(null);
+    const isLoadingSignal = signal4(false);
+    const reportSignal = signal4(undefined);
+    const updatedAtSignal = signal4(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      reportSignal.set(snapshot.report);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    if (typeof window !== "undefined") {
+      store.refresh().catch(() => {});
+    }
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed4(() => errorSignal()),
+      isLoading: computed4(() => isLoadingSignal()),
+      refresh: store.refresh,
+      report: computed4(() => reportSignal()),
+      updatedAt: computed4(() => updatedAtSignal())
+    };
+  }
+}
+VoiceWorkflowStatusService = __decorateElement(_init, 0, "VoiceWorkflowStatusService", _dec, VoiceWorkflowStatusService);
+__runInitializers(_init, 1, VoiceWorkflowStatusService);
+__decoratorMetadata(_init, VoiceWorkflowStatusService);
+let _VoiceWorkflowStatusService = VoiceWorkflowStatusService;
 export {
+  VoiceWorkflowStatusService,
   VoiceStreamService,
   VoiceProviderStatusService,
   VoiceControllerService

package/dist/angular/voice-workflow-status.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceWorkflowStatusClientOptions } from '../client/workflowStatus';
+import type { VoiceScenarioEvalReport } from '../evalRoutes';
+export declare class VoiceWorkflowStatusService {
+    connect(path?: string, options?: VoiceWorkflowStatusClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        refresh: () => Promise<VoiceScenarioEvalReport | undefined>;
+        report: import("@angular/core").Signal<VoiceScenarioEvalReport | undefined>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/client/index.d.ts

@@ -6,4 +6,6 @@ export { bindVoiceBargeIn, createVoiceDuplexController } from './duplex';
 export { bindVoiceHTMX } from './htmx';
 export { createMicrophoneCapture } from './microphone';
 export { createVoiceProviderStatusStore, fetchVoiceProviderStatus } from './providerStatus';
+export { createVoiceWorkflowStatusStore, fetchVoiceWorkflowStatus } from './workflowStatus';
 export type { VoiceProviderStatusClientOptions, VoiceProviderStatusSnapshot } from './providerStatus';
+export type { VoiceWorkflowStatusClientOptions, VoiceWorkflowStatusSnapshot } from './workflowStatus';

package/dist/client/index.js

@@ -1702,9 +1702,89 @@ var createVoiceProviderStatusStore = (path = "/api/provider-status", options = {
     }
   };
 };
+// src/client/workflowStatus.ts
+var fetchVoiceWorkflowStatus = async (path = "/evals/scenarios/json", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice workflow status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceWorkflowStatusStore = (path = "/evals/scenarios/json", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const report = await fetchVoiceWorkflowStatus(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        report,
+        updatedAt: Date.now()
+      };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (typeof window !== "undefined" && options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
 export {
+  fetchVoiceWorkflowStatus,
   fetchVoiceProviderStatus,
   decodeVoiceAudioChunk,
+  createVoiceWorkflowStatusStore,
   createVoiceStream,
   createVoiceProviderStatusStore,
   createVoiceDuplexController,

package/dist/client/workflowStatus.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceScenarioEvalReport } from '../evalRoutes';
+export type VoiceWorkflowStatusClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceWorkflowStatusSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceScenarioEvalReport;
+    updatedAt?: number;
+};
+export declare const fetchVoiceWorkflowStatus: (path?: string, options?: Pick<VoiceWorkflowStatusClientOptions, "fetch">) => Promise<VoiceScenarioEvalReport>;
+export declare const createVoiceWorkflowStatusStore: (path?: string, options?: VoiceWorkflowStatusClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceWorkflowStatusSnapshot;
+    getSnapshot: () => VoiceWorkflowStatusSnapshot;
+    refresh: () => Promise<VoiceScenarioEvalReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/index.d.ts

@@ -3,7 +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 { createVoiceWorkflowContract, createVoiceWorkflowContractHandler, createVoiceWorkflowContractPreset, 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';
@@ -42,7 +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 { VoiceWorkflowContract, VoiceWorkflowContractDefinition, VoiceWorkflowContractField, VoiceWorkflowContractFieldMatch, VoiceWorkflowContractPresetName, VoiceWorkflowContractPresetOptions, 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

@@ -8562,6 +8562,152 @@ var createVoiceWorkflowContract = (definition) => ({
   toScenarioEval: (overrides) => createVoiceWorkflowScenario(definition, overrides),
   validateRouteResult: (routeResult) => validateVoiceWorkflowRouteResult(definition, routeResult)
 });
+var presetDefinitions = {
+  "appointment-booking": {
+    description: "Appointment booking should complete with enough identity, appointment, and follow-up details to act on.",
+    fields: [
+      { aliases: ["name", "customer.name"], label: "Caller name", path: "caller.name" },
+      {
+        aliases: ["phone", "customer.phone"],
+        label: "Caller phone",
+        path: "caller.phone"
+      },
+      {
+        aliases: ["appointment.start", "appointment.time", "scheduledAt"],
+        label: "Appointment time",
+        path: "appointment.startsAt"
+      },
+      {
+        aliases: ["summary", "assistantSummary"],
+        label: "Summary",
+        path: "appointment.summary"
+      }
+    ],
+    id: "appointment-booking",
+    label: "Appointment booking",
+    outcome: "complete",
+    requiredDisposition: "completed"
+  },
+  "lead-qualification": {
+    description: "Lead qualification should complete with contact, need, qualification, and next-step fields.",
+    fields: [
+      { aliases: ["name", "lead.name"], label: "Lead name", path: "contact.name" },
+      {
+        aliases: ["email", "lead.email"],
+        label: "Lead email",
+        path: "contact.email"
+      },
+      {
+        aliases: ["need", "pain", "summary"],
+        label: "Need",
+        path: "qualification.need"
+      },
+      {
+        aliases: ["qualified", "qualification.qualified"],
+        label: "Qualified",
+        match: "boolean",
+        path: "qualification.isQualified"
+      },
+      {
+        aliases: ["nextStep", "followUp"],
+        label: "Next step",
+        path: "qualification.nextStep"
+      }
+    ],
+    id: "lead-qualification",
+    label: "Lead qualification",
+    outcome: "complete",
+    requiredDisposition: "completed"
+  },
+  "support-triage": {
+    description: "Support triage should capture identity, issue summary, severity, and the operational follow-up.",
+    fields: [
+      {
+        aliases: ["name", "customer.name"],
+        label: "Customer name",
+        path: "customer.name"
+      },
+      {
+        aliases: ["issue", "summary", "assistantSummary"],
+        label: "Issue summary",
+        path: "issue.summary"
+      },
+      {
+        aliases: ["priority", "severity"],
+        label: "Severity",
+        path: "issue.severity"
+      },
+      {
+        aliases: ["nextStep", "task.title"],
+        label: "Next step",
+        path: "resolution.nextStep"
+      }
+    ],
+    id: "support-triage",
+    label: "Support triage",
+    outcome: "complete",
+    requiredDisposition: "completed"
+  },
+  "transfer-handoff": {
+    description: "Transfer handoff should produce a routed transfer plus handoff evidence.",
+    fields: [
+      {
+        aliases: ["target", "callTarget"],
+        label: "Transfer target",
+        path: "transfer.target"
+      },
+      {
+        aliases: ["reason", "callReason"],
+        label: "Transfer reason",
+        path: "transfer.reason"
+      },
+      {
+        aliases: ["summary", "assistantSummary"],
+        label: "Transfer summary",
+        path: "transfer.summary"
+      }
+    ],
+    id: "transfer-handoff",
+    label: "Transfer handoff",
+    outcome: "transfer",
+    requiredDisposition: "transferred",
+    requiredHandoffActions: ["transfer"]
+  },
+  "voicemail-callback": {
+    description: "Voicemail callback should preserve enough caller and callback context for follow-up.",
+    fields: [
+      {
+        aliases: ["name", "caller.name"],
+        label: "Caller name",
+        path: "voicemail.callerName"
+      },
+      {
+        aliases: ["phone", "caller.phone"],
+        label: "Callback phone",
+        path: "voicemail.callbackPhone"
+      },
+      {
+        aliases: ["message", "summary", "assistantSummary"],
+        label: "Voicemail summary",
+        path: "voicemail.summary"
+      }
+    ],
+    id: "voicemail-callback",
+    label: "Voicemail callback",
+    outcome: "voicemail",
+    requiredDisposition: "voicemail",
+    requiredHandoffActions: ["voicemail"]
+  }
+};
+var createVoiceWorkflowContractPreset = (name, options = {}) => {
+  const preset = presetDefinitions[name];
+  return createVoiceWorkflowContract({
+    ...preset,
+    ...options,
+    fields: options.fields ?? preset.fields,
+    id: options.id ?? preset.id
+  });
+};
 var recordVoiceWorkflowContractTrace = async (input) => input.store.append({
   at: input.at ?? Date.now(),
   payload: {
@@ -13608,6 +13754,7 @@ export {
   createVoiceZendeskTicketSyncSinks,
   createVoiceZendeskTicketSink,
   createVoiceWorkflowScenario,
+  createVoiceWorkflowContractPreset,
   createVoiceWorkflowContractHandler,
   createVoiceWorkflowContract,
   createVoiceWebhookHandoffAdapter,

package/dist/react/index.d.ts

@@ -1,3 +1,4 @@
 export { useVoiceStream } from './useVoiceStream';
 export { useVoiceController } from './useVoiceController';
 export { useVoiceProviderStatus } from './useVoiceProviderStatus';
+export { useVoiceWorkflowStatus } from './useVoiceWorkflowStatus';

package/dist/react/index.js

@@ -1379,7 +1379,106 @@ var useVoiceProviderStatus = (path = "/api/provider-status", options = {}) => {
     refresh: store.refresh
   };
 };
+// src/react/useVoiceWorkflowStatus.tsx
+import { useEffect as useEffect4, useRef as useRef4, useSyncExternalStore as useSyncExternalStore4 } from "react";
+
+// src/client/workflowStatus.ts
+var fetchVoiceWorkflowStatus = async (path = "/evals/scenarios/json", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice workflow status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceWorkflowStatusStore = (path = "/evals/scenarios/json", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const report = await fetchVoiceWorkflowStatus(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        report,
+        updatedAt: Date.now()
+      };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (typeof window !== "undefined" && options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/react/useVoiceWorkflowStatus.tsx
+var useVoiceWorkflowStatus = (path = "/evals/scenarios/json", options = {}) => {
+  const storeRef = useRef4(null);
+  if (!storeRef.current) {
+    storeRef.current = createVoiceWorkflowStatusStore(path, options);
+  }
+  const store = storeRef.current;
+  useEffect4(() => {
+    store.refresh().catch(() => {});
+    return () => store.close();
+  }, [store]);
+  return {
+    ...useSyncExternalStore4(store.subscribe, store.getSnapshot, store.getServerSnapshot),
+    refresh: store.refresh
+  };
+};
 export {
+  useVoiceWorkflowStatus,
   useVoiceStream,
   useVoiceProviderStatus,
   useVoiceController

package/dist/react/useVoiceWorkflowStatus.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceWorkflowStatusClientOptions } from '../client/workflowStatus';
+export declare const useVoiceWorkflowStatus: (path?: string, options?: VoiceWorkflowStatusClientOptions) => {
+    refresh: () => Promise<import("..").VoiceScenarioEvalReport | undefined>;
+    error: string | null;
+    isLoading: boolean;
+    report?: import("..").VoiceScenarioEvalReport;
+    updatedAt?: number;
+};

package/dist/svelte/createVoiceWorkflowStatus.d.ts

@@ -0,0 +1,8 @@
+import type { VoiceWorkflowStatusClientOptions } from '../client/workflowStatus';
+export declare const createVoiceWorkflowStatus: (path?: string, options?: VoiceWorkflowStatusClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => import("../client").VoiceWorkflowStatusSnapshot;
+    getSnapshot: () => import("../client").VoiceWorkflowStatusSnapshot;
+    refresh: () => Promise<import("..").VoiceScenarioEvalReport | undefined>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/index.d.ts

@@ -1,3 +1,4 @@
 export { createVoiceStream } from './createVoiceStream';
 export { createVoiceProviderStatus } from './createVoiceProviderStatus';
+export { createVoiceWorkflowStatus } from './createVoiceWorkflowStatus';
 export { createVoiceController } from '../client/controller';

package/dist/svelte/index.js

@@ -666,6 +666,87 @@ var createVoiceProviderStatusStore = (path = "/api/provider-status", options = {
 
 // src/svelte/createVoiceProviderStatus.ts
 var createVoiceProviderStatus = (path = "/api/provider-status", options = {}) => createVoiceProviderStatusStore(path, options);
+// src/client/workflowStatus.ts
+var fetchVoiceWorkflowStatus = async (path = "/evals/scenarios/json", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice workflow status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceWorkflowStatusStore = (path = "/evals/scenarios/json", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const report = await fetchVoiceWorkflowStatus(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        report,
+        updatedAt: Date.now()
+      };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (typeof window !== "undefined" && options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/svelte/createVoiceWorkflowStatus.ts
+var createVoiceWorkflowStatus = (path = "/evals/scenarios/json", options = {}) => createVoiceWorkflowStatusStore(path, options);
 // src/client/htmx.ts
 var DEFAULT_EVENT_NAME = "voice-refresh";
 var DEFAULT_QUERY_PARAM = "sessionId";
@@ -1296,6 +1377,7 @@ var createVoiceController = (path, options = {}) => {
   };
 };
 export {
+  createVoiceWorkflowStatus,
   createVoiceStream2 as createVoiceStream,
   createVoiceProviderStatus,
   createVoiceController

package/dist/vue/index.d.ts

@@ -1,3 +1,4 @@
 export { useVoiceStream } from './useVoiceStream';
 export { useVoiceController } from './useVoiceController';
 export { useVoiceProviderStatus } from './useVoiceProviderStatus';
+export { useVoiceWorkflowStatus } from './useVoiceWorkflowStatus';

package/dist/vue/index.js

@@ -1428,7 +1428,121 @@ var useVoiceProviderStatus = (path = "/api/provider-status", options = {}) => {
     updatedAt
   };
 };
+// src/vue/useVoiceWorkflowStatus.ts
+import { onUnmounted as onUnmounted4, ref as ref4, shallowRef as shallowRef4 } from "vue";
+
+// src/client/workflowStatus.ts
+var fetchVoiceWorkflowStatus = async (path = "/evals/scenarios/json", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice workflow status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceWorkflowStatusStore = (path = "/evals/scenarios/json", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.report;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const report = await fetchVoiceWorkflowStatus(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        report,
+        updatedAt: Date.now()
+      };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (typeof window !== "undefined" && options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/vue/useVoiceWorkflowStatus.ts
+var useVoiceWorkflowStatus = (path = "/evals/scenarios/json", options = {}) => {
+  const store = createVoiceWorkflowStatusStore(path, options);
+  const error = ref4(null);
+  const isLoading = ref4(false);
+  const report = shallowRef4(undefined);
+  const updatedAt = ref4(undefined);
+  const sync = () => {
+    const snapshot = store.getSnapshot();
+    error.value = snapshot.error;
+    isLoading.value = snapshot.isLoading;
+    report.value = snapshot.report;
+    updatedAt.value = snapshot.updatedAt;
+  };
+  const unsubscribe = store.subscribe(sync);
+  sync();
+  if (typeof window !== "undefined") {
+    store.refresh().catch(() => {});
+  }
+  onUnmounted4(() => {
+    unsubscribe();
+    store.close();
+  });
+  return {
+    error,
+    isLoading,
+    refresh: store.refresh,
+    report,
+    updatedAt
+  };
+};
 export {
+  useVoiceWorkflowStatus,
   useVoiceStream,
   useVoiceProviderStatus,
   useVoiceController

package/dist/vue/useVoiceWorkflowStatus.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceWorkflowStatusClientOptions } from '../client/workflowStatus';
+import type { VoiceScenarioEvalReport } from '../evalRoutes';
+export declare const useVoiceWorkflowStatus: (path?: string, options?: VoiceWorkflowStatusClientOptions) => {
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    refresh: () => Promise<VoiceScenarioEvalReport | undefined>;
+    report: import("vue").ShallowRef<VoiceScenarioEvalReport | undefined, VoiceScenarioEvalReport | undefined>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/dist/workflowContract.d.ts

@@ -32,6 +32,11 @@ export type VoiceWorkflowContractDefinition<TResult = unknown> = {
         routeResult: VoiceRouteResult<TResult>;
     }) => VoiceWorkflowContractValidationIssue[];
 };
+export type VoiceWorkflowContractPresetName = 'appointment-booking' | 'lead-qualification' | 'support-triage' | 'transfer-handoff' | 'voicemail-callback';
+export type VoiceWorkflowContractPresetOptions<TResult = unknown> = Partial<Omit<VoiceWorkflowContractDefinition<TResult>, 'fields' | 'id'>> & {
+    fields?: VoiceWorkflowContractField[];
+    id?: string;
+};
 export type VoiceWorkflowContractValidationIssue = {
     code: string;
     field?: string;
@@ -62,6 +67,7 @@ export type VoiceWorkflowContractTracePayload = {
 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 createVoiceWorkflowContractPreset: <TResult = unknown>(name: VoiceWorkflowContractPresetName, options?: VoiceWorkflowContractPresetOptions<TResult>) => VoiceWorkflowContract<TResult>;
 export declare const recordVoiceWorkflowContractTrace: (input: {
     at?: number;
     contractId?: string;

package/package.json

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