@absolutejs/voice 0.0.22-beta.23 → 0.0.22-beta.25

package/dist/index.d.ts

@@ -13,6 +13,7 @@ export { createVoicePostgresExternalObjectMapStore, createVoicePostgresIntegrati
 export { createVoiceS3ReviewStore } from './s3Store';
 export { createVoiceMemoryStore } from './memoryStore';
 export { createVoiceCRMActivitySink, createVoiceHelpdeskTicketSink, createVoiceIntegrationHTTPSink, createVoiceHubSpotTaskSink, createVoiceHubSpotTaskSyncSinks, createVoiceHubSpotTaskUpdateSink, createVoiceLinearIssueSink, createVoiceLinearIssueSyncSinks, createVoiceLinearIssueUpdateSink, createVoiceZendeskTicketSink, createVoiceZendeskTicketSyncSinks, createVoiceZendeskTicketUpdateSink, deliverVoiceIntegrationEventToSinks } from './opsSinks';
+export { createVoiceOpsWebhookEnvelope, createVoiceOpsWebhookReceiverRoutes, createVoiceOpsWebhookSink, verifyVoiceOpsWebhookSignature } from './opsWebhook';
 export { createVoiceIntegrationSinkWorker, createVoiceIntegrationSinkWorkerLoop, createVoiceOpsTaskWorker, createVoiceOpsTaskProcessorWorker, createVoiceOpsTaskProcessorWorkerLoop, createVoiceRedisIdempotencyStore, createVoiceRedisTaskLeaseCoordinator, createVoiceTraceSinkDeliveryWorker, createVoiceTraceSinkDeliveryWorkerLoop, createVoiceWebhookDeliveryWorker, createVoiceWebhookDeliveryWorkerLoop, summarizeVoiceTraceSinkDeliveries, summarizeVoiceOpsTaskQueue, summarizeVoiceIntegrationEvents } from './queue';
 export { assignVoiceOpsTask, applyVoiceOpsTaskAssignmentRule, applyVoiceOpsTaskPolicy, buildVoiceOpsTaskFromReview, buildVoiceOpsTaskFromSLABreach, claimVoiceOpsTask, completeVoiceOpsTask, createVoiceExternalObjectMap, createVoiceExternalObjectMapId, createVoiceCallCompletedEvent, createVoiceTaskSLABreachedEvent, deadLetterVoiceOpsTask, deliverVoiceIntegrationEvent, failVoiceOpsTask, hasVoiceOpsTaskSLABreach, heartbeatVoiceOpsTask, isVoiceOpsTaskOverdue, markVoiceOpsTaskSLABreached, matchesVoiceOpsTaskAssignmentRule, resolveVoiceOpsTaskAgeBucket, createVoiceIntegrationEvent, createVoiceReviewSavedEvent, resolveVoiceOpsTaskAssignment, resolveVoiceOpsTaskPolicy, requeueVoiceOpsTask, createVoiceTaskCreatedEvent, createVoiceTaskUpdatedEvent, listVoiceOpsTasks, reopenVoiceOpsTask, startVoiceOpsTask, summarizeVoiceOpsTaskAnalytics, summarizeVoiceOpsTasks, withVoiceIntegrationEventId, withVoiceOpsTaskId } from './ops';
 export { createVoiceSession } from './session';
@@ -38,6 +39,7 @@ export type { VoiceOpsRuntime, VoiceOpsRuntimeConfig, VoiceOpsRuntimeSummary, Vo
 export type { VoiceOpsPresetName, VoiceOpsPresetOverrides, VoiceResolvedOpsPreset } from './opsPresets';
 export type { VoiceOutcomeRecipe, VoiceOutcomeRecipeName, VoiceOutcomeRecipeOptions } from './outcomeRecipes';
 export type { VoiceCRMActivitySinkOptions, VoiceHubSpotTaskSinkOptions, VoiceHubSpotTaskUpdateSinkOptions, VoiceHelpdeskTicketSinkOptions, VoiceIntegrationHTTPSinkOptions, VoiceIntegrationSink, VoiceIntegrationSinkDeliveryResult, VoiceLinearIssueSinkOptions, VoiceLinearIssueUpdateSinkOptions, VoiceZendeskTicketSinkOptions, VoiceZendeskTicketUpdateSinkOptions } from './opsSinks';
+export type { VoiceOpsWebhookEnvelope, VoiceOpsWebhookEntity, VoiceOpsWebhookLinkResolver, VoiceOpsWebhookReceiverRoutesOptions, VoiceOpsWebhookSinkOptions, VoiceOpsWebhookVerificationResult } from './opsWebhook';
 export type { StoredVoiceCallReviewArtifact, VoiceCallReviewArtifact, VoiceCallReviewConfig, VoiceCallReviewPostCallSummary, VoiceCallReviewRecorder, VoiceCallReviewRecorderOptions, VoiceCallReviewStore, VoiceCallReviewSummary, VoiceCallReviewTimelineEvent } from './testing/review';
 export type { VoiceFileRuntimeStorage, VoiceFileStoreOptions } from './fileStore';
 export type { StoredVoiceTraceEvent, VoiceTraceEvaluation, VoiceTraceEvaluationOptions, VoiceTraceEvent, VoiceTraceEventFilter, VoiceTraceEventStore, VoiceTraceEventType, VoiceTraceIssue, VoiceTraceIssueSeverity, VoiceTraceHTTPSinkOptions, VoiceTracePruneFilter, VoiceTracePruneOptions, VoiceTracePruneResult, VoiceTraceRedactionConfig, VoiceTraceRedactionOptions, VoiceTraceRedactionReplacement, VoiceResolvedTraceRedactionOptions, VoiceTraceSink, VoiceTraceSinkDeliveryQueueStatus, VoiceTraceSinkDeliveryRecord, VoiceTraceSinkDeliveryResult, VoiceTraceSinkDeliveryStatus, VoiceTraceSinkDeliveryStore, VoiceTraceSinkFanoutResult, VoiceTraceSinkStoreOptions, VoiceTraceSummary } from './trace';

package/dist/index.js

@@ -7167,12 +7167,14 @@ var summarizeVoiceSessions = async (options = {}) => {
     const providerErrors = {};
     const providers = new Set;
     let latestOutcome;
+    let errorCount = 0;
     for (const event of sorted) {
       const provider = getString3(event.payload.provider);
       if (provider) {
         providers.add(provider);
       }
       if (event.type === "session.error" && (event.payload.providerStatus === "error" || typeof event.payload.error === "string")) {
+        errorCount += 1;
         increment2(providerErrors, provider ?? "unknown");
       }
       const outcome = getString3(event.payload.outcome);
@@ -7182,14 +7184,14 @@ var summarizeVoiceSessions = async (options = {}) => {
     }
     const item = {
       endedAt: summary.endedAt,
-      errorCount: summary.errorCount,
+      errorCount,
       eventCount: summary.eventCount,
       latestOutcome,
       providerErrors,
       providers: [...providers].sort(),
       sessionId,
       startedAt: summary.startedAt,
-      status: summary.failed ? "failed" : "healthy",
+      status: errorCount > 0 ? "failed" : "healthy",
       transcriptCount: summary.transcriptCount,
       turnCount: summary.turnCount
     };
@@ -8870,6 +8872,167 @@ var createVoiceMemoryStore = () => {
   };
   return { get, getOrCreate, list, remove, set };
 };
+// src/opsWebhook.ts
+import { Elysia as Elysia5 } from "elysia";
+var toHex4 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+var signVoiceOpsWebhookBody = async (input) => {
+  const encoder = new TextEncoder;
+  const key = await crypto.subtle.importKey("raw", encoder.encode(input.secret), {
+    hash: "SHA-256",
+    name: "HMAC"
+  }, false, ["sign"]);
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(`${input.timestamp}.${input.body}`));
+  return `sha256=${toHex4(new Uint8Array(signature))}`;
+};
+var timingSafeEqual = (left, right) => {
+  const encoder = new TextEncoder;
+  const leftBytes = encoder.encode(left);
+  const rightBytes = encoder.encode(right);
+  if (leftBytes.length !== rightBytes.length) {
+    return false;
+  }
+  let diff = 0;
+  for (let index = 0;index < leftBytes.length; index += 1) {
+    diff |= leftBytes[index] ^ rightBytes[index];
+  }
+  return diff === 0;
+};
+var resolveWebhookLink = async (resolver, event) => {
+  if (typeof resolver === "function") {
+    return resolver({
+      event
+    });
+  }
+  return resolver;
+};
+var joinBaseUrl = (baseUrl, path) => `${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+var asString = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
+var buildVoiceOpsWebhookEntity = (event) => ({
+  disposition: asString(event.payload.disposition),
+  outcome: asString(event.payload.outcome),
+  priority: asString(event.payload.priority),
+  queue: asString(event.payload.queue),
+  reviewId: asString(event.payload.reviewId),
+  scenarioId: asString(event.payload.scenarioId),
+  sessionId: asString(event.payload.sessionId),
+  status: asString(event.payload.status),
+  target: asString(event.payload.target),
+  taskId: asString(event.payload.taskId)
+});
+var createVoiceOpsWebhookEnvelope = async (input) => {
+  const entity = buildVoiceOpsWebhookEntity(input.event);
+  const replayHref = await resolveWebhookLink(input.replayHref, input.event) ?? (input.baseUrl && entity.sessionId ? joinBaseUrl(input.baseUrl, `/api/voice-sessions/${encodeURIComponent(entity.sessionId)}/replay`) : undefined);
+  const links = {
+    event: await resolveWebhookLink(input.eventHref, input.event),
+    replay: replayHref,
+    review: await resolveWebhookLink(input.reviewHref, input.event),
+    task: await resolveWebhookLink(input.taskHref, input.event)
+  };
+  return {
+    entity,
+    event: {
+      createdAt: input.event.createdAt,
+      id: input.event.id,
+      payload: input.event.payload,
+      type: input.event.type
+    },
+    links: links.event || links.replay || links.review || links.task ? links : undefined,
+    schemaVersion: 1,
+    source: "absolutejs-voice"
+  };
+};
+var createVoiceOpsWebhookSink = (options) => createVoiceIntegrationHTTPSink({
+  ...options,
+  body: ({ event }) => createVoiceOpsWebhookEnvelope({
+    baseUrl: options.baseUrl,
+    event,
+    eventHref: options.eventHref,
+    replayHref: options.replayHref,
+    reviewHref: options.reviewHref,
+    taskHref: options.taskHref
+  }),
+  kind: options.kind ?? "ops-webhook"
+});
+var verifyVoiceOpsWebhookSignature = async (input) => {
+  if (!input.secret) {
+    return {
+      ok: false,
+      reason: "missing-secret"
+    };
+  }
+  if (!input.signature) {
+    return {
+      ok: false,
+      reason: "missing-signature"
+    };
+  }
+  if (!input.signature.startsWith("sha256=")) {
+    return {
+      ok: false,
+      reason: "unsupported-algorithm"
+    };
+  }
+  if (!input.timestamp) {
+    return {
+      ok: false,
+      reason: "missing-timestamp"
+    };
+  }
+  const timestampMs = Number(input.timestamp);
+  const toleranceMs = Math.max(0, input.toleranceMs ?? 5 * 60 * 1000);
+  if (!Number.isFinite(timestampMs) || toleranceMs > 0 && Math.abs((input.now ?? Date.now()) - timestampMs) > toleranceMs) {
+    return {
+      ok: false,
+      reason: "stale-timestamp"
+    };
+  }
+  const expected = await signVoiceOpsWebhookBody({
+    body: input.body,
+    secret: input.secret,
+    timestamp: input.timestamp
+  });
+  if (!timingSafeEqual(expected, input.signature)) {
+    return {
+      ok: false,
+      reason: "invalid-signature"
+    };
+  }
+  return {
+    ok: true
+  };
+};
+var createVoiceOpsWebhookReceiverRoutes = (options = {}) => {
+  const path = options.path ?? "/api/voice-ops/webhook";
+  return new Elysia5().post(path, async ({ request, set }) => {
+    const body = await request.text();
+    if (options.signingSecret) {
+      const verification = await verifyVoiceOpsWebhookSignature({
+        body,
+        secret: options.signingSecret,
+        signature: request.headers.get("x-absolutejs-signature"),
+        timestamp: request.headers.get("x-absolutejs-timestamp"),
+        toleranceMs: options.toleranceMs
+      });
+      if (!verification.ok) {
+        set.status = 401;
+        return {
+          ok: false,
+          reason: verification.reason
+        };
+      }
+    }
+    const envelope = JSON.parse(body);
+    await options.onEnvelope?.({
+      envelope,
+      request
+    });
+    return {
+      eventId: envelope.event?.id,
+      ok: true,
+      type: envelope.event?.type
+    };
+  });
+};
 // src/queue.ts
 var releaseLeaseScript = `
 if redis.call("GET", KEYS[1]) == ARGV[1] then
@@ -10835,6 +10998,7 @@ export {
   withVoiceOpsTaskId,
   withVoiceIntegrationEventId,
   voice,
+  verifyVoiceOpsWebhookSignature,
   transcodeTwilioInboundPayloadToPCM16,
   transcodePCMToTwilioOutboundPayload,
   summarizeVoiceTraceSinkDeliveries,
@@ -10941,6 +11105,9 @@ export {
   createVoicePostgresReviewStore,
   createVoicePostgresIntegrationEventStore,
   createVoicePostgresExternalObjectMapStore,
+  createVoiceOpsWebhookSink,
+  createVoiceOpsWebhookReceiverRoutes,
+  createVoiceOpsWebhookEnvelope,
   createVoiceOpsTaskWorker,
   createVoiceOpsTaskProcessorWorkerLoop,
   createVoiceOpsTaskProcessorWorker,

package/dist/opsWebhook.d.ts

@@ -0,0 +1,126 @@
+import { Elysia } from 'elysia';
+import type { StoredVoiceIntegrationEvent, VoiceIntegrationEventType } from './ops';
+import type { VoiceIntegrationHTTPSinkOptions, VoiceIntegrationSink } from './opsSinks';
+type MaybePromise<T> = T | Promise<T>;
+export type VoiceOpsWebhookLinkResolver = string | ((input: {
+    event: StoredVoiceIntegrationEvent;
+}) => MaybePromise<string | undefined>);
+export type VoiceOpsWebhookEntity = {
+    disposition?: string;
+    outcome?: string;
+    priority?: string;
+    queue?: string;
+    reviewId?: string;
+    scenarioId?: string;
+    sessionId?: string;
+    status?: string;
+    target?: string;
+    taskId?: string;
+};
+export type VoiceOpsWebhookEnvelope = {
+    entity: VoiceOpsWebhookEntity;
+    event: {
+        createdAt: number;
+        id: string;
+        payload: Record<string, unknown>;
+        type: VoiceIntegrationEventType;
+    };
+    links?: {
+        event?: string;
+        replay?: string;
+        review?: string;
+        task?: string;
+    };
+    schemaVersion: 1;
+    source: 'absolutejs-voice';
+};
+export type VoiceOpsWebhookSinkOptions = Omit<VoiceIntegrationHTTPSinkOptions<VoiceOpsWebhookEnvelope>, 'body'> & {
+    baseUrl?: string;
+    eventHref?: VoiceOpsWebhookLinkResolver;
+    replayHref?: VoiceOpsWebhookLinkResolver;
+    reviewHref?: VoiceOpsWebhookLinkResolver;
+    taskHref?: VoiceOpsWebhookLinkResolver;
+};
+export type VoiceOpsWebhookVerificationResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: 'invalid-signature' | 'missing-secret' | 'missing-signature' | 'missing-timestamp' | 'stale-timestamp' | 'unsupported-algorithm';
+};
+export type VoiceOpsWebhookReceiverRoutesOptions = {
+    onEnvelope?: (input: {
+        envelope: VoiceOpsWebhookEnvelope;
+        request: Request;
+    }) => MaybePromise<void>;
+    path?: string;
+    signingSecret?: string;
+    toleranceMs?: number;
+};
+export declare const createVoiceOpsWebhookEnvelope: (input: {
+    baseUrl?: string;
+    event: StoredVoiceIntegrationEvent;
+    eventHref?: VoiceOpsWebhookLinkResolver;
+    replayHref?: VoiceOpsWebhookLinkResolver;
+    reviewHref?: VoiceOpsWebhookLinkResolver;
+    taskHref?: VoiceOpsWebhookLinkResolver;
+}) => Promise<VoiceOpsWebhookEnvelope>;
+export declare const createVoiceOpsWebhookSink: (options: VoiceOpsWebhookSinkOptions) => VoiceIntegrationSink;
+export declare const verifyVoiceOpsWebhookSignature: (input: {
+    body: string;
+    now?: number;
+    secret?: string;
+    signature?: string | null;
+    timestamp?: string | null;
+    toleranceMs?: number;
+}) => Promise<VoiceOpsWebhookVerificationResult>;
+export declare const createVoiceOpsWebhookReceiverRoutes: (options?: VoiceOpsWebhookReceiverRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: {
+                    ok: boolean;
+                    reason: "invalid-signature" | "missing-secret" | "missing-signature" | "missing-timestamp" | "stale-timestamp" | "unsupported-algorithm";
+                    eventId?: undefined;
+                    type?: undefined;
+                } | {
+                    eventId: string;
+                    ok: boolean;
+                    type: VoiceIntegrationEventType;
+                    reason?: undefined;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/package.json

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