@absolutejs/voice 0.0.22-beta.477 → 0.0.22-beta.479

package/dist/agentTools.d.ts

@@ -29,6 +29,7 @@ export type VoiceTransferCallToolDestination = {
     message?: string;
     metadata?: Record<string, unknown>;
     target: string;
+    transferMode?: "cold" | "warm";
 };
 export type VoiceTransferCallToolArgs = {
     destinationId: string;

package/dist/amdDetector.d.ts

@@ -0,0 +1,25 @@
+import type { Transcript, VoiceSessionHandle, VoiceSessionRecord } from "./types";
+export type VoiceAMDDetectorInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    api: VoiceSessionHandle<TContext, TSession, TResult>;
+    audioLevel: number | undefined;
+    elapsedSinceFirstAudioMs: number;
+    elapsedSinceLastTurnCommitMs: number;
+    partialTranscript: string;
+    session: TSession;
+    transcripts: Transcript[];
+};
+export type VoiceAMDVerdict = {
+    metadata?: Record<string, unknown>;
+    reason?: string;
+};
+export type VoiceAMDDetector<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    evaluate: (input: VoiceAMDDetectorInput<TContext, TSession, TResult>) => Promise<VoiceAMDVerdict | undefined> | VoiceAMDVerdict | undefined;
+    intervalMs?: number;
+};
+export type MonologueAMDDetectorOptions = {
+    intervalMs?: number;
+    minMonologueMs?: number;
+    reason?: string;
+    requireFirstAudio?: boolean;
+};
+export declare const createMonologueAMDDetector: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options?: MonologueAMDDetectorOptions) => VoiceAMDDetector<TContext, TSession, TResult>;

package/dist/index.d.ts

@@ -71,6 +71,8 @@ export { createVoiceSessionListRoutes, createVoiceSessionReplayHTMLHandler, crea
 export { createVoiceAgent, createVoiceAgentSquad, createVoiceAgentTool, } from "./agent";
 export { createAIVoiceModel } from "./aiVoiceModel";
 export type { CreateAIVoiceModelOptions } from "./aiVoiceModel";
+export { createMonologueAMDDetector } from "./amdDetector";
+export type { MonologueAMDDetectorOptions, VoiceAMDDetector, VoiceAMDDetectorInput, VoiceAMDVerdict, } from "./amdDetector";
 export { createVoiceRAGTool } from "./ragTool";
 export type { VoiceRAGCollectionLike, VoiceRAGQueryResult, VoiceRAGSearchInput, VoiceRAGToolArgs, VoiceRAGToolOptions, VoiceRAGToolResult, } from "./ragTool";
 export { createVoiceApiRequestTool, createVoiceDTMFTool, createVoiceEndCallTool, createVoiceTransferCallTool, createVoiceVoicemailDetectionTool, } from "./agentTools";
@@ -120,7 +122,7 @@ export { buildVoiceTraceDeliveryReport, createVoiceTraceDeliveryHTMLHandler, cre
 export { createVoiceTraceTimelineRoutes, renderVoiceTraceTimelineHTML, renderVoiceTraceTimelineSessionHTML, summarizeVoiceTraceTimeline, } from "./traceTimeline";
 export { createVoiceSQLiteAuditEventStore, createVoiceSQLiteAuditSinkDeliveryStore, createVoiceSQLiteCampaignStore, createVoiceSQLiteExternalObjectMapStore, createVoiceSQLiteIntegrationEventStore, createVoiceSQLiteReviewStore, createVoiceSQLiteRuntimeStorage, createVoiceSQLiteSessionStore, createVoiceSQLiteTaskStore, createVoiceSQLiteTelephonyWebhookIdempotencyStore, createVoiceSQLiteTraceSinkDeliveryStore, createVoiceSQLiteTraceEventStore, } from "./sqliteStore";
 export { createVoicePostgresAuditEventStore, createVoicePostgresAuditSinkDeliveryStore, createVoicePostgresCampaignStore, createVoicePostgresExternalObjectMapStore, createVoicePostgresIntegrationEventStore, createVoicePostgresReviewStore, createVoicePostgresRuntimeStorage, createVoicePostgresSessionStore, createVoicePostgresTaskStore, createVoicePostgresTelephonyWebhookIdempotencyStore, createVoicePostgresTraceSinkDeliveryStore, createVoicePostgresTraceEventStore, } from "./postgresStore";
-export { createVoiceS3ReviewStore } from "./s3Store";
+export { createVoiceS3RecordingStore, 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";

package/dist/index.js

@@ -3682,6 +3682,90 @@ var createVoiceSession = (options) => {
   const currentTurnAudio = [];
   let fallbackAttemptsForCurrentTurn = 0;
   let fallbackReplayAudioMsForCurrentTurn = 0;
+  const amdDetector = options.amd;
+  let amdEvaluationTimer = null;
+  let amdFired = false;
+  let amdFirstAudioAt;
+  let amdLastTurnCommitAt;
+  let amdLastAudioLevel;
+  const clearAmdEvaluationTimer = () => {
+    if (amdEvaluationTimer) {
+      clearInterval(amdEvaluationTimer);
+      amdEvaluationTimer = null;
+    }
+  };
+  const evaluateAmd = async () => {
+    if (!amdDetector || amdFired) {
+      return;
+    }
+    let snapshot;
+    try {
+      snapshot = await readSession();
+    } catch {
+      return;
+    }
+    const now = Date.now();
+    const verdict = await Promise.resolve(amdDetector.evaluate({
+      api,
+      audioLevel: amdLastAudioLevel,
+      elapsedSinceFirstAudioMs: amdFirstAudioAt === undefined ? 0 : now - amdFirstAudioAt,
+      elapsedSinceLastTurnCommitMs: amdLastTurnCommitAt === undefined ? 0 : now - amdLastTurnCommitAt,
+      partialTranscript: snapshot.currentTurn.partialText,
+      session: snapshot,
+      transcripts: [
+        ...snapshot.transcripts,
+        ...snapshot.currentTurn.transcripts
+      ]
+    }));
+    if (!verdict || amdFired) {
+      return;
+    }
+    amdFired = true;
+    clearAmdEvaluationTimer();
+    try {
+      await api.markVoicemail({
+        metadata: verdict.metadata
+      });
+    } catch (error) {
+      logger.warn("voice amd markVoicemail failed", {
+        error: toError(error).message,
+        sessionId: options.id
+      });
+    }
+  };
+  const startAmdEvaluationTimer = () => {
+    if (!amdDetector || amdEvaluationTimer || amdFired) {
+      return;
+    }
+    const intervalMs = amdDetector.intervalMs ?? 1000;
+    amdEvaluationTimer = setInterval(() => {
+      evaluateAmd();
+    }, intervalMs);
+  };
+  const callSilenceTimeoutMs = options.callSilenceTimeoutMs && options.callSilenceTimeoutMs > 0 ? options.callSilenceTimeoutMs : undefined;
+  let callSilenceWatchdog = null;
+  let callSilenceFired = false;
+  const clearCallSilenceWatchdog = () => {
+    if (callSilenceWatchdog) {
+      clearTimeout(callSilenceWatchdog);
+      callSilenceWatchdog = null;
+    }
+  };
+  const fireCallSilenceTimeout = () => {
+    callSilenceWatchdog = null;
+    if (callSilenceFired) {
+      return;
+    }
+    callSilenceFired = true;
+    api.close("silence-timeout");
+  };
+  const kickCallSilenceWatchdog = () => {
+    if (callSilenceTimeoutMs === undefined || callSilenceFired) {
+      return;
+    }
+    clearCallSilenceWatchdog();
+    callSilenceWatchdog = setTimeout(fireCallSilenceTimeout, callSilenceTimeoutMs);
+  };
   const recordingConfig = options.recording;
   const recordingChannels = new Set(recordingConfig?.channels ?? ["assistant", "user"]);
   const recordingMaxBytes = recordingConfig?.maxBytesPerChannel ?? 50 * 1024 * 1024;
@@ -3970,6 +4054,7 @@ var createVoiceSession = (options) => {
   const sendAssistantAudio = async (chunk, input) => {
     const normalizedChunk = chunk instanceof Uint8Array ? new Uint8Array(chunk) : chunk instanceof ArrayBuffer ? new Uint8Array(chunk.slice(0)) : new Uint8Array(chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength));
     captureRecordingChunk("assistant", normalizedChunk, input.format);
+    kickCallSilenceWatchdog();
     await send({
       chunkBase64: encodeBase64(normalizedChunk),
       format: input.format,
@@ -4064,6 +4149,8 @@ var createVoiceSession = (options) => {
       recoverable: false,
       type: "error"
     });
+    clearCallSilenceWatchdog();
+    clearAmdEvaluationTimer();
     await closeTTSSession("failed");
     await closeAdapter("failed");
     await persistRecordings();
@@ -4133,6 +4220,8 @@ var createVoiceSession = (options) => {
       sessionId: options.id,
       type: "complete"
     });
+    clearCallSilenceWatchdog();
+    clearAmdEvaluationTimer();
     await closeTTSSession("complete");
     await closeAdapter("complete");
     await persistRecordings();
@@ -4191,19 +4280,21 @@ var createVoiceSession = (options) => {
     });
   };
   const transferInternal = async (input) => {
+    const transferMetadata = input.transferMode === undefined ? input.metadata : { ...input.metadata ?? {}, transferMode: input.transferMode };
     const session = await writeSession((currentSession) => {
       pushCallLifecycleEvent(currentSession, {
-        metadata: input.metadata,
+        metadata: transferMetadata,
         reason: input.reason,
         target: input.target,
         type: "transfer"
       });
     });
     await appendTrace({
-      metadata: input.metadata,
+      metadata: transferMetadata,
       payload: {
         reason: input.reason,
         target: input.target,
+        transferMode: input.transferMode,
         type: "transfer"
       },
       session,
@@ -4988,6 +5079,7 @@ var createVoiceSession = (options) => {
   };
   const commitTurnInternal = async (reason = "manual") => {
     clearSilenceTimer();
+    amdLastTurnCommitAt = Date.now();
     const session = await readSession();
     if (session.status === "completed" || session.status === "failed") {
       return;
@@ -5234,6 +5326,8 @@ var createVoiceSession = (options) => {
     resumePendingTurnCommit(session);
     await ensureAdapter();
     warmTTSSession();
+    kickCallSilenceWatchdog();
+    startAmdEvaluationTimer();
   };
   const disconnectInternal = async (event) => {
     clearSilenceTimer();
@@ -5281,12 +5375,17 @@ var createVoiceSession = (options) => {
       const userBytes = conditionedAudio instanceof Uint8Array ? conditionedAudio : conditionedAudio instanceof ArrayBuffer ? new Uint8Array(conditionedAudio) : new Uint8Array(conditionedAudio.buffer, conditionedAudio.byteOffset, conditionedAudio.byteLength);
       captureRecordingChunk("user", userBytes, recordingConfig.userInputFormat);
     }
+    amdLastAudioLevel = audioLevel;
     if (audioLevel >= turnDetection.speechThreshold) {
+      if (amdFirstAudioAt === undefined) {
+        amdFirstAudioAt = Date.now();
+      }
       if (!speechDetected && activeTTSTurnId !== undefined) {
         cancelActiveTTS("barge-in");
       }
       speechDetected = true;
       clearSilenceTimer();
+      kickCallSilenceWatchdog();
     } else if (speechDetected) {
       const currentSession = await readSession();
       const hasTurnText = Boolean(buildTurnText(currentSession.currentTurn.transcripts, currentSession.currentTurn.partialText, {
@@ -5299,44 +5398,50 @@ var createVoiceSession = (options) => {
     }
     await adapter.send(conditionedAudio);
   };
+  const closeInternal = async (reason, disposition = "closed") => {
+    const session = await writeSession((currentSession) => {
+      if (currentSession.status !== "completed" && currentSession.status !== "failed" && !currentSession.call?.endedAt) {
+        currentSession.lastActivityAt = Date.now();
+        currentSession.status = "completed";
+        pushCallLifecycleEvent(currentSession, {
+          disposition,
+          reason,
+          type: "end"
+        });
+      }
+    });
+    clearSilenceTimer();
+    clearCallSilenceWatchdog();
+    clearAmdEvaluationTimer();
+    await closeTTSSession(reason);
+    await closeAdapter(reason);
+    await persistRecordings();
+    await Promise.resolve(socket.close(1000, reason));
+    if (session.call?.endedAt && session.call.disposition === disposition) {
+      await appendTrace({
+        payload: {
+          disposition,
+          reason,
+          type: "end"
+        },
+        session,
+        type: "call.lifecycle"
+      });
+      await options.route.onCallEnd?.({
+        api,
+        context: options.context,
+        disposition,
+        reason,
+        session
+      });
+    }
+  };
   const api = {
     id: options.id,
     close: async (reason) => {
       await runSerial("api.close", async () => {
-        const session = await writeSession((currentSession) => {
-          if (currentSession.status !== "completed" && currentSession.status !== "failed" && !currentSession.call?.endedAt) {
-            currentSession.lastActivityAt = Date.now();
-            currentSession.status = "completed";
-            pushCallLifecycleEvent(currentSession, {
-              disposition: "closed",
-              reason,
-              type: "end"
-            });
-          }
-        });
-        clearSilenceTimer();
-        await closeTTSSession(reason);
-        await closeAdapter(reason);
-        await persistRecordings();
-        await Promise.resolve(socket.close(1000, reason));
-        if (session.call?.endedAt && session.call.disposition === "closed") {
-          await appendTrace({
-            payload: {
-              disposition: "closed",
-              reason,
-              type: "end"
-            },
-            session,
-            type: "call.lifecycle"
-          });
-          await options.route.onCallEnd?.({
-            api,
-            context: options.context,
-            disposition: "closed",
-            reason,
-            session
-          });
-        }
+        const disposition = reason === "silence-timeout" ? "silence-timeout" : "closed";
+        await closeInternal(reason, disposition);
       });
     },
     commitTurn: async (reason = "manual") => runSerial("api.commitTurn", async () => {
@@ -9082,6 +9187,18 @@ var RECIPE_DEFAULTS = {
     defaultQueue: "transfer-verification",
     description: "Creates transfer verification work for transferred calls and escalation work when the handoff fails.",
     escalationQueue: "transfer-escalations"
+  },
+  "cold-transfer": {
+    completedAction: "Verify the SIP REFER landed and the caller reached the destination without re-introduction.",
+    completedDescription: "The call was cold-transferred (SIP REFER) \u2014 confirm the destination picked up.",
+    completedKind: "transfer-check",
+    completedTitle: "Verify cold transfer",
+    defaultCompletedCreatesTask: false,
+    defaultDueInMs: 5 * 60000,
+    defaultPriority: "normal",
+    defaultQueue: "transfer-verification",
+    description: "Creates verification work for cold-transferred (REFER) calls and escalation work when the handoff fails.",
+    escalationQueue: "transfer-escalations"
   }
 };
 var buildRecipeTask = (input) => {
@@ -9211,7 +9328,7 @@ var resolveVoiceOutcomeRecipe = (name, options = {}) => {
       dueInMs: Math.min(options.dueInMs ?? defaults.defaultDueInMs, 20 * 60000),
       name: `${name}-transfer-check`,
       priority: options.priority ?? defaults.defaultPriority,
-      queue: name === "warm-transfer" ? options.queue ?? defaults.defaultQueue : "transfer-verification"
+      queue: name === "warm-transfer" || name === "cold-transfer" ? options.queue ?? defaults.defaultQueue : "transfer-verification"
     },
     voicemail: {
       assignee: options.assignee,
@@ -34818,6 +34935,36 @@ var createAIVoiceModel = (options) => ({
     return output;
   }
 });
+// src/amdDetector.ts
+var createMonologueAMDDetector = (options = {}) => {
+  const minMonologueMs = options.minMonologueMs ?? 8000;
+  const reason = options.reason ?? "monologue-suspected-voicemail";
+  const requireFirstAudio = options.requireFirstAudio ?? true;
+  return {
+    evaluate: ({
+      elapsedSinceFirstAudioMs,
+      elapsedSinceLastTurnCommitMs,
+      session
+    }) => {
+      if (requireFirstAudio && elapsedSinceFirstAudioMs <= 0) {
+        return;
+      }
+      const noTurnsYet = session.turns.length === 0;
+      const monologueElapsed = noTurnsYet ? elapsedSinceFirstAudioMs : elapsedSinceLastTurnCommitMs;
+      if (monologueElapsed < minMonologueMs) {
+        return;
+      }
+      return {
+        metadata: {
+          detector: "monologue",
+          monologueMs: monologueElapsed
+        },
+        reason
+      };
+    },
+    intervalMs: options.intervalMs ?? 1000
+  };
+};
 // src/ragTool.ts
 var DEFAULT_TOOL_NAME = "searchKnowledgeBase";
 var DEFAULT_DESCRIPTION = "Search the knowledge base and return short grounded citations. Use this whenever the caller asks a question that may be answered by indexed reference material.";
@@ -34999,7 +35146,8 @@ ${destinationDocs}`,
         metadata: destination.metadata,
         reason: args?.reason,
         result,
-        target: destination.target
+        target: destination.target,
+        transferMode: destination.transferMode
       });
       return {
         destinationId: destination.id,
@@ -41255,6 +41403,62 @@ var createVoiceS3ReviewStore = (options) => {
     set
   };
 };
+var normalizeRecordingKeyPrefix = (prefix) => prefix?.trim().replace(/^\/+|\/+$/g, "") ?? "voice/recordings";
+var recordingWavKey = (prefix, sessionId, channel) => `${prefix}/${encodeURIComponent(sessionId)}_${channel}.wav`;
+var recordingMetadataKey = (prefix, sessionId, channel) => `${prefix}/${encodeURIComponent(sessionId)}_${channel}.json`;
+var createVoiceS3RecordingStore = (options) => {
+  const client = options.client ?? new Bun.S3Client(options);
+  const keyPrefix = normalizeRecordingKeyPrefix(options.keyPrefix);
+  const publicUrlBase = options.publicUrlBase?.replace(/\/+$/, "");
+  const getFile = (key) => client.file(key, options);
+  const resolveUrl = (key) => publicUrlBase ? `${publicUrlBase}/${key}` : `s3://${key}`;
+  const put = async (artifact) => {
+    const wavKey = recordingWavKey(keyPrefix, artifact.sessionId, artifact.channel);
+    const metadataKey = recordingMetadataKey(keyPrefix, artifact.sessionId, artifact.channel);
+    const wav = encodePcmAsWav(artifact.audioBytes, artifact.format);
+    await getFile(wavKey).write(wav);
+    const recordingUrl = resolveUrl(wavKey);
+    const metadata = {
+      capturedAt: artifact.capturedAt,
+      channel: artifact.channel,
+      durationMs: artifact.durationMs,
+      format: artifact.format,
+      recordingUrl,
+      sessionId: artifact.sessionId
+    };
+    await getFile(metadataKey).write(JSON.stringify(metadata));
+    return {
+      ...artifact,
+      recordingUrl
+    };
+  };
+  const readMetadata = async (sessionId, channel) => {
+    const metadataKey = recordingMetadataKey(keyPrefix, sessionId, channel);
+    const wavKey = recordingWavKey(keyPrefix, sessionId, channel);
+    const metadataFile = getFile(metadataKey);
+    if (!await metadataFile.exists()) {
+      return;
+    }
+    const meta = JSON.parse(await metadataFile.text());
+    const wavBytes = await getFile(wavKey).bytes();
+    return {
+      audioBytes: wavBytes,
+      capturedAt: meta.capturedAt,
+      channel: meta.channel,
+      durationMs: meta.durationMs,
+      format: meta.format,
+      recordingUrl: meta.recordingUrl,
+      sessionId: meta.sessionId
+    };
+  };
+  const get = (sessionId, channel) => readMetadata(sessionId, channel);
+  const list = async (sessionId) => {
+    const channels = ["assistant", "user"];
+    const records = await Promise.all(channels.map((channel) => readMetadata(sessionId, channel)));
+    return records.filter((record) => record !== undefined);
+  };
+  return { get, list, put };
+};
 // src/memoryStore.ts
 var createVoiceMemoryStore = () => {
   const sessions = new Map;
@@ -45687,6 +45891,7 @@ export {
   createVoiceSQLiteAuditSinkDeliveryStore,
   createVoiceSQLiteAuditEventStore,
   createVoiceS3ReviewStore,
+  createVoiceS3RecordingStore,
   createVoiceS3DeliverySink,
   createVoiceRoutingDecisionSummary,
   createVoiceReviewSavedEvent,
@@ -45928,6 +46133,7 @@ export {
   createPhraseHintCorrectionHandler,
   createOpenAIVoiceTTS,
   createOpenAIVoiceAssistantModel,
+  createMonologueAMDDetector,
   createMemoryVoiceTelnyxWebhookEventStore,
   createMemoryVoiceTelephonyWebhookIdempotencyStore,
   createMemoryVoicePlivoWebhookNonceStore,

package/dist/outcomeRecipes.d.ts

@@ -1,6 +1,6 @@
 import type { VoiceOpsTaskPriority } from "./ops";
 import type { VoiceRuntimeOpsConfig, VoiceSessionRecord } from "./types";
-export type VoiceOutcomeRecipeName = "appointment-booking" | "lead-qualification" | "support-triage" | "voicemail-callback" | "warm-transfer";
+export type VoiceOutcomeRecipeName = "appointment-booking" | "cold-transfer" | "lead-qualification" | "support-triage" | "voicemail-callback" | "warm-transfer";
 export type VoiceOutcomeRecipeOptions = {
     assignee?: string;
     completedCreatesTask?: boolean;

package/dist/s3Store.d.ts

@@ -1,5 +1,6 @@
 import type { S3Client, S3Options } from "bun";
 import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from "./testing/review";
+import type { VoiceRecordingStore } from "./recordingStore";
 export type VoiceS3ReviewStoreFile = {
     delete: () => Promise<void>;
     exists: () => Promise<boolean>;
@@ -12,3 +13,17 @@ export type VoiceS3ReviewStoreOptions = S3Options & {
     keyPrefix?: string;
 };
 export declare const createVoiceS3ReviewStore: <TArtifact extends StoredVoiceCallReviewArtifact = StoredVoiceCallReviewArtifact>(options: VoiceS3ReviewStoreOptions) => VoiceCallReviewStore<TArtifact>;
+export type VoiceS3RecordingStoreFile = {
+    delete: () => Promise<void>;
+    exists: () => Promise<boolean>;
+    text: () => Promise<string>;
+    bytes: () => Promise<Uint8Array>;
+    write: (data: string | Uint8Array) => Promise<number>;
+};
+export type VoiceS3RecordingStoreClient = Pick<S3Client, "file" | "list">;
+export type VoiceS3RecordingStoreOptions = S3Options & {
+    client?: VoiceS3RecordingStoreClient;
+    keyPrefix?: string;
+    publicUrlBase?: string;
+};
+export declare const createVoiceS3RecordingStore: (options: VoiceS3RecordingStoreOptions) => VoiceRecordingStore;

package/dist/testing/index.js

@@ -5650,6 +5650,90 @@ var createVoiceSession = (options) => {
   const currentTurnAudio = [];
   let fallbackAttemptsForCurrentTurn = 0;
   let fallbackReplayAudioMsForCurrentTurn = 0;
+  const amdDetector = options.amd;
+  let amdEvaluationTimer = null;
+  let amdFired = false;
+  let amdFirstAudioAt;
+  let amdLastTurnCommitAt;
+  let amdLastAudioLevel;
+  const clearAmdEvaluationTimer = () => {
+    if (amdEvaluationTimer) {
+      clearInterval(amdEvaluationTimer);
+      amdEvaluationTimer = null;
+    }
+  };
+  const evaluateAmd = async () => {
+    if (!amdDetector || amdFired) {
+      return;
+    }
+    let snapshot;
+    try {
+      snapshot = await readSession();
+    } catch {
+      return;
+    }
+    const now = Date.now();
+    const verdict = await Promise.resolve(amdDetector.evaluate({
+      api,
+      audioLevel: amdLastAudioLevel,
+      elapsedSinceFirstAudioMs: amdFirstAudioAt === undefined ? 0 : now - amdFirstAudioAt,
+      elapsedSinceLastTurnCommitMs: amdLastTurnCommitAt === undefined ? 0 : now - amdLastTurnCommitAt,
+      partialTranscript: snapshot.currentTurn.partialText,
+      session: snapshot,
+      transcripts: [
+        ...snapshot.transcripts,
+        ...snapshot.currentTurn.transcripts
+      ]
+    }));
+    if (!verdict || amdFired) {
+      return;
+    }
+    amdFired = true;
+    clearAmdEvaluationTimer();
+    try {
+      await api.markVoicemail({
+        metadata: verdict.metadata
+      });
+    } catch (error) {
+      logger.warn("voice amd markVoicemail failed", {
+        error: toError(error).message,
+        sessionId: options.id
+      });
+    }
+  };
+  const startAmdEvaluationTimer = () => {
+    if (!amdDetector || amdEvaluationTimer || amdFired) {
+      return;
+    }
+    const intervalMs = amdDetector.intervalMs ?? 1000;
+    amdEvaluationTimer = setInterval(() => {
+      evaluateAmd();
+    }, intervalMs);
+  };
+  const callSilenceTimeoutMs = options.callSilenceTimeoutMs && options.callSilenceTimeoutMs > 0 ? options.callSilenceTimeoutMs : undefined;
+  let callSilenceWatchdog = null;
+  let callSilenceFired = false;
+  const clearCallSilenceWatchdog = () => {
+    if (callSilenceWatchdog) {
+      clearTimeout(callSilenceWatchdog);
+      callSilenceWatchdog = null;
+    }
+  };
+  const fireCallSilenceTimeout = () => {
+    callSilenceWatchdog = null;
+    if (callSilenceFired) {
+      return;
+    }
+    callSilenceFired = true;
+    api.close("silence-timeout");
+  };
+  const kickCallSilenceWatchdog = () => {
+    if (callSilenceTimeoutMs === undefined || callSilenceFired) {
+      return;
+    }
+    clearCallSilenceWatchdog();
+    callSilenceWatchdog = setTimeout(fireCallSilenceTimeout, callSilenceTimeoutMs);
+  };
   const recordingConfig = options.recording;
   const recordingChannels = new Set(recordingConfig?.channels ?? ["assistant", "user"]);
   const recordingMaxBytes = recordingConfig?.maxBytesPerChannel ?? 50 * 1024 * 1024;
@@ -5938,6 +6022,7 @@ var createVoiceSession = (options) => {
   const sendAssistantAudio = async (chunk, input) => {
     const normalizedChunk = chunk instanceof Uint8Array ? new Uint8Array(chunk) : chunk instanceof ArrayBuffer ? new Uint8Array(chunk.slice(0)) : new Uint8Array(chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength));
     captureRecordingChunk("assistant", normalizedChunk, input.format);
+    kickCallSilenceWatchdog();
     await send({
       chunkBase64: encodeBase64(normalizedChunk),
       format: input.format,
@@ -6032,6 +6117,8 @@ var createVoiceSession = (options) => {
       recoverable: false,
       type: "error"
     });
+    clearCallSilenceWatchdog();
+    clearAmdEvaluationTimer();
     await closeTTSSession("failed");
     await closeAdapter("failed");
     await persistRecordings();
@@ -6101,6 +6188,8 @@ var createVoiceSession = (options) => {
       sessionId: options.id,
       type: "complete"
     });
+    clearCallSilenceWatchdog();
+    clearAmdEvaluationTimer();
     await closeTTSSession("complete");
     await closeAdapter("complete");
     await persistRecordings();
@@ -6159,19 +6248,21 @@ var createVoiceSession = (options) => {
     });
   };
   const transferInternal = async (input) => {
+    const transferMetadata = input.transferMode === undefined ? input.metadata : { ...input.metadata ?? {}, transferMode: input.transferMode };
     const session = await writeSession((currentSession) => {
       pushCallLifecycleEvent(currentSession, {
-        metadata: input.metadata,
+        metadata: transferMetadata,
         reason: input.reason,
         target: input.target,
         type: "transfer"
       });
     });
     await appendTrace({
-      metadata: input.metadata,
+      metadata: transferMetadata,
       payload: {
         reason: input.reason,
         target: input.target,
+        transferMode: input.transferMode,
         type: "transfer"
       },
       session,
@@ -6956,6 +7047,7 @@ var createVoiceSession = (options) => {
   };
   const commitTurnInternal = async (reason = "manual") => {
     clearSilenceTimer();
+    amdLastTurnCommitAt = Date.now();
     const session = await readSession();
     if (session.status === "completed" || session.status === "failed") {
       return;
@@ -7202,6 +7294,8 @@ var createVoiceSession = (options) => {
     resumePendingTurnCommit(session);
     await ensureAdapter();
     warmTTSSession();
+    kickCallSilenceWatchdog();
+    startAmdEvaluationTimer();
   };
   const disconnectInternal = async (event) => {
     clearSilenceTimer();
@@ -7249,12 +7343,17 @@ var createVoiceSession = (options) => {
       const userBytes = conditionedAudio instanceof Uint8Array ? conditionedAudio : conditionedAudio instanceof ArrayBuffer ? new Uint8Array(conditionedAudio) : new Uint8Array(conditionedAudio.buffer, conditionedAudio.byteOffset, conditionedAudio.byteLength);
       captureRecordingChunk("user", userBytes, recordingConfig.userInputFormat);
     }
+    amdLastAudioLevel = audioLevel;
     if (audioLevel >= turnDetection.speechThreshold) {
+      if (amdFirstAudioAt === undefined) {
+        amdFirstAudioAt = Date.now();
+      }
       if (!speechDetected && activeTTSTurnId !== undefined) {
         cancelActiveTTS("barge-in");
       }
       speechDetected = true;
       clearSilenceTimer();
+      kickCallSilenceWatchdog();
     } else if (speechDetected) {
       const currentSession = await readSession();
       const hasTurnText = Boolean(buildTurnText(currentSession.currentTurn.transcripts, currentSession.currentTurn.partialText, {
@@ -7267,44 +7366,50 @@ var createVoiceSession = (options) => {
     }
     await adapter.send(conditionedAudio);
   };
+  const closeInternal = async (reason, disposition = "closed") => {
+    const session = await writeSession((currentSession) => {
+      if (currentSession.status !== "completed" && currentSession.status !== "failed" && !currentSession.call?.endedAt) {
+        currentSession.lastActivityAt = Date.now();
+        currentSession.status = "completed";
+        pushCallLifecycleEvent(currentSession, {
+          disposition,
+          reason,
+          type: "end"
+        });
+      }
+    });
+    clearSilenceTimer();
+    clearCallSilenceWatchdog();
+    clearAmdEvaluationTimer();
+    await closeTTSSession(reason);
+    await closeAdapter(reason);
+    await persistRecordings();
+    await Promise.resolve(socket.close(1000, reason));
+    if (session.call?.endedAt && session.call.disposition === disposition) {
+      await appendTrace({
+        payload: {
+          disposition,
+          reason,
+          type: "end"
+        },
+        session,
+        type: "call.lifecycle"
+      });
+      await options.route.onCallEnd?.({
+        api,
+        context: options.context,
+        disposition,
+        reason,
+        session
+      });
+    }
+  };
   const api = {
     id: options.id,
     close: async (reason) => {
       await runSerial("api.close", async () => {
-        const session = await writeSession((currentSession) => {
-          if (currentSession.status !== "completed" && currentSession.status !== "failed" && !currentSession.call?.endedAt) {
-            currentSession.lastActivityAt = Date.now();
-            currentSession.status = "completed";
-            pushCallLifecycleEvent(currentSession, {
-              disposition: "closed",
-              reason,
-              type: "end"
-            });
-          }
-        });
-        clearSilenceTimer();
-        await closeTTSSession(reason);
-        await closeAdapter(reason);
-        await persistRecordings();
-        await Promise.resolve(socket.close(1000, reason));
-        if (session.call?.endedAt && session.call.disposition === "closed") {
-          await appendTrace({
-            payload: {
-              disposition: "closed",
-              reason,
-              type: "end"
-            },
-            session,
-            type: "call.lifecycle"
-          });
-          await options.route.onCallEnd?.({
-            api,
-            context: options.context,
-            disposition: "closed",
-            reason,
-            session
-          });
-        }
+        const disposition = reason === "silence-timeout" ? "silence-timeout" : "closed";
+        await closeInternal(reason, disposition);
       });
     },
     commitTurn: async (reason = "manual") => runSerial("api.commitTurn", async () => {

package/dist/types.d.ts

@@ -271,7 +271,7 @@ export type VoiceSessionSummary = {
     status: VoiceSessionStatus;
     turnCount: number;
 };
-export type VoiceCallDisposition = "completed" | "transferred" | "escalated" | "voicemail" | "no-answer" | "failed" | "closed";
+export type VoiceCallDisposition = "completed" | "transferred" | "escalated" | "voicemail" | "no-answer" | "failed" | "silence-timeout" | "closed";
 export type VoiceCallLifecycleEvent = {
     at: number;
     type: "start" | "end" | "transfer" | "escalation" | "voicemail" | "no-answer";
@@ -455,6 +455,7 @@ export type VoiceSessionHandle<TContext = unknown, TSession extends VoiceSession
         reason?: string;
         result?: TResult;
         target: string;
+        transferMode?: "cold" | "warm";
     }) => Promise<void>;
     close: (reason?: string) => Promise<void>;
     snapshot: () => Promise<TSession>;
@@ -467,6 +468,7 @@ export type VoiceRouteResult<TResult = unknown> = {
         metadata?: Record<string, unknown>;
         reason?: string;
         target: string;
+        transferMode?: "cold" | "warm";
     };
     escalate?: {
         metadata?: Record<string, unknown>;
@@ -722,6 +724,8 @@ export type CreateVoiceSessionOptions<TContext = unknown, TSession extends Voice
     store: VoiceSessionStore<TSession>;
     trace?: VoiceTraceEventStore;
     recording?: VoiceSessionRecordingConfig;
+    callSilenceTimeoutMs?: number;
+    amd?: import("./amdDetector").VoiceAMDDetector<TContext, TSession, TResult>;
     reconnect: Required<VoiceReconnectConfig>;
     phraseHints?: VoicePhraseHint[];
     sessionMetadata?: Record<string, unknown>;

package/package.json

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