twilio-agent-connect 2.0.1 → 2.2.0

package/dist/index.d.ts

@@ -4,6 +4,7 @@ import pino from 'pino';
 import { AxiosInstance } from 'axios';
 import { WebSocket } from 'ws';
 import VoiceResponse from 'twilio/lib/twiml/VoiceResponse.js';
+import { CallListInstanceCreateOptions } from 'twilio/lib/rest/api/v2010/account/call.js';
 import { FastifyInstance, FastifyServerOptions } from 'fastify';
 
 /**
@@ -30,6 +31,15 @@ declare const TwilioMemoryConfigSchema: z.ZodObject<{
     phoneTraitField: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>;
 type TwilioMemoryConfig = z.infer<typeof TwilioMemoryConfigSchema>;
+/** The three Twilio call callbacks TAC serves, one route per kind. */
+declare const CallEventKindSchema: z.ZodEnum<{
+    status: "status";
+    amd: "amd";
+    recording: "recording";
+}>;
+type CallEventKind = z.infer<typeof CallEventKindSchema>;
+/** Iterable form of {@link CallEventKind}, for registering every route. */
+declare const CALL_EVENT_KINDS: readonly CallEventKind[];
 /**
  * TAC configuration schema
  */
@@ -54,8 +64,8 @@ declare const TACConfigSchema: z.ZodObject<{
     voicePublicDomain: z.ZodOptional<z.ZodPreprocess<z.ZodOptional<z.ZodString>>>;
     voiceWebsocketPath: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
     voiceActionPath: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
+    voiceCallEventPath: z.ZodType<string, unknown, z.core.$ZodTypeInternals<string, unknown>>;
     cintelConfigurationId: z.ZodOptional<z.ZodString>;
-    cintelObservationOperatorSid: z.ZodOptional<z.ZodString>;
     cintelSummaryOperatorSid: z.ZodOptional<z.ZodString>;
     region: z.ZodOptional<z.ZodString>;
     studioHandoffFlowSid: z.ZodOptional<z.ZodString>;
@@ -83,8 +93,8 @@ declare const EnvironmentVariables: {
     readonly TWILIO_VOICE_PUBLIC_DOMAIN: "TWILIO_VOICE_PUBLIC_DOMAIN";
     readonly TWILIO_VOICE_WEBSOCKET_PATH: "TWILIO_VOICE_WEBSOCKET_PATH";
     readonly TWILIO_VOICE_ACTION_PATH: "TWILIO_VOICE_ACTION_PATH";
+    readonly TWILIO_VOICE_CALL_EVENT_PATH: "TWILIO_VOICE_CALL_EVENT_PATH";
     readonly TWILIO_TAC_CI_CONFIGURATION_ID: "TWILIO_TAC_CI_CONFIGURATION_ID";
-    readonly TWILIO_TAC_CI_OBSERVATION_OPERATOR_SID: "TWILIO_TAC_CI_OBSERVATION_OPERATOR_SID";
     readonly TWILIO_TAC_CI_SUMMARY_OPERATOR_SID: "TWILIO_TAC_CI_SUMMARY_OPERATOR_SID";
     readonly TWILIO_REGION: "TWILIO_REGION";
     readonly TWILIO_STUDIO_HANDOFF_FLOW_SID: "TWILIO_STUDIO_HANDOFF_FLOW_SID";
@@ -94,8 +104,9 @@ declare const EnvironmentVariables: {
  * Memory retrieval mode for channels.
  *
  * - "always": Fetch memory with the message as query on every inbound message.
- * - "once": Fetch memory once at conversation start with an empty query and
- *   cache it. The cache is invalidated when the conversation becomes INACTIVE.
+ * - "once": Fetch memory once at conversation start with no query (and no
+ *   conversation id, skipping query expansion) and cache it. The cache is
+ *   invalidated when the conversation becomes INACTIVE.
  * - "never": Never automatically fetch memory (default).
  */
 declare const MemoryModeSchema: z.ZodEnum<{
@@ -134,6 +145,7 @@ declare const MemoryParticipantTypeSchema: z.ZodEnum<{
     CUSTOMER: "CUSTOMER";
     AI_AGENT: "AI_AGENT";
     AGENT: "AGENT";
+    UNKNOWN: "UNKNOWN";
 }>;
 type MemoryParticipantType = z.infer<typeof MemoryParticipantTypeSchema>;
 /**
@@ -173,6 +185,7 @@ declare const MemoryParticipantSchema: z.ZodObject<{
         CUSTOMER: "CUSTOMER";
         AI_AGENT: "AI_AGENT";
         AGENT: "AGENT";
+        UNKNOWN: "UNKNOWN";
     }>>;
     profileId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     deliveryStatus: z.ZodOptional<z.ZodEnum<{
@@ -222,6 +235,7 @@ declare const MemoryCommunicationSchema: z.ZodObject<{
             CUSTOMER: "CUSTOMER";
             AI_AGENT: "AI_AGENT";
             AGENT: "AGENT";
+            UNKNOWN: "UNKNOWN";
         }>>;
         profileId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         deliveryStatus: z.ZodOptional<z.ZodEnum<{
@@ -254,6 +268,7 @@ declare const MemoryCommunicationSchema: z.ZodObject<{
             CUSTOMER: "CUSTOMER";
             AI_AGENT: "AI_AGENT";
             AGENT: "AGENT";
+            UNKNOWN: "UNKNOWN";
         }>>;
         profileId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         deliveryStatus: z.ZodOptional<z.ZodEnum<{
@@ -390,6 +405,7 @@ declare const MemoryRetrievalResponseSchema: z.ZodObject<{
                 CUSTOMER: "CUSTOMER";
                 AI_AGENT: "AI_AGENT";
                 AGENT: "AGENT";
+                UNKNOWN: "UNKNOWN";
             }>>;
             profileId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             deliveryStatus: z.ZodOptional<z.ZodEnum<{
@@ -422,6 +438,7 @@ declare const MemoryRetrievalResponseSchema: z.ZodObject<{
                 CUSTOMER: "CUSTOMER";
                 AI_AGENT: "AI_AGENT";
                 AGENT: "AGENT";
+                UNKNOWN: "UNKNOWN";
             }>>;
             profileId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             deliveryStatus: z.ZodOptional<z.ZodEnum<{
@@ -463,13 +480,39 @@ type ProfileResponse = z.infer<typeof ProfileResponseSchema>;
  */
 declare const EMPTY_MEMORY_RESPONSE: MemoryRetrievalResponse;
 /**
- * Response from creating an observation
+ * A single observation in a create request.
+ *
+ * `occurredAt` is required by the Memory API and formatted as ISO 8601.
  */
-declare const CreateObservationResponseSchema: z.ZodObject<{
+declare const ObservationCreateRequestSchema: z.ZodObject<{
     content: z.ZodString;
     source: z.ZodString;
     occurredAt: z.ZodString;
-    conversationIds: z.ZodArray<z.ZodString>;
+    conversationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type ObservationCreateRequest = z.infer<typeof ObservationCreateRequestSchema>;
+/**
+ * Request body for the Memory API Observations endpoint.
+ *
+ * The endpoint is a batch create that wraps observations in an array.
+ */
+declare const CreateObservationsRequestSchema: z.ZodObject<{
+    observations: z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+        source: z.ZodString;
+        occurredAt: z.ZodString;
+        conversationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type CreateObservationsRequest = z.infer<typeof CreateObservationsRequestSchema>;
+/**
+ * Response from creating an observation.
+ *
+ * The Memory API Observations endpoint is a batch create that returns a
+ * confirmation message rather than the persisted observation.
+ */
+declare const CreateObservationResponseSchema: z.ZodObject<{
+    message: z.ZodString;
 }, z.core.$strip>;
 type CreateObservationResponse = z.infer<typeof CreateObservationResponseSchema>;
 /**
@@ -1152,6 +1195,7 @@ interface Profile {
  */
 declare const ConversationSessionSchema: z.ZodObject<{
     conversationId: z.ZodString;
+    callSid: z.ZodOptional<z.ZodString>;
     profileId: z.ZodOptional<z.ZodString>;
     serviceId: z.ZodOptional<z.ZodString>;
     channel: z.ZodEnum<{
@@ -1440,8 +1484,8 @@ interface InitiateConversationResult {
 /**
  * Result of initiating an outbound voice conversation.
  * Note: conversationId is not included because the conversation is created by
- * Conversation Orchestrator during passive hydration — the SDK discovers it
- * lazily on the first prompt via callSid lookup.
+ * Conversation Orchestrator during passive hydration — the SDK discovers it by
+ * callSid, in the background from WebSocket setup.
  */
 interface InitiateVoiceConversationResult {
     callSid: string;
@@ -1827,6 +1871,213 @@ declare const ConversationRelayCallbackPayloadSchema: z.ZodObject<{
     SessionDuration: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type ConversationRelayCallbackPayload = z.infer<typeof ConversationRelayCallbackPayloadSchema>;
+/**
+ * A Twilio `statusCallback` webhook — call progress and disposition.
+ *
+ * By default Twilio sends only the terminal event, which covers every
+ * disposition (`completed` / `busy` / `no-answer` / `failed` / `canceled`); set
+ * `CallOptions.statusCallbackEvent` for the intermediate ones. Register a
+ * handler via `VoiceChannel.onCallStatus`.
+ *
+ * `isUnreached` is computed at parse time so application code doesn't have to
+ * match disposition strings itself.
+ */
+declare const CallStatusEventSchema: z.ZodPipe<z.ZodObject<{
+    callStatus: z.ZodOptional<z.ZodString>;
+    callDuration: z.ZodOptional<z.ZodString>;
+    sipResponseCode: z.ZodOptional<z.ZodString>;
+    callSid: z.ZodString;
+    accountSid: z.ZodOptional<z.ZodString>;
+    extra: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>, z.ZodTransform<{
+    /** Call ended without reaching the callee — i.e. worth a retry. */
+    isUnreached: boolean;
+    callSid: string;
+    extra: Record<string, string>;
+    callStatus?: string | undefined;
+    callDuration?: string | undefined;
+    sipResponseCode?: string | undefined;
+    accountSid?: string | undefined;
+}, {
+    callSid: string;
+    extra: Record<string, string>;
+    callStatus?: string | undefined;
+    callDuration?: string | undefined;
+    sipResponseCode?: string | undefined;
+    accountSid?: string | undefined;
+}>>;
+type CallStatusEvent = z.infer<typeof CallStatusEventSchema>;
+/** Build a {@link CallStatusEvent} from a raw Twilio webhook form. */
+declare function callStatusEventFromForm(form: Record<string, string>): CallStatusEvent;
+/**
+ * A Twilio `asyncAmdStatusCallback` webhook — answering machine detection.
+ *
+ * Fires at most once per call, and only when the call set both
+ * `CallOptions.machineDetection` and `asyncAmd`.
+ *
+ * `answeredBy` is mode-dependent — `machine_start` under `'Enable'`,
+ * `machine_end_beep` / `machine_end_silence` / `machine_end_other` under
+ * `'DetectMessageEnd'`, plus `human` / `fax` / `unknown` in both. Use
+ * `isMachine` rather than matching those yourself. Register a handler via
+ * `VoiceChannel.onAmd`.
+ */
+declare const AmdEventSchema: z.ZodPipe<z.ZodObject<{
+    answeredBy: z.ZodOptional<z.ZodString>;
+    machineDetectionDuration: z.ZodOptional<z.ZodString>;
+    callSid: z.ZodString;
+    accountSid: z.ZodOptional<z.ZodString>;
+    extra: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>, z.ZodTransform<{
+    /**
+     * A machine answered — any `machine_*` value, either mode. `unknown`
+     * (detection timed out) is false, so a call is never hung up on a guess.
+     */
+    isMachine: boolean;
+    callSid: string;
+    extra: Record<string, string>;
+    answeredBy?: string | undefined;
+    machineDetectionDuration?: string | undefined;
+    accountSid?: string | undefined;
+}, {
+    callSid: string;
+    extra: Record<string, string>;
+    answeredBy?: string | undefined;
+    machineDetectionDuration?: string | undefined;
+    accountSid?: string | undefined;
+}>>;
+type AmdEvent = z.infer<typeof AmdEventSchema>;
+/** Build an {@link AmdEvent} from a raw Twilio webhook form. */
+declare function amdEventFromForm(form: Record<string, string>): AmdEvent;
+/**
+ * A Twilio `recordingStatusCallback` webhook — a recording became available.
+ *
+ * Fires when the recording is ready (`recordingUrl` accessible), only when
+ * recording is enabled. Register a handler via `VoiceChannel.onRecording`.
+ */
+declare const RecordingEventSchema: z.ZodObject<{
+    recordingSid: z.ZodOptional<z.ZodString>;
+    recordingUrl: z.ZodOptional<z.ZodString>;
+    recordingStatus: z.ZodOptional<z.ZodString>;
+    recordingDuration: z.ZodOptional<z.ZodString>;
+    callSid: z.ZodString;
+    accountSid: z.ZodOptional<z.ZodString>;
+    extra: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+type RecordingEvent = z.infer<typeof RecordingEventSchema>;
+/** Build a {@link RecordingEvent} from a raw Twilio webhook form. */
+declare function recordingEventFromForm(form: Record<string, string>): RecordingEvent;
+/**
+ * Every parameter `client.calls.create()` accepts, as of the pinned Twilio SDK.
+ *
+ * Unlike Python's `inspect.signature`, TypeScript has no runtime view of a
+ * function's accepted keys, so the set is listed here and pinned to the SDK by
+ * {@link _CallsCreateDriftGuards} at typecheck time. It's needed at runtime
+ * because the Node SDK builds its request body from an explicit whitelist —
+ * an unrecognized key is **silently dropped**, not an error, so without this a
+ * typo would look like it worked.
+ */
+declare const CALLS_CREATE_PARAMS: readonly ["applicationSid", "asyncAmd", "asyncAmdStatusCallback", "asyncAmdStatusCallbackMethod", "byoc", "callerId", "callReason", "callToken", "clientNotificationUrl", "fallbackMethod", "fallbackUrl", "from", "machineDetection", "machineDetectionSilenceTimeout", "machineDetectionSpeechEndThreshold", "machineDetectionSpeechThreshold", "machineDetectionTimeout", "method", "record", "recordingChannels", "recordingStatusCallback", "recordingStatusCallbackEvent", "recordingStatusCallbackMethod", "recordingTrack", "sendDigits", "sipAuthPassword", "sipAuthUsername", "statusCallback", "statusCallbackEvent", "statusCallbackMethod", "timeLimit", "timeout", "to", "trim", "twiml", "url"];
+/**
+ * `calls.create` parameters TAC owns — it builds the call and its TwiML, so a
+ * caller setting these would either be overwritten or break the call.
+ */
+declare const RESERVED_CALL_PARAMS: readonly ["to", "from", "twiml", "url", "applicationSid"];
+type ReservedCallParam = (typeof RESERVED_CALL_PARAMS)[number];
+/**
+ * The `calls.create` parameters TAC types explicitly — the ones outbound
+ * ConversationRelay reaches for. Everything else the SDK accepts is still
+ * forwarded, typed by the SDK itself via {@link CallOptions}.
+ */
+interface TypedCallOptions {
+    /**
+     * Enables AMD. `'Enable'` reports as soon as it can tell human from machine
+     * (to hang up on voicemail); `'DetectMessageEnd'` waits out the greeting (to
+     * leave a message). Required, together with `asyncAmd`, for `onAmd` to fire.
+     */
+    machineDetection?: 'Enable' | 'DetectMessageEnd' | undefined;
+    /**
+     * Detect in the background. Required for `onAmd`: with it off, `AnsweredBy`
+     * comes back on the TwiML request, which inline TwiML can't receive.
+     *
+     * Twilio's API types this as a string; a boolean is serialized for you.
+     */
+    asyncAmd?: boolean | string | undefined;
+    asyncAmdStatusCallback?: string | undefined;
+    asyncAmdStatusCallbackMethod?: string | undefined;
+    machineDetectionTimeout?: number | undefined;
+    machineDetectionSpeechThreshold?: number | undefined;
+    machineDetectionSpeechEndThreshold?: number | undefined;
+    machineDetectionSilenceTimeout?: number | undefined;
+    /** Required for `onRecording`. */
+    record?: boolean | undefined;
+    recordingStatusCallback?: string | undefined;
+    recordingStatusCallbackEvent?: string[] | undefined;
+    recordingChannels?: string | undefined;
+    recordingTrack?: string | undefined;
+    statusCallback?: string | undefined;
+    /**
+     * Lifecycle events to report. Omitted, Twilio sends only `'completed'` —
+     * which covers busy/canceled/failed/no-answer. Set it for ringing/answered.
+     */
+    statusCallbackEvent?: string[] | undefined;
+    statusCallbackMethod?: string | undefined;
+    /** Seconds to ring before giving up. Twilio defaults to 60. */
+    timeout?: number | undefined;
+}
+/**
+ * Parameters for Twilio's `client.calls.create()`.
+ *
+ * {@link TypedCallOptions} covers the ones outbound ConversationRelay reaches
+ * for; any other parameter `calls.create()` accepts is forwarded too, typed by
+ * the Twilio SDK. TAC-owned parameters (`to`, `from`, `twiml`, `url`,
+ * `applicationSid`) are excluded — TAC builds the call and its TwiML.
+ *
+ * Unknown keys are rejected at validation, so a typo fails at
+ * `initiateOutboundConversation` rather than being silently dropped by the SDK.
+ *
+ * @example
+ * ```typescript
+ * const callOptions: CallOptions = {
+ *   machineDetection: 'Enable',
+ *   asyncAmd: true,
+ *   record: true,
+ * };
+ * ```
+ */
+type CallOptions = TypedCallOptions & Omit<CallListInstanceCreateOptions, ReservedCallParam | keyof TypedCallOptions>;
+/**
+ * @internal Fails typecheck unless instantiated with `true`. A conditional type
+ * that merely resolves to `never` is not an error on its own, so the assertion
+ * has to be a constraint violation to be load-bearing.
+ */
+type _AssertTrue<T extends true> = T;
+/**
+ * @internal Compile-time SDK drift guards — do not use directly.
+ * If the Twilio SDK adds, removes, or renames a `calls.create` parameter these
+ * checks fail during `npm run typecheck`, signaling that
+ * {@link CALLS_CREATE_PARAMS} needs updating. Without the `complete` direction a
+ * newly added SDK parameter would be rejected at runtime as unknown.
+ */
+type _CallsCreateDriftGuards = {
+    known: _AssertTrue<(typeof CALLS_CREATE_PARAMS)[number] extends keyof CallListInstanceCreateOptions ? true : false>;
+    complete: _AssertTrue<keyof CallListInstanceCreateOptions extends (typeof CALLS_CREATE_PARAMS)[number] ? true : false>;
+    typedAreRealParams: _AssertTrue<keyof TypedCallOptions extends keyof CallListInstanceCreateOptions ? true : false>;
+    reservedAreRealParams: _AssertTrue<ReservedCallParam extends keyof CallListInstanceCreateOptions ? true : false>;
+};
+/**
+ * Validates {@link CallOptions}. The parsed value is re-widened to `CallOptions`
+ * because the loose object's inferred index signature would otherwise erase the
+ * SDK-derived parameter types.
+ */
+declare const CallOptionsSchema: z.ZodType<CallOptions, unknown>;
+/**
+ * Serialize {@link CallOptions} into the argument object for
+ * `client.calls.create()`, dropping unset keys.
+ *
+ * `asyncAmd` is coerced to a string because Twilio's SDK types it as one,
+ * unlike `record`.
+ */
+declare function callOptionsToCreateParams(options: CallOptions): Record<string, unknown>;
 /**
  * Options for initiating an outbound voice conversation.
  *
@@ -1858,6 +2109,12 @@ interface InitiateVoiceConversationOptions {
      * `VoiceChannelConfig.defaultTwimlOptions` and TAC defaults.
      */
     twimlOptions?: TwiMLOptions | undefined;
+    /**
+     * Parameters for Twilio's `calls.create()` — AMD, recording, status
+     * callbacks, timeout (see {@link CallOptions}). Callback URLs auto-wire when
+     * the matching handler is registered; an explicit URL wins.
+     */
+    callOptions?: CallOptions | undefined;
 }
 declare const InitiateVoiceConversationOptionsSchema: z.ZodType<InitiateVoiceConversationOptions>;
 
@@ -1910,7 +2167,7 @@ type JSONSchema = z.infer<typeof JSONSchemaSchema>;
 /**
  * Tool function signature
  */
-type ToolFunction<TParams = any, TResult = any> = (params: TParams) => Promise<TResult> | TResult;
+type ToolFunction<TParams = unknown, TResult = unknown> = (params: TParams) => Promise<TResult> | TResult;
 /**
  * OpenAI tool format
  */
@@ -1936,6 +2193,28 @@ declare const OpenAIToolSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 type OpenAITool = z.infer<typeof OpenAIToolSchema>;
+/**
+ * Anthropic tool format
+ */
+declare const AnthropicToolSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    input_schema: z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            array: "array";
+        }>;
+        properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        items: z.ZodOptional<z.ZodAny>;
+        enum: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type AnthropicTool = z.infer<typeof AnthropicToolSchema>;
 /**
  * Tool execution context
  */
@@ -2078,7 +2357,6 @@ type OperatorProcessingResult = z.infer<typeof OperatorProcessingResultSchema>;
  */
 declare const ConversationIntelligenceConfigSchema: z.ZodObject<{
     configurationId: z.ZodString;
-    observationOperatorSid: z.ZodOptional<z.ZodString>;
     summaryOperatorSid: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type ConversationIntelligenceConfig = z.infer<typeof ConversationIntelligenceConfigSchema>;
@@ -2176,8 +2454,9 @@ declare class TACConfig {
     readonly voiceWebsocketPath: string;
     /** Path the ConversationRelay action callback is served at (default '/conversation-relay-callback'). */
     readonly voiceActionPath: string;
+    /** Base path the call-event callbacks are served under (default '/twilio/call-events'). */
+    readonly voiceCallEventPath: string;
     readonly cintelConfigurationId?: string;
-    readonly cintelObservationOperatorSid?: string;
     readonly cintelSummaryOperatorSid?: string;
     /** Optional Twilio region subdomain for API routing (e.g. transforms base URLs to `https://{product}.{region}.twilio.com`) */
     readonly region?: string;
@@ -2203,9 +2482,10 @@ declare class TACConfig {
      * Optional environment variables:
      * - TWILIO_WHATSAPP_NUMBER: WhatsApp number for WhatsApp channel (e.g., 'whatsapp:+1234567890')
      * - TWILIO_CONVERSATION_CONFIGURATION_ID: Conversation Orchestrator configuration ID (enables orchestrated mode)
-     * - TWILIO_VOICE_PUBLIC_DOMAIN: Public domain for voice routes (required for voice; domain only, without protocol/port/path, e.g., 'abc123.ngrok.app')
+     * - TWILIO_VOICE_PUBLIC_DOMAIN: Public domain for voice routes (required for voice; a port and/or base path are allowed, e.g., 'abc123.ngrok.app', 'example.ngrok.app:8080', or 'example.com/server1')
      * - TWILIO_VOICE_WEBSOCKET_PATH: Path for the voice WebSocket (default: /ws)
      * - TWILIO_VOICE_ACTION_PATH: Path for the ConversationRelay action callback (default: /conversation-relay-callback)
+     * - TWILIO_VOICE_CALL_EVENT_PATH: Base path for the call-event callbacks — status, async AMD, recording (default: /twilio/call-events)
      * - TWILIO_REGION: Twilio region subdomain for API routing (e.g. transforms base URLs to `https://{product}.{region}.twilio.com`)
      * - TWILIO_STUDIO_HANDOFF_FLOW_SID: Studio Flow SID used by createStudioHandoffTool for human handoff
      * - TWILIO_RCS_SENDER_ID: RCS Sender ID for the RCS channel
@@ -2231,6 +2511,17 @@ declare class TACConfig {
      * ```
      */
     static fromEnv(): TACConfig;
+    /**
+     * Path a call-event callback is served at.
+     *
+     * Single source of truth: the voice channel builds callback URLs from this
+     * and TACServer registers routes at it, so the two can't drift.
+     */
+    callEventPath(kind: CallEventKind): string;
+    /**
+     * Public URL for a call-event callback, or `undefined` without a public domain.
+     */
+    callEventUrl(kind: CallEventKind): string | undefined;
     /**
      * Whether Conversation Orchestrator is configured.
      * Returns false in voice-only mode (no conversationConfigurationId).
@@ -2304,6 +2595,16 @@ declare class MemoryClient extends BaseClient {
      * @returns Promise containing memory retrieval response
      */
     retrieveMemories(profileId: string, request?: Partial<MemoryRetrievalRequest>): Promise<MemoryRetrievalResponse>;
+    /** Cap on per-item validation warnings logged per response, to avoid flooding logs. */
+    private static readonly MAX_INVALID_ITEM_LOGS;
+    /**
+     * Validate an array of memory items one at a time, dropping (and logging)
+     * any that fail validation while keeping the rest.
+     *
+     * Per-item warnings are capped at {@link MemoryClient.MAX_INVALID_ITEM_LOGS}
+     * and followed by a single summary warning with the total `invalid_count`.
+     */
+    private parseItems;
     /**
      * Find profiles that contain a specific identifier value
      *
@@ -2339,14 +2640,18 @@ declare class MemoryClient extends BaseClient {
      */
     getProfile(profileId: string, traitGroups?: string[]): Promise<ProfileResponse>;
     /**
-     * Create an observation for a profile
+     * Create an observation for a profile.
+     *
+     * The Memory API Observations endpoint is a batch create: the observation is
+     * wrapped in an `observations` array and `occurredAt` is required, so it
+     * defaults to the current time (ISO 8601) when omitted or blank.
      *
      * @param profileId - The profile ID to create the observation for
      * @param content - The observation content
      * @param source - Source of the observation (default: 'conversation-intelligence')
      * @param conversationIds - Optional array of conversation IDs associated with this observation
-     * @param occurredAt - Optional timestamp when the observation occurred
-     * @returns Promise containing the created observation
+     * @param occurredAt - Timestamp when the observation occurred (ISO 8601); defaults to now when omitted or blank
+     * @returns Promise containing the API confirmation message
      */
     createObservation(profileId: string, content: string, source?: string, conversationIds?: string[], occurredAt?: string): Promise<CreateObservationResponse>;
     /**
@@ -2542,7 +2847,7 @@ interface BaseChannelOptions {
      *
      * - "never": Memory is not automatically retrieved. Use the memory TAC tool or manually call `tac.retrieveMemory()` in callbacks for conditional retrieval.
      * - "always": Memory is automatically retrieved (using the message as query) for every inbound message and available in `onMessageReady` callback.
-     * - "once": Memory is retrieved once at conversation start with an empty query and cached on the session. Subsequent messages reuse the cache until the conversation becomes INACTIVE.
+     * - "once": Memory is retrieved once at conversation start with no query (and no conversation id) and cached on the session. Subsequent messages reuse the cache until the conversation becomes INACTIVE.
      */
     memoryMode?: MemoryMode;
     /**
@@ -2680,9 +2985,9 @@ declare abstract class BaseChannel {
      *
      * Modes:
      * - "always": Fetch with the provided query on every message.
-     * - "once": Fetch once with an empty query and cache the result on the
-     *   session. Subsequent calls reuse the cache until it is invalidated on the
-     *   INACTIVE transition.
+     * - "once": Fetch once with neither a query nor a conversation id (skipping
+     *   query expansion) and cache the result on the session. Subsequent calls
+     *   reuse the cache until it is invalidated on the INACTIVE transition.
      * - "never": Skip retrieval.
      *
      * Memory retrieval failures are logged and swallowed so message processing
@@ -2833,6 +3138,10 @@ declare class TAC {
      *
      * @param session - Conversation session context
      * @param query - Optional semantic search query
+     * @param conversationId - Passed through to `/Recall` as-is. Sending one
+     *   without a `query` makes Memory infer one from that conversation's history
+     *   — an expensive server-side step — so leave it unset when there is no
+     *   per-turn topic (e.g. `"once"` mode's cache-priming fetch).
      * @returns Promise containing TACMemoryResponse wrapper providing unified access to memory data.
      *
      * Attempts to retrieve from Memory API first:
@@ -2843,7 +3152,7 @@ declare class TAC {
      * - observations and summaries are empty arrays
      * - communications have basic fields only (no author name/type)
      */
-    retrieveMemory(session: ConversationSession, query?: string): Promise<TACMemoryResponse>;
+    retrieveMemory(session: ConversationSession, query?: string, conversationId?: string): Promise<TACMemoryResponse>;
     /**
      * Fetch profile information with traits
      *
@@ -3202,6 +3511,14 @@ interface VoiceChannelConfig extends BaseChannelOptions {
      * higher-priority layer sets them.
      */
     defaultTwimlOptions?: TwiMLOptions;
+    /**
+     * Static {@link CallOptions} applied to every outbound call — the
+     * `calls.create` parameters, including the call-event callback URLs. This is
+     * the layer to use for a custom server or non-default routes: URLs set here
+     * override the ones TAC would derive from `voicePublicDomain` +
+     * `voiceCallEventPath`.
+     */
+    defaultCallOptions?: CallOptions;
 }
 /**
  * Callback that produces per-call overrides for the TwiML inside
@@ -3209,6 +3526,12 @@ interface VoiceChannelConfig extends BaseChannelOptions {
  * {@link TwiMLRequest} and returns {@link TwiMLOptions}.
  */
 type InboundCallTwimlHandler = (req: TwiMLRequest) => Promise<TwiMLOptions>;
+/** Handler for Twilio `statusCallback` webhooks. */
+type CallStatusHandler = (event: CallStatusEvent) => Promise<void> | void;
+/** Handler for Twilio `asyncAmdStatusCallback` webhooks. */
+type AmdHandler = (event: AmdEvent) => Promise<void> | void;
+/** Handler for Twilio `recordingStatusCallback` webhooks. */
+type RecordingHandler = (event: RecordingEvent) => Promise<void> | void;
 /**
  * Voice channel event callbacks extending base callbacks
  */
@@ -3231,6 +3554,10 @@ interface VoiceChannelEvents extends BaseChannelEvents {
         utteranceUntilInterrupt: string | undefined;
         durationUntilInterruptMs: number | undefined;
     }) => void;
+    /**
+     * Fired once the session and WebSocket registration exist — in orchestrated
+     * mode possibly before the first prompt, since the lookup starts at setup.
+     */
     onWebSocketConnected?: (data: {
         conversationId: ConversationId;
     }) => void;
@@ -3259,6 +3586,9 @@ declare class VoiceChannel extends BaseChannel {
     private twilioClient;
     private readonly voiceConfig;
     private onInboundCallTwimlHandler;
+    private onCallStatusHandler;
+    private onAmdHandler;
+    private onRecordingHandler;
     constructor(tac: TAC, options?: VoiceChannelConfig);
     /**
      * Register a callback that produces per-call overrides for the TwiML inside
@@ -3283,6 +3613,68 @@ declare class VoiceChannel extends BaseChannel {
      * `InitiateVoiceConversationOptions.twimlOptions` directly.
      */
     onInboundCallTwiml(callback: InboundCallTwimlHandler): void;
+    /**
+     * Register a handler for Twilio `statusCallback` webhooks.
+     *
+     * This is the Calls-API status callback (call disposition), not the
+     * ConversationRelay session callback — see
+     * {@link handleConversationRelayCallback}.
+     *
+     * Registering does two things: it stores the handler, and it makes later
+     * outbound calls pass `statusCallback` to `calls.create`. With no handler
+     * registered TAC omits that parameter, so Twilio has nowhere to post and the
+     * event never arrives.
+     *
+     * Twilio reports only the terminal event by default, which covers every
+     * disposition; set `CallOptions.statusCallbackEvent` for ringing/answered.
+     *
+     * @example
+     * ```typescript
+     * voiceChannel.onCallStatus(async event => {
+     *   if (event.isUnreached) {
+     *     // queue a retry
+     *   }
+     * });
+     * ```
+     */
+    onCallStatus(callback: CallStatusHandler): void;
+    /**
+     * Register a handler for Twilio `asyncAmdStatusCallback` webhooks.
+     *
+     * Registering makes later outbound calls pass `asyncAmdStatusCallback` to
+     * `calls.create`; without a handler TAC omits it and Twilio has nowhere to
+     * post the result. It does not enable detection — that's per-call, via
+     * `CallOptions.machineDetection` and `asyncAmd`, both of which are required
+     * for this to fire (at most once per call).
+     *
+     * @example
+     * ```typescript
+     * voiceChannel.onAmd(async event => {
+     *   if (event.isMachine) {
+     *     await voiceChannel.endCall(event.callSid); // voicemail → hang up
+     *   }
+     * });
+     * ```
+     */
+    onAmd(callback: AmdHandler): void;
+    /**
+     * Register a handler for Twilio `recordingStatusCallback` webhooks.
+     *
+     * Registering makes later outbound calls pass `recordingStatusCallback` to
+     * `calls.create`; without a handler TAC omits it and Twilio has nowhere to
+     * post. It does not start recording — that's `CallOptions.record`, which is
+     * required for this to fire.
+     *
+     * @example
+     * ```typescript
+     * voiceChannel.onRecording(async event => {
+     *   if (event.recordingStatus === 'completed') {
+     *     // store event.recordingUrl
+     *   }
+     * });
+     * ```
+     */
+    onRecording(callback: RecordingHandler): void;
     /**
      * Resolve the public WebSocket URL from `TACConfig.voicePublicDomain` +
      * `TACConfig.voiceWebsocketPath`. Throws if `voicePublicDomain` isn't set.
@@ -3323,6 +3715,13 @@ declare class VoiceChannel extends BaseChannel {
      * Get active WebSocket connection for a conversation
      */
     getWebsocket(conversationId: ConversationId): WebSocket | null;
+    /**
+     * Poll Conversation Orchestrator for the conversation ConversationRelay
+     * created for `callSid`, then register the local session and WebSocket.
+     * Runs in the background from `setup`, so those can exist before the
+     * caller speaks.
+     */
+    private initializeOrchestratedConversation;
     /**
      * Handle WebSocket connection from ConversationRelay
      */
@@ -3443,13 +3842,42 @@ declare class VoiceChannel extends BaseChannel {
      * `actionUrl` left absent (key not present) falls through to the next layer.
      */
     private resolveActionUrl;
+    /**
+     * Overlay `perCall` onto `VoiceChannelConfig.defaultCallOptions`.
+     *
+     * Per-field via key presence, the same convention {@link overlayFields} uses
+     * for TwiML options — so a per-call `{ machineDetection: undefined }`
+     * explicitly clears the channel default rather than falling through to it.
+     *
+     * The result is always validated, for two reasons: a combination only
+     * reachable by layering — per-call clearing `machineDetection` while the
+     * default set `asyncAmd` — must still fail instead of reaching Twilio, and
+     * `VoiceChannelConfig` is a plain interface, so `defaultCallOptions` has had
+     * no runtime validation of its own.
+     */
+    private mergeCallOptions;
+    /**
+     * Build the extra arguments for `client.calls.create`.
+     *
+     * Layers, highest precedence first: this call's `callOptions`,
+     * `VoiceChannelConfig.defaultCallOptions`, then callback URLs derived from
+     * `voicePublicDomain` + `voiceCallEventPath`.
+     *
+     * A URL is derived only when its handler is registered. That's a deliberate
+     * deviation from `websocketUrl` / `actionUrl`, which derive unconditionally:
+     * those are load-bearing, so a wrong one fails loudly on the first call,
+     * whereas an unwanted call-event URL fails as silent 11200 alerts for a
+     * feature nobody asked for. Set the URLs in `defaultCallOptions` when TAC
+     * isn't serving the routes.
+     */
+    private buildCallParams;
     /**
      * Initiate an outbound voice conversation
      *
      * Places an outbound call with inline TwiML that connects to ConversationRelay.
      * The conversationConfiguration attribute tells CO to create and manage the
-     * conversation during passive hydration. The session is initialized lazily
-     * on the first prompt when the conversation is discovered by callSid.
+     * conversation during passive hydration. The session is initialized when the
+     * background callSid lookup started at WebSocket setup finds it.
      *
      * TwiML fields are merged per-field, highest precedence first:
      *   1. `options.twimlOptions` — per-call overrides
@@ -3458,6 +3886,12 @@ declare class VoiceChannel extends BaseChannel {
      *      `TACConfig`, and `actionUrl` from Studio handoff (if configured), else
      *      derived from `TACConfig.voicePublicDomain` + `voiceActionPath`.
      *
+     * Calls-API parameters merge the same way:
+     *   1. `options.callOptions` — per-call overrides
+     *   2. `VoiceChannelConfig.defaultCallOptions` — channel-wide defaults
+     *   3. Callback URLs derived from `TACConfig.voicePublicDomain` +
+     *      `voiceCallEventPath`, for handlers that are registered
+     *
      * The WebSocket URL is derived from `TACConfig.voicePublicDomain` +
      * `TACConfig.voiceWebsocketPath`, unless overridden per-call via
      * `options.websocketUrl`.
@@ -3475,6 +3909,120 @@ declare class VoiceChannel extends BaseChannel {
         content: string;
         contentType: string;
     }>;
+    /**
+     * Whether a call-webhook payload belongs to the configured account.
+     *
+     * Twilio signature validation already gates the route; this is defense in
+     * depth. A payload with no `AccountSid` is allowed through.
+     *
+     * Subaccounts: events carry the SID the call was placed on, so configure TAC
+     * with that account or its events get dropped here.
+     */
+    private callEventAccountOk;
+    /**
+     * Parse a call-event webhook form and dispatch it to its handler.
+     *
+     * Returns 400 when the payload can't be parsed (no `CallSid`) or the handler
+     * throws — better than handing Twilio a 200 for an event that wasn't
+     * processed. Everything else, including no handler registered and an
+     * account mismatch, is a 200 no-op.
+     */
+    private dispatchCallEvent;
+    /**
+     * Handle a Twilio `statusCallback` webhook.
+     *
+     * The developer routes the request here (`TACServer` does this automatically
+     * for its `/status` call-event route). Parsed into a {@link CallStatusEvent}
+     * and dispatched to the {@link onCallStatus} handler. No-op if no handler is
+     * registered.
+     *
+     * @param form - Raw form data from the webhook request.
+     */
+    handleCallStatusEvent(form: Record<string, string>): Promise<{
+        status: number;
+        content: string;
+        contentType: string;
+    }>;
+    /**
+     * Handle a Twilio `asyncAmdStatusCallback` webhook.
+     *
+     * The developer routes the request here (`TACServer` does this automatically
+     * for its `/amd` call-event route). Parsed into an {@link AmdEvent} and
+     * dispatched to the {@link onAmd} handler. No-op if no handler is registered.
+     *
+     * @param form - Raw form data from the webhook request.
+     */
+    handleAmdEvent(form: Record<string, string>): Promise<{
+        status: number;
+        content: string;
+        contentType: string;
+    }>;
+    /**
+     * Handle a Twilio `recordingStatusCallback` webhook.
+     *
+     * The developer routes the request here (`TACServer` does this automatically
+     * for its `/recording` call-event route). Parsed into a
+     * {@link RecordingEvent} and dispatched to the {@link onRecording} handler.
+     * No-op if no handler is registered.
+     *
+     * @param form - Raw form data from the webhook request.
+     */
+    handleRecordingEvent(form: Record<string, string>): Promise<{
+        status: number;
+        content: string;
+        contentType: string;
+    }>;
+    /**
+     * Hang up a call and clean up its ConversationRelay session.
+     *
+     * Works on `callSid` alone, whether or not a session exists yet. No-ops the
+     * session cleanup if none is tracked.
+     *
+     * Does not throw — hanging up an already-ended call is routine (the callee
+     * hangs up while AMD is still resolving), and handlers shouldn't have to
+     * guard against it.
+     *
+     * @param callSid - Twilio Call SID (from a call event, the outbound result, or
+     *   `ConversationSession.callSid`).
+     * @returns True if Twilio accepted the hangup, false if it failed (logged).
+     *   Session cleanup runs either way.
+     */
+    endCall(callSid: string): Promise<boolean>;
+    /**
+     * Look up the active voice session for a Twilio Call SID.
+     *
+     * Out-of-band code holding a CallSid — a dashboard route, an operator action,
+     * a call-event handler — can't reach the session-facing methods, which are
+     * keyed by conversation id: the Orchestrator conversation id in orchestrator
+     * mode, the CallSid only in ConversationRelay-only mode.
+     *
+     * Relay-only mode creates the session on the first prompt; orchestrated
+     * mode creates it when the lookup started at setup finishes, so it may
+     * exist before the caller speaks — including before `onAmd` fires. Treat it
+     * as racy and hang up with {@link endCall}, which needs no session.
+     *
+     * At the other end, orchestrator mode keeps the session until Conversation
+     * Orchestrator's CLOSED webhook, so it outlives the call and `onCallStatus` /
+     * `onRecording` do resolve. Relay-only mode tears down on the
+     * ConversationRelay callback instead, which races them.
+     *
+     * @example
+     * ```typescript
+     * async function nudge(callSid: string): Promise<void> {
+     *   const session = voiceChannel.getConversationSessionByCallSid(callSid);
+     *   if (session) {
+     *     await voiceChannel.sendResponse(session.conversationId, 'Still there?');
+     *   }
+     * }
+     * ```
+     *
+     * @param callSid - Twilio Call SID, e.g. from
+     *   `InitiateVoiceConversationResult.callSid` or a call event.
+     * @returns The session, or `undefined` — not created yet, the call ended, or
+     *   it landed on another instance (see the horizontal-scaling note in
+     *   CLAUDE.md).
+     */
+    getConversationSessionByCallSid(callSid: string): ConversationSession | undefined;
     /**
      * Start tracking a streaming task for a conversation
      *
@@ -3557,6 +4105,18 @@ declare function scrubObject(obj: unknown, seen?: WeakSet<object>): unknown;
 declare function maskPhone(phone: string): string;
 declare function maskEmail(email: string): string;
 declare function maskAddress(address: string): string;
+/**
+ * Mask `<Parameter value="...">` contents in TwiML, keeping the names.
+ *
+ * `<Parameter>` children carry whatever the developer put in
+ * `customParameters` — profile IDs, caller names. Names stay because knowing
+ * which parameters were sent is the point of logging the TwiML.
+ *
+ * Handles either quote style. TAC's own TwiML comes from the Twilio SDK, which
+ * always double-quotes, but this takes a plain string and shouldn't depend on
+ * that to stay safe.
+ */
+declare function redactTwimlParameters(twiml: string | undefined | null): string;
 
 /**
  * URL builders for Twilio Studio handoff.
@@ -3583,8 +4143,8 @@ declare function studioVoiceHandoffUrl(accountSid: string, flowSid: string): str
 /**
  * Processor for Conversation Intelligence operator result webhooks
  *
- * Processes operator results from CI and creates observations or summaries
- * in the Memory service based on the operator configuration.
+ * Processes operator results from CI and creates conversation summaries in the
+ * Memory service based on the operator configuration.
  */
 declare class OperatorResultProcessor {
     private readonly memoryClient;
@@ -3602,10 +4162,6 @@ declare class OperatorResultProcessor {
      * Process an individual operator result
      */
     private processOperatorResult;
-    /**
-     * Process an observation operator result
-     */
-    private processObservationEvent;
     /**
      * Process a summary operator result
      */
@@ -3741,7 +4297,7 @@ declare class MemoryPromptBuilder {
  *
  * Matches Python's TACTool dataclass with conversion methods.
  */
-declare class TACTool<TParams = any, TResult = any> {
+declare class TACTool<TParams = unknown, TResult = unknown> {
     readonly name: string;
     readonly description: string;
     readonly parameters: JSONSchema;
@@ -3750,11 +4306,11 @@ declare class TACTool<TParams = any, TResult = any> {
     /**
      * Convert to OpenAI function calling format
      */
-    toOpenAIFormat(): Record<string, any>;
+    toOpenAIFormat(): OpenAITool;
     /**
      * Convert to Anthropic tool calling format
      */
-    toAnthropicFormat(): Record<string, any>;
+    toAnthropicFormat(): AnthropicTool;
     /**
      * Convert to JSON string (OpenAI format by default)
      */
@@ -3781,7 +4337,7 @@ declare class TACTool<TParams = any, TResult = any> {
  * Simplified approach matching Python's create_tool function.
  * No builder pattern - just a simple function call.
  */
-declare function defineTool<TParams = any, TResult = any>(name: string, description: string, parameters: JSONSchema, implementation: ToolFunction<TParams, TResult>): TACTool<TParams, TResult>;
+declare function defineTool<TParams = unknown, TResult = unknown>(name: string, description: string, parameters: JSONSchema, implementation: ToolFunction<TParams, TResult>): TACTool<TParams, TResult>;
 
 /**
  * Parameters for memory retrieval tool
@@ -3843,9 +4399,6 @@ declare function createSendMessageTool(channel: BaseChannel, conversationId: Con
  * Create factory function for messaging tools
  */
 declare function createMessagingTools(): {
-    /**
-     * Create send message tool for specific channel and conversation
-     */
     forConversation: (channel: BaseChannel, conversationId: ConversationId) => TACTool<SendMessageParams, SendMessageResult>;
 };
 
@@ -4051,6 +4604,19 @@ declare class TACServer {
     /** All channels that need webhook processing (voice + messaging) */
     private readonly webhookChannels;
     constructor(tac: TAC, config?: TACServerConfig);
+    /**
+     * Validate `voiceCallEventPath`, the one path that isn't literal.
+     *
+     * Every other TAC path registers as configured, so a bad value is visible.
+     * This one expands into three sub-paths, hiding a mistake the base path looks
+     * innocent for: a sub-path colliding with another route while the base looks
+     * unrelated (base `/hooks` vs `webhookPaths.twiml = '/hooks/status'`). Both
+     * would register as POST routes and requests would reach the wrong handler.
+     *
+     * The leading-slash requirement is enforced by `TACConfigSchema` at parse
+     * time, so it doesn't need re-checking here.
+     */
+    private validateCallEventPaths;
     private getForwardedProto;
     private getForwardedHost;
     /**
@@ -4084,4 +4650,4 @@ declare class TACServer {
     stop(): Promise<void>;
 }
 
-export { type ActionChannelSettings, ActionChannelSettingsSchema, type ActionParticipantRef, ActionParticipantRefSchema, type ActionResponse, ActionResponseSchema, type ActionTextContent, ActionTextContentSchema, type AdapterOptions, type AuthorInfo, AuthorInfoSchema, BaseChannel, type BaseChannelEvents, type BaseChannelOptions, BaseClient, type BuiltInToolName, BuiltInTools, type CaptureRule, CaptureRuleSchema, type ChannelSettings, ChannelSettingsSchema, type ChannelType, ChannelTypeSchema, ChatChannel, type ChatChannelConfig, type CintelParticipant, CintelParticipantSchema, type Communication, type CommunicationContent, CommunicationContentSchema, type CommunicationParticipant, CommunicationParticipantSchema, CommunicationSchema, type ConversationAddress, ConversationAddressSchema, ConversationClient, type ConversationConfiguration, ConversationConfigurationSchema, type ConversationEndedCallback, type ConversationGroupingType, ConversationGroupingTypeSchema, type ConversationId, type ConversationIntelligenceConfig, ConversationIntelligenceConfigSchema, type ConversationParticipant, ConversationParticipantSchema, type ConversationRelayAttributes, ConversationRelayAttributesSchema, type ConversationRelayCallbackPayload, ConversationRelayCallbackPayloadSchema, type ConversationRelayConfig, ConversationRelayConfigSchema, type ConversationResponse, ConversationResponseSchema, type ConversationSession, ConversationSessionSchema, type ConversationSummaryItem, ConversationSummaryItemSchema, type ConversationWebhookPayload, type CreateConversationSummariesResponse, CreateConversationSummariesResponseSchema, type CreateObservationResponse, CreateObservationResponseSchema, type CustomParameters, CustomParametersSchema, EMPTY_MEMORY_RESPONSE, EnvironmentVariables, type ExecutionDetails, ExecutionDetailsSchema, type HandoffPayload, HandoffPayloadSchema, type HandoffResult, type InboundCallTwimlHandler, type InitiateChatConversationOptions, type InitiateConversationResult, type InitiateMessagingConversationOptions, InitiateMessagingConversationOptionsSchema, type InitiateVoiceConversationOptions, InitiateVoiceConversationOptionsSchema, type InitiateVoiceConversationResult, type IntelligenceConfiguration, IntelligenceConfigurationSchema, type InterruptCallback, type InterruptMessage, InterruptMessageSchema, type InterruptMode, InterruptModeSchema, type JSONSchema, JSONSchemaSchema, type KnowledgeBase, KnowledgeBaseSchema, type KnowledgeBaseStatus, KnowledgeBaseStatusSchema, type KnowledgeChunkResult, KnowledgeChunkResultSchema, KnowledgeClient, type KnowledgeSearchResponse, KnowledgeSearchResponseSchema, type LanguageAttributes, LanguageAttributesSchema, type LanguageConfig, LanguageConfigSchema, type ListCommunicationsResponse, ListCommunicationsResponseSchema, type ListConversationsResponse, ListConversationsResponseSchema, type ListParticipantsResponse, ListParticipantsResponseSchema, type Logger, type MemoryChannelType, MemoryChannelTypeSchema, MemoryClient, type MemoryCommunication, type MemoryCommunicationContent, MemoryCommunicationContentSchema, MemoryCommunicationSchema, type MemoryDeliveryStatus, MemoryDeliveryStatusSchema, type MemoryMode, MemoryModeSchema, type MemoryParticipant, MemoryParticipantSchema, type MemoryParticipantType, MemoryParticipantTypeSchema, MemoryPromptBuilder, type MemoryRetrievalRequest, MemoryRetrievalRequestSchema, type MemoryRetrievalResponse, MemoryRetrievalResponseSchema, type MessageDirection, MessageDirectionSchema, type MessageReadyCallback, MessagingChannel, type MessagingChannelConfig, type MessagingChannelEvents, type ObservationInfo, ObservationInfoSchema, type OpenAITool, OpenAIToolSchema, type Operator, type OperatorProcessingResult, OperatorProcessingResultSchema, type OperatorResult, type OperatorResultEvent, OperatorResultEventSchema, OperatorResultProcessor, OperatorResultSchema, OperatorSchema, type ParticipantAddress, ParticipantAddressSchema, type ParticipantAddressType, ParticipantAddressTypeSchema, type ParticipantId, type PendingHandoffData, PendingHandoffDataSchema, type Profile, type ProfileId, type ProfileLookupResponse, ProfileLookupResponseSchema, type ProfileResponse, ProfileResponseSchema, type PromptMessage, PromptMessageSchema, RCSChannel, SMSChannel, type SendMessageActionPayload, SendMessageActionPayloadSchema, type SendMessageActionRequest, SendMessageActionRequestSchema, type SessionInfo, SessionInfoSchema, type SessionMessage, SessionMessageSchema, type SetupMessage, SetupMessageSchema, type StatusCallback, StatusCallbackSchema, type StatusTimeouts, StatusTimeoutsSchema, type StreamTask, type SummaryInfo, SummaryInfoSchema, TAC, type TACChannelType, TACChannelTypeSchema, type TACCommunication, type TACCommunicationAuthor, TACCommunicationAuthorSchema, type TACCommunicationContent, TACCommunicationContentSchema, TACCommunicationSchema, TACConfig, type TACConfigData, TACConfigSchema, type TACDeliveryStatus, TACDeliveryStatusSchema, TACMemoryResponse, type TACOptions, type TACParticipantType, TACParticipantTypeSchema, TACServer, type TACServerConfig, TACTool, type TextTokenMessage, TextTokenMessageSchema, type ToolContext, type ToolExecutionResult, ToolExecutionResultSchema, type ToolFunction, type Transcription, TranscriptionSchema, type TranscriptionWord, TranscriptionWordSchema, type TwiMLOptions, TwiMLOptionsSchema, type TwiMLRequest, TwiMLRequestSchema, type TwilioMemoryConfig, TwilioMemoryConfigSchema, VoiceChannel, type VoiceChannelConfig, type VoiceChannelEvents, type WebSocketMessage, WebSocketMessageSchema, WhatsAppChannel, type _SDKDriftGuards, buildHandoffPayload, createKnowledgeSearchTool, createKnowledgeSearchToolAsync, createKnowledgeTools, createLogger, createMemoryRetrievalTool, createMemoryTools, createMessagingTools, createSendMessageTool, createStudioHandoffTool, defineTool, isConversationId, isParticipantId, isProfileId, maskAddress, maskEmail, maskPhone, postStudioHandoff, scrubObject, scrubPii, studioExecutionsUrl, studioVoiceHandoffUrl, twiMLRequestFromForm };
+export { type ActionChannelSettings, ActionChannelSettingsSchema, type ActionParticipantRef, ActionParticipantRefSchema, type ActionResponse, ActionResponseSchema, type ActionTextContent, ActionTextContentSchema, type AdapterOptions, type AmdEvent, AmdEventSchema, type AmdHandler, type AnthropicTool, AnthropicToolSchema, type AuthorInfo, AuthorInfoSchema, BaseChannel, type BaseChannelEvents, type BaseChannelOptions, BaseClient, type BuiltInToolName, BuiltInTools, CALL_EVENT_KINDS, type CallEventKind, CallEventKindSchema, type CallOptions, CallOptionsSchema, type CallStatusEvent, CallStatusEventSchema, type CallStatusHandler, type CaptureRule, CaptureRuleSchema, type ChannelSettings, ChannelSettingsSchema, type ChannelType, ChannelTypeSchema, ChatChannel, type ChatChannelConfig, type CintelParticipant, CintelParticipantSchema, type Communication, type CommunicationContent, CommunicationContentSchema, type CommunicationParticipant, CommunicationParticipantSchema, CommunicationSchema, type ConversationAddress, ConversationAddressSchema, ConversationClient, type ConversationConfiguration, ConversationConfigurationSchema, type ConversationEndedCallback, type ConversationGroupingType, ConversationGroupingTypeSchema, type ConversationId, type ConversationIntelligenceConfig, ConversationIntelligenceConfigSchema, type ConversationParticipant, ConversationParticipantSchema, type ConversationRelayAttributes, ConversationRelayAttributesSchema, type ConversationRelayCallbackPayload, ConversationRelayCallbackPayloadSchema, type ConversationRelayConfig, ConversationRelayConfigSchema, type ConversationResponse, ConversationResponseSchema, type ConversationSession, ConversationSessionSchema, type ConversationSummaryItem, ConversationSummaryItemSchema, type ConversationWebhookPayload, type CreateConversationSummariesResponse, CreateConversationSummariesResponseSchema, type CreateObservationResponse, CreateObservationResponseSchema, type CreateObservationsRequest, CreateObservationsRequestSchema, type CustomParameters, CustomParametersSchema, EMPTY_MEMORY_RESPONSE, EnvironmentVariables, type ExecutionDetails, ExecutionDetailsSchema, type HandoffPayload, HandoffPayloadSchema, type HandoffResult, type InboundCallTwimlHandler, type InitiateChatConversationOptions, type InitiateConversationResult, type InitiateMessagingConversationOptions, InitiateMessagingConversationOptionsSchema, type InitiateVoiceConversationOptions, InitiateVoiceConversationOptionsSchema, type InitiateVoiceConversationResult, type IntelligenceConfiguration, IntelligenceConfigurationSchema, type InterruptCallback, type InterruptMessage, InterruptMessageSchema, type InterruptMode, InterruptModeSchema, type JSONSchema, JSONSchemaSchema, type KnowledgeBase, KnowledgeBaseSchema, type KnowledgeBaseStatus, KnowledgeBaseStatusSchema, type KnowledgeChunkResult, KnowledgeChunkResultSchema, KnowledgeClient, type KnowledgeSearchResponse, KnowledgeSearchResponseSchema, type LanguageAttributes, LanguageAttributesSchema, type LanguageConfig, LanguageConfigSchema, type ListCommunicationsResponse, ListCommunicationsResponseSchema, type ListConversationsResponse, ListConversationsResponseSchema, type ListParticipantsResponse, ListParticipantsResponseSchema, type Logger, type MemoryChannelType, MemoryChannelTypeSchema, MemoryClient, type MemoryCommunication, type MemoryCommunicationContent, MemoryCommunicationContentSchema, MemoryCommunicationSchema, type MemoryDeliveryStatus, MemoryDeliveryStatusSchema, type MemoryMode, MemoryModeSchema, type MemoryParticipant, MemoryParticipantSchema, type MemoryParticipantType, MemoryParticipantTypeSchema, MemoryPromptBuilder, type MemoryRetrievalRequest, MemoryRetrievalRequestSchema, type MemoryRetrievalResponse, MemoryRetrievalResponseSchema, type MessageDirection, MessageDirectionSchema, type MessageReadyCallback, MessagingChannel, type MessagingChannelConfig, type MessagingChannelEvents, type ObservationCreateRequest, ObservationCreateRequestSchema, type ObservationInfo, ObservationInfoSchema, type OpenAITool, OpenAIToolSchema, type Operator, type OperatorProcessingResult, OperatorProcessingResultSchema, type OperatorResult, type OperatorResultEvent, OperatorResultEventSchema, OperatorResultProcessor, OperatorResultSchema, OperatorSchema, type ParticipantAddress, ParticipantAddressSchema, type ParticipantAddressType, ParticipantAddressTypeSchema, type ParticipantId, type PendingHandoffData, PendingHandoffDataSchema, type Profile, type ProfileId, type ProfileLookupResponse, ProfileLookupResponseSchema, type ProfileResponse, ProfileResponseSchema, type PromptMessage, PromptMessageSchema, RCSChannel, type RecordingEvent, RecordingEventSchema, type RecordingHandler, SMSChannel, type SendMessageActionPayload, SendMessageActionPayloadSchema, type SendMessageActionRequest, SendMessageActionRequestSchema, type SessionInfo, SessionInfoSchema, type SessionMessage, SessionMessageSchema, type SetupMessage, SetupMessageSchema, type StatusCallback, StatusCallbackSchema, type StatusTimeouts, StatusTimeoutsSchema, type StreamTask, type SummaryInfo, SummaryInfoSchema, TAC, type TACChannelType, TACChannelTypeSchema, type TACCommunication, type TACCommunicationAuthor, TACCommunicationAuthorSchema, type TACCommunicationContent, TACCommunicationContentSchema, TACCommunicationSchema, TACConfig, type TACConfigData, TACConfigSchema, type TACDeliveryStatus, TACDeliveryStatusSchema, TACMemoryResponse, type TACOptions, type TACParticipantType, TACParticipantTypeSchema, TACServer, type TACServerConfig, TACTool, type TextTokenMessage, TextTokenMessageSchema, type ToolContext, type ToolExecutionResult, ToolExecutionResultSchema, type ToolFunction, type Transcription, TranscriptionSchema, type TranscriptionWord, TranscriptionWordSchema, type TwiMLOptions, TwiMLOptionsSchema, type TwiMLRequest, TwiMLRequestSchema, type TwilioMemoryConfig, TwilioMemoryConfigSchema, type TypedCallOptions, VoiceChannel, type VoiceChannelConfig, type VoiceChannelEvents, type WebSocketMessage, WebSocketMessageSchema, WhatsAppChannel, type _CallsCreateDriftGuards, type _SDKDriftGuards, amdEventFromForm, buildHandoffPayload, callOptionsToCreateParams, callStatusEventFromForm, createKnowledgeSearchTool, createKnowledgeSearchToolAsync, createKnowledgeTools, createLogger, createMemoryRetrievalTool, createMemoryTools, createMessagingTools, createSendMessageTool, createStudioHandoffTool, defineTool, isConversationId, isParticipantId, isProfileId, maskAddress, maskEmail, maskPhone, postStudioHandoff, recordingEventFromForm, redactTwimlParameters, scrubObject, scrubPii, studioExecutionsUrl, studioVoiceHandoffUrl, twiMLRequestFromForm };