@absolutejs/voice 0.0.22-beta.485 → 0.0.22-beta.487

package/dist/callerMemory.d.ts

@@ -0,0 +1,37 @@
+import type { Transcript, VoiceSessionRecord, VoiceTurnRecord } from "./types";
+import type { VoiceAssistantMemoryNamespaceInput } from "./assistantMemory";
+export type VoiceCallerIdentity = {
+    email?: string;
+    externalId?: string;
+    phone?: string;
+};
+export type VoiceCallerMemorySnapshot = {
+    facts: Record<string, string>;
+    identity: VoiceCallerIdentity;
+    lastSessionAt: number;
+    openActions: string[];
+    summary: string;
+};
+export declare const VOICE_CALLER_MEMORY_KEY = "caller-memory-snapshot";
+export declare const buildVoiceCallerMemoryNamespace: (identity: VoiceCallerIdentity | undefined, prefix?: string) => string;
+export type CreateVoiceCallerMemoryNamespaceOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    identifyCaller: (input: VoiceAssistantMemoryNamespaceInput<TContext, TSession>) => Promise<VoiceCallerIdentity | undefined> | VoiceCallerIdentity | undefined;
+    prefix?: string;
+};
+export declare const createVoiceCallerMemoryNamespace: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: CreateVoiceCallerMemoryNamespaceOptions<TContext, TSession>) => (input: VoiceAssistantMemoryNamespaceInput<TContext, TSession>) => Promise<string>;
+export type VoiceCallerMemoryCompletion = (input: {
+    prompt: string;
+    systemPrompt?: string;
+}) => Promise<string>;
+export type SummarizeVoiceCallerTranscriptOptions = {
+    completion: VoiceCallerMemoryCompletion;
+    previousSnapshot?: VoiceCallerMemorySnapshot;
+    systemPrompt?: string;
+};
+export type VoiceCallerMemorySummarizerInput = {
+    identity: VoiceCallerIdentity;
+    options: SummarizeVoiceCallerTranscriptOptions;
+    transcripts?: Transcript[];
+    turns: VoiceTurnRecord[];
+};
+export declare const summarizeVoiceCallerTranscript: (input: VoiceCallerMemorySummarizerInput) => Promise<VoiceCallerMemorySnapshot>;

package/dist/index.d.ts

@@ -81,6 +81,10 @@ export { describeVoiceAssistantMode, resolveVoiceAssistantMode, } from "./assist
 export type { VoiceAssistantMode, VoiceAssistantModality, VoiceAssistantModeDescriptor, VoiceSemanticVADConfig, } from "./assistantMode";
 export { createPunctuationSemanticTurnDetector, createRegexSemanticTurnDetector, } from "./semanticTurn";
 export { VOICE_WEBHOOK_SIGNATURE_HEADER, VOICE_WEBHOOK_TIMESTAMP_HEADER, extractVoiceWebhookSignatureFromHeaders, signVoiceWebhookBody, verifyVoiceWebhookSignature, } from "./webhookVerification";
+export { VOICE_CALLER_MEMORY_KEY, buildVoiceCallerMemoryNamespace, createVoiceCallerMemoryNamespace, summarizeVoiceCallerTranscript, } from "./callerMemory";
+export type { CreateVoiceCallerMemoryNamespaceOptions, SummarizeVoiceCallerTranscriptOptions, VoiceCallerIdentity, VoiceCallerMemoryCompletion, VoiceCallerMemorySnapshot, VoiceCallerMemorySummarizerInput, } from "./callerMemory";
+export { aggregateVoiceTurnLatencySpans, buildOTELSpanId, buildOTELTraceId, buildVoiceOTELPayload, createVoiceOTELHTTPExporter, } from "./otelExporter";
+export type { VoiceOTELAttribute, VoiceOTELExporter, VoiceOTELExporterOptions, VoiceOTELPayload, VoiceOTELResourceSpans, VoiceOTELSpan, VoiceTurnLatencySpanSet, VoiceTurnLatencySpanStage, } from "./otelExporter";
 export type { VoiceWebhookVerificationInput, VoiceWebhookVerificationReason, VoiceWebhookVerificationResult, } from "./webhookVerification";
 export type { CreatePunctuationSemanticTurnDetectorOptions, CreateRegexSemanticTurnDetectorOptions, VoiceSemanticTurnDetector, VoiceSemanticTurnInput, VoiceSemanticTurnVerdict, } from "./semanticTurn";
 export { createMonologueAMDDetector } from "./amdDetector";

package/dist/index.js

@@ -35475,6 +35475,234 @@ var extractVoiceWebhookSignatureFromHeaders = (headers) => {
     timestamp: get(VOICE_WEBHOOK_TIMESTAMP_HEADER)
   };
 };
+// src/callerMemory.ts
+var VOICE_CALLER_MEMORY_KEY = "caller-memory-snapshot";
+var normalizeIdentifier = (value) => value.trim().replace(/[^a-zA-Z0-9+@._-]/g, "-").toLowerCase();
+var buildVoiceCallerMemoryNamespace = (identity, prefix = "caller") => {
+  const identifier = identity?.externalId ?? identity?.phone ?? identity?.email ?? "anonymous";
+  return `${prefix}:${normalizeIdentifier(identifier)}`;
+};
+var createVoiceCallerMemoryNamespace = (options) => async (input) => {
+  const identity = await Promise.resolve(options.identifyCaller(input));
+  return buildVoiceCallerMemoryNamespace(identity, options.prefix);
+};
+var DEFAULT_SYSTEM_PROMPT2 = "You write structured caller memory snapshots for a voice agent. " + "Given the latest call transcript (and an optional previous snapshot), " + "merge them into JSON with shape " + '{"summary":"\u2026","facts":{"key":"value"},"openActions":["\u2026"]}. ' + "Keep summary under 240 chars. Facts must be short value strings (name, plan, last_issue). " + "openActions are concrete follow-ups still pending. JSON only.";
+var buildTranscriptBlock = (turns) => turns.map((turn, index) => {
+  const userText = turn.text.trim();
+  const assistantText = typeof turn.assistantText === "string" ? turn.assistantText.trim() : "";
+  const lines = [`Turn ${index + 1}:`];
+  if (userText) {
+    lines.push(`  user: ${userText}`);
+  }
+  if (assistantText) {
+    lines.push(`  agent: ${assistantText}`);
+  }
+  return lines.join(`
+`);
+}).join(`
+`);
+var extractJson2 = (raw) => {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    throw new Error("Caller-memory summarizer returned empty response");
+  }
+  const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(trimmed);
+  const candidate = fenced ? fenced[1].trim() : trimmed;
+  try {
+    return JSON.parse(candidate);
+  } catch {
+    const start = candidate.indexOf("{");
+    const end = candidate.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+      return JSON.parse(candidate.slice(start, end + 1));
+    }
+    throw new Error("Caller-memory response was not valid JSON");
+  }
+};
+var coerceFacts = (input) => {
+  if (!input || typeof input !== "object") {
+    return {};
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (typeof value === "string") {
+      out[key] = value;
+    } else if (value !== null && value !== undefined) {
+      out[key] = String(value);
+    }
+  }
+  return out;
+};
+var coerceActions = (input) => {
+  if (!Array.isArray(input)) {
+    return [];
+  }
+  return input.map((value) => typeof value === "string" ? value.trim() : "").filter((value) => value.length > 0);
+};
+var summarizeVoiceCallerTranscript = async (input) => {
+  const transcriptBlock = buildTranscriptBlock(input.turns);
+  const previousBlock = input.options.previousSnapshot ? `Previous snapshot:
+${JSON.stringify(input.options.previousSnapshot, null, 2)}
+
+` : "";
+  const prompt = `${previousBlock}Latest call transcript:
+${transcriptBlock}
+
+Return JSON only.`;
+  const raw = await input.options.completion({
+    prompt,
+    systemPrompt: input.options.systemPrompt ?? DEFAULT_SYSTEM_PROMPT2
+  });
+  const parsed = extractJson2(raw);
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("Caller-memory summarizer returned non-object JSON");
+  }
+  const record = parsed;
+  return {
+    facts: coerceFacts(record.facts),
+    identity: input.identity,
+    lastSessionAt: Date.now(),
+    openActions: coerceActions(record.openActions ?? record.open_actions),
+    summary: typeof record.summary === "string" ? record.summary : ""
+  };
+};
+// src/otelExporter.ts
+var SCOPE_NAME = "@absolutejs/voice";
+var SPAN_KIND_INTERNAL = 1;
+var STATUS_OK = 1;
+var HEX_CHARS = "0123456789abcdef";
+var hashToHex = (input, length) => {
+  let hash = 0xcbf29ce4_84222325n;
+  const prime = 0x100000001_b3n;
+  for (let index = 0;index < input.length; index += 1) {
+    hash ^= BigInt(input.charCodeAt(index));
+    hash = hash * prime & 0xffffffffffffffffn;
+  }
+  let hex = hash.toString(16).padStart(16, "0");
+  while (hex.length < length) {
+    let next = 0n;
+    for (const ch of hex) {
+      next = next * 31n + BigInt(HEX_CHARS.indexOf(ch)) & 0xffffffffffffffffn;
+    }
+    hex += next.toString(16).padStart(16, "0");
+  }
+  return hex.slice(0, length);
+};
+var buildOTELTraceId = (sessionId) => hashToHex(`voice-trace:${sessionId}`, 32);
+var buildOTELSpanId = (sessionId, suffix) => hashToHex(`voice-span:${sessionId}:${suffix}`, 16);
+var toUnixNano = (ms) => `${Math.trunc(ms * 1e6)}`;
+var stringAttr = (key, value) => ({
+  key,
+  value: { stringValue: value }
+});
+var aggregateVoiceTurnLatencySpans = (events) => {
+  const byTurn = new Map;
+  for (const event of events) {
+    if (event.type !== "turn_latency.stage" || !event.turnId) {
+      continue;
+    }
+    const stage = typeof event.payload?.stage === "string" ? event.payload.stage : undefined;
+    if (!stage) {
+      continue;
+    }
+    const key = `${event.sessionId}::${event.turnId}`;
+    const existing = byTurn.get(key);
+    if (!existing) {
+      byTurn.set(key, {
+        endedAt: event.at,
+        scenarioId: event.scenarioId,
+        sessionId: event.sessionId,
+        stages: [{ at: event.at, stage }],
+        startedAt: event.at,
+        turnId: event.turnId
+      });
+      continue;
+    }
+    existing.stages.push({ at: event.at, stage });
+    existing.startedAt = Math.min(existing.startedAt, event.at);
+    existing.endedAt = Math.max(existing.endedAt, event.at);
+  }
+  return Array.from(byTurn.values()).sort((left, right) => left.startedAt - right.startedAt);
+};
+var buildVoiceOTELPayload = (spanSets, options = {}) => {
+  const resourceAttributes = [
+    stringAttr("service.name", options.serviceName ?? "absolutejs-voice")
+  ];
+  for (const [key, value] of Object.entries(options.resourceAttributes ?? {})) {
+    resourceAttributes.push(stringAttr(key, value));
+  }
+  const spans = [];
+  for (const set of spanSets) {
+    const traceId = buildOTELTraceId(set.sessionId);
+    const parentSpanId = buildOTELSpanId(set.sessionId, `turn:${set.turnId}`);
+    spans.push({
+      attributes: [
+        stringAttr("voice.session_id", set.sessionId),
+        stringAttr("voice.turn_id", set.turnId),
+        ...set.scenarioId ? [stringAttr("voice.scenario_id", set.scenarioId)] : []
+      ],
+      endTimeUnixNano: toUnixNano(set.endedAt),
+      kind: SPAN_KIND_INTERNAL,
+      name: "voice.turn",
+      spanId: parentSpanId,
+      startTimeUnixNano: toUnixNano(set.startedAt),
+      status: { code: STATUS_OK },
+      traceId
+    });
+    for (let index = 0;index < set.stages.length; index += 1) {
+      const stage = set.stages[index];
+      const next = set.stages[index + 1];
+      const endsAt = next ? next.at : set.endedAt;
+      spans.push({
+        attributes: [
+          stringAttr("voice.session_id", set.sessionId),
+          stringAttr("voice.turn_id", set.turnId),
+          stringAttr("voice.stage", stage.stage)
+        ],
+        endTimeUnixNano: toUnixNano(endsAt),
+        kind: SPAN_KIND_INTERNAL,
+        name: `voice.turn.stage.${stage.stage}`,
+        parentSpanId,
+        spanId: buildOTELSpanId(set.sessionId, `${set.turnId}:${stage.stage}:${index}`),
+        startTimeUnixNano: toUnixNano(stage.at),
+        status: { code: STATUS_OK },
+        traceId
+      });
+    }
+  }
+  return {
+    resourceSpans: [
+      {
+        resource: { attributes: resourceAttributes },
+        scopeSpans: [{ scope: { name: SCOPE_NAME }, spans }]
+      }
+    ]
+  };
+};
+var createVoiceOTELHTTPExporter = (options) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+  return {
+    export: async (events) => {
+      const spanSets = aggregateVoiceTurnLatencySpans(events);
+      if (spanSets.length === 0) {
+        return { ok: true };
+      }
+      const payload = buildVoiceOTELPayload(spanSets, {
+        resourceAttributes: options.resourceAttributes,
+        serviceName: options.serviceName
+      });
+      const response = await fetchImpl(options.url, {
+        body: JSON.stringify(payload),
+        headers: {
+          "content-type": "application/json",
+          ...options.headers
+        },
+        method: "POST"
+      });
+      return { ok: response.ok, status: response.status };
+    }
+  };
+};
 // src/amdDetector.ts
 var createMonologueAMDDetector = (options = {}) => {
   const minMonologueMs = options.minMonologueMs ?? 8000;
@@ -46085,6 +46313,7 @@ export {
   summarizeVoiceHandoffHealth,
   summarizeVoiceHandoffDeliveries,
   summarizeVoiceCampaigns,
+  summarizeVoiceCallerTranscript,
   summarizeVoiceBrowserMedia,
   summarizeVoiceBargeIn,
   summarizeVoiceAuditTrail,
@@ -46540,6 +46769,7 @@ export {
   createVoiceObservabilityExportSchema,
   createVoiceObservabilityExportRoutes,
   createVoiceObservabilityExportReplayRoutes,
+  createVoiceOTELHTTPExporter,
   createVoiceMonitorWebhookNotifier,
   createVoiceMonitorSession,
   createVoiceMonitorRuntimeBinding,
@@ -46632,6 +46862,7 @@ export {
   createVoiceCampaignTelephonyOutcomeHandler,
   createVoiceCampaignRoutes,
   createVoiceCampaign,
+  createVoiceCallerMemoryNamespace,
   createVoiceCallReviewRecorder,
   createVoiceCallReviewFromSession,
   createVoiceCallReviewFromLiveTelephonyReport,
@@ -46758,6 +46989,7 @@ export {
   buildVoiceObservabilityExportDeliveryHistory,
   buildVoiceObservabilityExport,
   buildVoiceObservabilityArtifactIndex,
+  buildVoiceOTELPayload,
   buildVoiceMultilingualProofReadinessCheck,
   buildVoiceMonitorRunReport,
   buildVoiceMonitorPlan,
@@ -46783,11 +47015,14 @@ export {
   buildVoiceDataControlReport,
   buildVoiceCompetitiveCoverageReport,
   buildVoiceCampaignObservabilityReport,
+  buildVoiceCallerMemoryNamespace,
   buildVoiceCallDebuggerReport,
   buildVoiceBrowserCallProfileReport,
   buildVoiceAuditTrailReport,
   buildVoiceAuditExport,
   buildVoiceAuditDeliveryReport,
+  buildOTELTraceId,
+  buildOTELSpanId,
   buildEmptyVoiceProofTrendReport,
   assignVoiceOpsTask,
   assertVoiceToolContractEvidence,
@@ -46838,10 +47073,12 @@ export {
   appendVoiceRealCallProfileRecoveryEvidence,
   appendVoiceProviderRouterTraceEvent,
   appendVoiceIOProviderRouterTraceEvent,
+  aggregateVoiceTurnLatencySpans,
   acknowledgeVoiceMonitorIssue,
   VOICE_WEBHOOK_TIMESTAMP_HEADER,
   VOICE_WEBHOOK_SIGNATURE_HEADER,
   VOICE_LIVE_OPS_ACTIONS,
+  VOICE_CALLER_MEMORY_KEY,
   TURN_PROFILE_DEFAULTS,
   DEFAULT_VOICE_REDACTION_PATTERNS,
   DEFAULT_VOICE_PROOF_TREND_PROFILE_DEFINITIONS,

package/dist/otelExporter.d.ts

@@ -0,0 +1,83 @@
+import type { StoredVoiceTraceEvent } from "./trace";
+export type VoiceOTELAttribute = {
+    key: string;
+    value: {
+        boolValue: boolean;
+    };
+} | {
+    key: string;
+    value: {
+        doubleValue: number;
+    };
+} | {
+    key: string;
+    value: {
+        intValue: string;
+    };
+} | {
+    key: string;
+    value: {
+        stringValue: string;
+    };
+};
+export type VoiceOTELSpan = {
+    attributes: VoiceOTELAttribute[];
+    endTimeUnixNano: string;
+    kind: number;
+    name: string;
+    parentSpanId?: string;
+    spanId: string;
+    startTimeUnixNano: string;
+    status: {
+        code: number;
+    };
+    traceId: string;
+};
+export type VoiceOTELResourceSpans = {
+    resource: {
+        attributes: VoiceOTELAttribute[];
+    };
+    scopeSpans: ReadonlyArray<{
+        scope: {
+            name: string;
+            version?: string;
+        };
+        spans: VoiceOTELSpan[];
+    }>;
+};
+export type VoiceOTELPayload = {
+    resourceSpans: VoiceOTELResourceSpans[];
+};
+export type VoiceTurnLatencySpanStage = {
+    at: number;
+    stage: string;
+};
+export type VoiceTurnLatencySpanSet = {
+    endedAt: number;
+    scenarioId?: string;
+    sessionId: string;
+    stages: VoiceTurnLatencySpanStage[];
+    startedAt: number;
+    turnId: string;
+};
+export declare const buildOTELTraceId: (sessionId: string) => string;
+export declare const buildOTELSpanId: (sessionId: string, suffix: string) => string;
+export declare const aggregateVoiceTurnLatencySpans: (events: StoredVoiceTraceEvent[]) => VoiceTurnLatencySpanSet[];
+export type VoiceOTELExporterOptions = {
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+    resourceAttributes?: Record<string, string>;
+    serviceName?: string;
+    url: string;
+};
+export declare const buildVoiceOTELPayload: (spanSets: VoiceTurnLatencySpanSet[], options?: {
+    resourceAttributes?: Record<string, string>;
+    serviceName?: string;
+}) => VoiceOTELPayload;
+export type VoiceOTELExporter = {
+    export: (events: StoredVoiceTraceEvent[]) => Promise<{
+        ok: boolean;
+        status?: number;
+    }>;
+};
+export declare const createVoiceOTELHTTPExporter: (options: VoiceOTELExporterOptions) => VoiceOTELExporter;

package/package.json

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