phonic 0.32.13 → 0.32.15

package/dist/esm/api/types/OutboundCallConfig.d.mts

@@ -97,7 +97,7 @@ export declare namespace OutboundCallConfig {
     }
     type Tools = Tools.Item[];
     namespace Tools {
-        type Item = "keypad_input" | "natural_conversation_ending"
+        type Item = "keypad_input" | "natural_conversation_ending" | "choose_not_to_respond"
         /**
          * Custom tool */
          | string;

package/dist/esm/api/types/Tool.d.mts

@@ -48,6 +48,8 @@ export interface Tool {
     require_speech_before_tool_call?: boolean | undefined;
     /** For built_in_natural_conversation_ending and built_in_keypad_input tools. Whether the agent must speak before calling the tool ("required"), the model decides ("optional"), or the agent must stay silent ("suppressed"). Not used by other tool types. */
     speech_before_tool_call?: Tool.SpeechBeforeToolCall | undefined;
+    /** For built_in_choose_not_to_respond tools. Number of seconds to wait after the tool fires before the agent speaks a follow-up if the user stays silent. When null, the agent stays silent (default). Not used by other tool types. */
+    respond_after_sec?: (number | null) | undefined;
     /** If true, the agent will wait to finish speaking before executing the tool. This is only available for custom_webhook and custom_websocket tools. */
     wait_for_speech_before_tool_call?: boolean | undefined;
     /** When true, forbids the agent from speaking after executing the tool. Available for custom_context, custom_webhook and custom_websocket tools. */

package/dist/esm/api/types/index.d.mts

@@ -13,6 +13,7 @@ export * from "./BasicError.mjs";
 export * from "./BuiltInToolConfig.mjs";
 export * from "./BuiltInToolConfigs.mjs";
 export * from "./BuiltInToolDefinition.mjs";
+export * from "./ChooseNotToRespondToolConfig.mjs";
 export * from "./ConfigOptions.mjs";
 export * from "./ConfigPayload.mjs";
 export * from "./Conversation.mjs";

package/dist/esm/api/types/index.mjs

@@ -13,6 +13,7 @@ export * from "./BasicError.mjs";
 export * from "./BuiltInToolConfig.mjs";
 export * from "./BuiltInToolConfigs.mjs";
 export * from "./BuiltInToolDefinition.mjs";
+export * from "./ChooseNotToRespondToolConfig.mjs";
 export * from "./ConfigOptions.mjs";
 export * from "./ConfigPayload.mjs";
 export * from "./Conversation.mjs";

package/dist/esm/custom/ReconnectableConversationsSocket.d.mts

@@ -27,6 +27,11 @@ type EventHandlers = {
  * with a terminal close code (4800 session expired, 4801 invalid state),
  * the safety cap is reached, or the user calls close().
  *
+ * A reconnectable close is not surfaced to the user's close handler while the
+ * reconnect is in flight. The close is emitted only when reconnection has
+ * failed, meaning the conversation is closing. Closes that are not
+ * reconnectable (1000, 4000, etc) are not affected and will pass through.
+ *
  * Uses composition rather than inheritance to avoid coupling to the parent's
  * private event handler registration or ReconnectingWebSocket internals.
  */
@@ -41,6 +46,8 @@ export declare class ReconnectableConversationsSocket {
     private _cleanupWireListeners;
     private _pendingReconnect;
     private _pendingReplacement;
+    private _lastSuppressedClose;
+    private _gaveUp;
     constructor(args: ReconnectableConversationsSocketArgs);
     /** The conversation ID captured from the server's conversation_created message. */
     get conversationId(): string | null;
@@ -67,9 +74,18 @@ export declare class ReconnectableConversationsSocket {
     connect(): never;
     close(): void;
     waitForOpen(): Promise<core.ReconnectingWebSocket>;
+    private _willReconnectAfter;
+    private _giveUp;
     private _getReconnectDelay;
     /** Schedule a reconnection attempt after backoff delay. */
     private _scheduleReconnect;
+    /** Settle as soon as the abort signal fires rather than waiting on the
+     *  factory, whose promise is caller-supplied (it awaits fresh auth) and
+     *  may never settle — the suppressed close would stay hidden forever.
+     *  Resolves null when aborted; a socket arriving afterwards is closed
+     *  rather than leaked. The listener is removed once the factory settles,
+     *  so a long-lived conversation does not accumulate them on the signal. */
+    private _createSocketOrAbort;
     /** Perform the actual reconnection attempt. */
     private _doReconnect;
     private _wireInner;

package/dist/esm/custom/ReconnectableConversationsSocket.mjs

@@ -44,6 +44,11 @@ const MAX_RECONNECT_ATTEMPTS = 10;
  * with a terminal close code (4800 session expired, 4801 invalid state),
  * the safety cap is reached, or the user calls close().
  *
+ * A reconnectable close is not surfaced to the user's close handler while the
+ * reconnect is in flight. The close is emitted only when reconnection has
+ * failed, meaning the conversation is closing. Closes that are not
+ * reconnectable (1000, 4000, etc) are not affected and will pass through.
+ *
  * Uses composition rather than inheritance to avoid coupling to the parent's
  * private event handler registration or ReconnectingWebSocket internals.
  */
@@ -56,6 +61,8 @@ export class ReconnectableConversationsSocket {
         this._cleanupWireListeners = null;
         this._pendingReconnect = null;
         this._pendingReplacement = false;
+        this._lastSuppressedClose = null;
+        this._gaveUp = false;
         this._createReconnectSocket = args.createReconnectSocket;
         this._abortSignal = args.abortSignal != undefined ? args.abortSignal : null;
         this._inner = new ConversationsSocket({ socket: args.socket });
@@ -134,15 +141,36 @@ export class ReconnectableConversationsSocket {
             clearTimeout(this._pendingReconnect);
             this._pendingReconnect = null;
         }
+        // Close before detaching: ConversationsSocket.close() synthesizes a
+        // 1000 close event, and a user-initiated close should still surface one.
+        this._inner.close();
         (_a = this._cleanupWireListeners) === null || _a === void 0 ? void 0 : _a.call(this);
         this._cleanupWireListeners = null;
-        this._inner.close();
     }
     waitForOpen() {
         return __awaiter(this, void 0, void 0, function* () {
             return this._inner.waitForOpen();
         });
     }
+    _willReconnectAfter(event) {
+        return (!this._isClosed
+            && !this._gaveUp
+            && this._conversationId !== null
+            && isReconnectableClose(event.code, event.reason));
+    }
+    _giveUp() {
+        var _a, _b;
+        this._pendingReplacement = false;
+        if (this._gaveUp || this._isClosed) {
+            return;
+        }
+        this._gaveUp = true;
+        const suppressed = this._lastSuppressedClose;
+        this._lastSuppressedClose = null;
+        if (suppressed !== null) {
+            (_b = (_a = this._handlers).close) === null || _b === void 0 ? void 0 : _b.call(_a, suppressed);
+        }
+    }
     _getReconnectDelay() {
         // Exponential backoff: 500ms, 1s, 2s, 4s, capped at 5s
         const delay = BASE_RECONNECT_DELAY_MS * Math.pow(2, this._reconnectAttempts - 1);
@@ -151,12 +179,18 @@ export class ReconnectableConversationsSocket {
     /** Schedule a reconnection attempt after backoff delay. */
     _scheduleReconnect() {
         var _a, _b, _c;
-        if (this._isClosed || this._conversationId === null || ((_a = this._abortSignal) === null || _a === void 0 ? void 0 : _a.aborted)) {
+        // With no conversation the close was never suppressed, so unlike the
+        // branches below there is nothing to emit.
+        if (this._isClosed || this._conversationId === null) {
+            return;
+        }
+        if ((_a = this._abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) {
+            this._giveUp();
             return;
         }
         if (this._reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-            this._pendingReplacement = false;
             (_c = (_b = this._handlers).error) === null || _c === void 0 ? void 0 : _c.call(_b, new Error("Max reconnect attempts reached"));
+            this._giveUp();
             return;
         }
         // Clear any existing timer to prevent orphaned timeouts
@@ -167,24 +201,70 @@ export class ReconnectableConversationsSocket {
         const delay = this._getReconnectDelay();
         this._pendingReplacement = true;
         this._pendingReconnect = setTimeout(() => {
+            var _a;
             this._pendingReconnect = null;
             if (this._isClosed) {
                 this._pendingReplacement = false;
                 return;
             }
+            if ((_a = this._abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) {
+                this._giveUp();
+                return;
+            }
             void this._doReconnect();
         }, delay);
     }
+    /** Settle as soon as the abort signal fires rather than waiting on the
+     *  factory, whose promise is caller-supplied (it awaits fresh auth) and
+     *  may never settle — the suppressed close would stay hidden forever.
+     *  Resolves null when aborted; a socket arriving afterwards is closed
+     *  rather than leaked. The listener is removed once the factory settles,
+     *  so a long-lived conversation does not accumulate them on the signal. */
+    _createSocketOrAbort(created) {
+        const signal = this._abortSignal;
+        if (signal === null) {
+            return created;
+        }
+        const discardLate = () => {
+            void created.then((socket) => socket.close()).catch(() => undefined);
+        };
+        if (signal.aborted) {
+            discardLate();
+            return Promise.resolve(null);
+        }
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                discardLate();
+                resolve(null);
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+            created.then((socket) => {
+                signal.removeEventListener("abort", onAbort);
+                resolve(socket);
+            }, (error) => {
+                signal.removeEventListener("abort", onAbort);
+                reject(error);
+            });
+        });
+    }
     /** Perform the actual reconnection attempt. */
     _doReconnect() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             try {
                 const created = this._createReconnectSocket(this._conversationId);
-                const newRawSocket = created instanceof Promise ? yield created : created;
+                const newRawSocket = created instanceof Promise ? yield this._createSocketOrAbort(created) : created;
+                if (newRawSocket === null) {
+                    // Aborted while the factory was still in flight.
+                    this._giveUp();
+                    return;
+                }
                 if (this._isClosed || ((_a = this._abortSignal) === null || _a === void 0 ? void 0 : _a.aborted)) {
                     this._pendingReplacement = false;
                     newRawSocket.close();
+                    if (!this._isClosed) {
+                        this._giveUp();
+                    }
                     return;
                 }
                 // Clean up the old socket: remove our custom listeners and close
@@ -197,7 +277,7 @@ export class ReconnectableConversationsSocket {
                 catch ( /* already closed from 1006 */_c) { /* already closed from 1006 */ }
                 const newInner = new ConversationsSocket({ socket: newRawSocket });
                 this._inner = newInner;
-                this._wireInner(newInner, newRawSocket);
+                this._wireInner(newInner, newRawSocket, true);
             }
             catch (_d) {
                 this._pendingReplacement = false;
@@ -208,17 +288,41 @@ export class ReconnectableConversationsSocket {
             }
         });
     }
-    _wireInner(inner, rawSocket) {
-        // Forward events from the inner ConversationsSocket to user handlers.
-        // Clear _pendingReplacement before calling the user's open handler
-        // so that sends inside the handler are not silently dropped.
+    _wireInner(inner, rawSocket, isReplacement = false) {
+        // A replacement that closes before ever opening failed at the transport
+        // level, and its code says nothing about why: ReconnectingWebSocket
+        // synthesizes 1000 for connect errors and timeouts (_handleError ->
+        // _disconnect). Read it as a failed attempt rather than as a close.
+        // _isClosed excluded: close() also reaches this via the synthesized
+        // 1000, and a user-initiated close is a close, not a failed attempt.
+        let opened = false;
+        const isFailedAttempt = () => isReplacement && !opened && !this._isClosed;
+        // Clearing _pendingReplacement before the user's open handler keeps
+        // sends made inside that handler from being dropped.
         inner.on("open", () => {
             var _a, _b;
+            opened = true;
             this._pendingReplacement = false;
+            this._lastSuppressedClose = null;
             (_b = (_a = this._handlers).open) === null || _b === void 0 ? void 0 : _b.call(_a);
         });
         inner.on("message", (msg) => { var _a, _b; return (_b = (_a = this._handlers).message) === null || _b === void 0 ? void 0 : _b.call(_a, msg); });
-        inner.on("close", (ev) => { var _a, _b; return (_b = (_a = this._handlers).close) === null || _b === void 0 ? void 0 : _b.call(_a, ev); });
+        // ConversationsSocket registers this in its constructor, so it runs
+        // before the rawSocket close listener below that schedules the
+        // reconnect — the decision cannot be read off reconnect state here.
+        inner.on("close", (ev) => {
+            var _a, _b;
+            // Leave _lastSuppressedClose holding the original drop, so _giveUp
+            // reports what went wrong rather than this attempt's code.
+            if (isFailedAttempt()) {
+                return;
+            }
+            if (this._willReconnectAfter(ev)) {
+                this._lastSuppressedClose = ev;
+                return;
+            }
+            (_b = (_a = this._handlers).close) === null || _b === void 0 ? void 0 : _b.call(_a, ev);
+        });
         inner.on("error", (err) => { var _a, _b; return (_b = (_a = this._handlers).error) === null || _b === void 0 ? void 0 : _b.call(_a, err); });
         // Intercept raw messages to capture conversation_id and reset reconnect counter
         const onMessage = (event) => {
@@ -238,8 +342,15 @@ export class ReconnectableConversationsSocket {
                 // ignore — inner socket handles parse errors
             }
         };
+        // After giving up this is a plain pass-through: the close was already
+        // forwarded above, and retrying would repeat the give-up error.
         const onClose = (event) => {
-            if (this._isClosed) {
+            if (this._isClosed || this._gaveUp) {
+                return;
+            }
+            if (isFailedAttempt()) {
+                rawSocket.close();
+                this._scheduleReconnect();
                 return;
             }
             if (isReconnectableClose(event.code, event.reason) && this._conversationId !== null) {
@@ -258,6 +369,11 @@ export class ReconnectableConversationsSocket {
         rawSocket.addEventListener("message", onMessage);
         rawSocket.addEventListener("close", onClose);
         this._cleanupWireListeners = () => {
+            // ConversationsSocket.close() synthesizes a 1000 close event, so a
+            // discarded socket would otherwise report a spurious normal closure.
+            for (const event of ["open", "message", "close", "error"]) {
+                inner.on(event, undefined);
+            }
             rawSocket.removeEventListener("message", onMessage);
             rawSocket.removeEventListener("close", onClose);
         };

package/dist/esm/version.d.mts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.32.13";
+export declare const SDK_VERSION = "0.32.15";

package/dist/esm/version.mjs

@@ -1 +1 @@
-export const SDK_VERSION = "0.32.13";
+export const SDK_VERSION = "0.32.15";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "phonic",
-    "version": "0.32.13",
+    "version": "0.32.15",
     "private": false,
     "repository": {
         "type": "git",

package/dist/index.d.mts

@@ -1,240 +0,0 @@
-import WebSocket from 'ws';
-
-type PhonicConfig = {
-    baseUrl?: string;
-    headers?: Record<string, string>;
-    __downstreamWebSocketUrl?: string;
-};
-type FetchOptions = {
-    method: "GET";
-    headers?: Record<string, string>;
-} | {
-    method: "POST";
-    headers?: Record<string, string>;
-    body: string;
-};
-type DataOrError<T> = Promise<{
-    data: T;
-    error: null;
-} | {
-    data: null;
-    error: {
-        message: string;
-        code?: string;
-    };
-}>;
-type ISODate = `${string}-${string}-${string}`;
-type ISODateTime$1 = `${string}Z`;
-
-type ISODateTime = `${string}Z`;
-type ConversationItem = {
-    role: "user";
-    item_idx: number;
-    text: string;
-    duration_ms: number;
-    started_at: string;
-} | {
-    role: "assistant";
-    item_idx: number;
-    text: string;
-    voice_id: string;
-    system_prompt: string;
-    output_audio_speed: number;
-    duration_ms: number;
-    started_at: string;
-};
-type Conversation = {
-    id: string;
-    external_id: string | null;
-    model: string;
-    welcome_message: string | null;
-    input_format: "pcm_44100" | "mulaw_8000";
-    output_format: "pcm_44100" | "mulaw_8000";
-    text: string;
-    duration_ms: number;
-    started_at: ISODateTime;
-    ended_at: ISODateTime;
-    items: Array<ConversationItem>;
-};
-type ConversationSuccessResponse = {
-    conversation: Conversation;
-};
-type ConversationsSuccessResponse = {
-    conversations: Array<Conversation>;
-};
-
-declare class Conversations {
-    private readonly phonic;
-    constructor(phonic: Phonic);
-    get(id: string): DataOrError<ConversationSuccessResponse>;
-    getByExternalId({ project, externalId, }: {
-        project?: string;
-        externalId: string;
-    }): DataOrError<ConversationSuccessResponse>;
-    list({ project, durationMin, durationMax, startedAtMin, startedAtMax, }: {
-        project?: string;
-        durationMin?: number;
-        durationMax?: number;
-        startedAtMin?: ISODate | ISODateTime$1;
-        startedAtMax?: ISODate | ISODateTime$1;
-    }): DataOrError<ConversationsSuccessResponse>;
-}
-
-type PhonicSTSConfig = {
-    project: string;
-    input_format: "pcm_44100" | "mulaw_8000";
-    system_prompt?: string;
-    welcome_message?: string;
-    voice_id?: string;
-    output_format?: "pcm_44100" | "mulaw_8000";
-    enable_silent_audio_fallback?: boolean;
-    experimental_params?: Record<string, unknown>;
-    tools?: string[];
-    vad_prebuffer_duration_ms?: number;
-    vad_min_speech_duration_ms?: number;
-    vad_min_silence_duration_ms?: number;
-    vad_threshold?: number;
-};
-type PhonicSTSWebSocketResponseMessage = {
-    type: "ready_to_start_conversation";
-} | {
-    type: "input_text";
-    text: string;
-} | {
-    type: "audio_chunk";
-    text: string;
-    audio: string;
-} | {
-    type: "is_user_speaking";
-    isUserSpeaking: boolean;
-} | {
-    type: "interrupted_response";
-    interruptedResponse: string;
-} | {
-    type: "assistant_ended_conversation";
-} | {
-    type: "error";
-    error: {
-        message: string;
-        code?: string;
-    };
-    param_errors?: {
-        input_format?: string;
-        system_prompt?: string;
-        welcome_message?: string;
-        voice_id?: string;
-        output_format?: string;
-    };
-};
-type OnMessageCallback = (message: PhonicSTSWebSocketResponseMessage) => void;
-type OnCloseCallback = (event: WebSocket.CloseEvent) => void;
-type OnErrorCallback = (event: WebSocket.ErrorEvent) => void;
-type PhonicSTSOutboundCallConfig = Omit<PhonicSTSConfig, "input_format" | "output_format">;
-type OutboundCallSuccessResponse = {
-    success: true;
-};
-
-type PhonicSTSTwilioOutboundCallParams = {
-    account_sid: string;
-    api_key_sid: string;
-    api_key_secret: string;
-    from_phone_number: string;
-    to_phone_number: string;
-};
-type PhonicSTSTwilioOutboundCallConfig = PhonicSTSOutboundCallConfig;
-type TwilioOutboundCallSuccessResponse = {
-    success: true;
-    callSid: string;
-};
-
-declare class Twilio {
-    private readonly phonic;
-    constructor(phonic: Phonic);
-    outboundCall(params: PhonicSTSTwilioOutboundCallParams, config: PhonicSTSTwilioOutboundCallConfig): DataOrError<TwilioOutboundCallSuccessResponse>;
-}
-
-declare class PhonicSTSWebSocket {
-    private readonly ws;
-    private readonly config;
-    private onMessageCallback;
-    private onCloseCallback;
-    private onErrorCallback;
-    private buffer;
-    private isOpen;
-    constructor(ws: WebSocket, config: PhonicSTSConfig);
-    onMessage(callback: OnMessageCallback): void;
-    onClose(callback: OnCloseCallback): void;
-    onError(callback: OnErrorCallback): void;
-    audioChunk({ audio }: {
-        audio: string;
-    }): void;
-    updateSystemPrompt({ systemPrompt }: {
-        systemPrompt: string;
-    }): void;
-    setExternalId({ externalId }: {
-        externalId: string;
-    }): void;
-    close(code?: number): void;
-}
-
-declare class SpeechToSpeech {
-    private readonly phonic;
-    readonly twilio: Twilio;
-    constructor(phonic: Phonic);
-    websocket(config: PhonicSTSConfig): PhonicSTSWebSocket;
-    outboundCall(toPhoneNumber: string, config: PhonicSTSOutboundCallConfig): DataOrError<OutboundCallSuccessResponse>;
-}
-
-type Voice = {
-    id: string;
-    name: string;
-};
-type VoicesSuccessResponse = {
-    voices: Array<Voice>;
-};
-type VoiceSuccessResponse = {
-    voice: Voice;
-};
-
-declare class Voices {
-    private readonly phonic;
-    constructor(phonic: Phonic);
-    list({ model }: {
-        model: string;
-    }): DataOrError<VoicesSuccessResponse>;
-    get(id: string): DataOrError<VoiceSuccessResponse>;
-}
-
-declare class Phonic {
-    readonly apiKey: string;
-    readonly baseUrl: string;
-    readonly __downstreamWebSocketUrl: string | null;
-    readonly headers: Record<string, string>;
-    readonly conversations: Conversations;
-    readonly voices: Voices;
-    readonly sts: SpeechToSpeech;
-    constructor(apiKey: string, config?: PhonicConfig);
-    fetchRequest<T>(path: string, options: FetchOptions): DataOrError<T>;
-    get<T>(path: string): Promise<{
-        data: null;
-        error: {
-            message: string;
-            code?: string;
-        };
-    } | {
-        data: T;
-        error: null;
-    }>;
-    post<T>(path: string, body: Record<string, unknown>, headers?: Record<string, string>): Promise<{
-        data: null;
-        error: {
-            message: string;
-            code?: string;
-        };
-    } | {
-        data: T;
-        error: null;
-    }>;
-}
-
-export { Phonic, type PhonicSTSConfig, PhonicSTSWebSocket };