phonic 0.32.12 → 0.32.14

package/dist/esm/api/resources/tools/client/requests/UpdateToolRequest.d.mts

@@ -22,13 +22,18 @@ export interface UpdateToolRequest {
     /** The static context returned to the agent. Only applicable to custom_context tools. */
     context?: string;
     /**
-     * Array of parameter definitions.
-     * When updating `endpoint_method`, all parameters must include explicit `location` values.
-     * For `custom_webhook` tools: `location` is required for POST, defaults to `"query_string"` for GET.
+     * The tool's parameters, either as a flat array of parameter definitions or as a raw JSON Schema object (use the object form for nested parameters). Replaces the tool's existing parameters, including the form they are stored in.
+     * For `custom_webhook` tools: when sending an array, `location` is required for POST and defaults to `"query_string"` for GET, and `parameter_locations` must not be sent; when sending a JSON Schema object, placement is supplied in `parameter_locations`.
      * For `custom_websocket`, `built_in_transfer_to_phone_number`, and `built_in_transfer_to_agent` tools: `location` must not be specified.
      */
-    parameters?: Phonic.ToolParameter[];
-    /** HTTP method for webhook tools. When changing this value, all parameters must include explicit `location` values. */
+    parameters?: UpdateToolRequest.Parameters;
+    /**
+     * Where each top-level parameter is sent in the webhook request, as a map from parameter name to location. Only for `custom_webhook` tools whose `parameters` are a raw JSON Schema object.
+     * Can be sent on its own to move existing parameters without resending `parameters`; entries are merged over the tool's current placement, so parameters left out keep where they were.
+     * Every key must name a top-level parameter. For POST webhooks, every parameter needs a placement. For GET webhooks, unplaced parameters default to `"query_string"` and `"request_body"` is not allowed.
+     */
+    parameter_locations?: Record<string, UpdateToolRequest.ParameterLocations.Value>;
+    /** HTTP method for webhook tools. When switching from POST to GET, a tool with request body parameters must also send new `parameters` (or `parameter_locations`) placing them in the query string. */
     endpoint_method?: UpdateToolRequest.EndpointMethod;
     /** URL for webhook tools. Must be a publicly routable HTTPS URL without embedded credentials. */
     endpoint_url?: string;
@@ -56,6 +61,8 @@ export interface UpdateToolRequest {
     wait_for_speech_before_tool_call?: boolean;
     /** When true, forbids the agent from speaking after executing the tool. Available for custom_context, custom_webhook and custom_websocket tools. */
     forbid_speech_after_tool_call?: boolean;
+    /** When true, forbids the agent from calling the tool right after it has spoken. Available for custom_webhook and custom_websocket tools. */
+    forbid_tool_call_after_speech?: boolean;
     /** When true, allows the agent to chain and execute other tools after executing the tool. Available for custom_context, custom_webhook and custom_websocket tools. */
     allow_tool_chaining?: boolean;
     /** The agent doesn't typically wait for the response of async custom_websocket tools. When true, makes the agent wait for a response, not call other tools and inform the user of the result. Only available for async custom_websocket tools. */
@@ -68,7 +75,20 @@ export declare namespace UpdateToolRequest {
         readonly Async: "async";
     };
     type ExecutionMode = (typeof ExecutionMode)[keyof typeof ExecutionMode];
-    /** HTTP method for webhook tools. When changing this value, all parameters must include explicit `location` values. */
+    /**
+     * The tool's parameters, either as a flat array of parameter definitions or as a raw JSON Schema object (use the object form for nested parameters). Replaces the tool's existing parameters, including the form they are stored in.
+     * For `custom_webhook` tools: when sending an array, `location` is required for POST and defaults to `"query_string"` for GET, and `parameter_locations` must not be sent; when sending a JSON Schema object, placement is supplied in `parameter_locations`.
+     * For `custom_websocket`, `built_in_transfer_to_phone_number`, and `built_in_transfer_to_agent` tools: `location` must not be specified.
+     */
+    type Parameters = Phonic.ToolParameter[] | Phonic.ToolParametersJsonSchema;
+    namespace ParameterLocations {
+        const Value: {
+            readonly RequestBody: "request_body";
+            readonly QueryString: "query_string";
+        };
+        type Value = (typeof Value)[keyof typeof Value];
+    }
+    /** HTTP method for webhook tools. When switching from POST to GET, a tool with request body parameters must also send new `parameters` (or `parameter_locations`) placing them in the query string. */
     const EndpointMethod: {
         readonly Get: "GET";
         readonly Post: "POST";

package/dist/esm/api/resources/tools/client/requests/UpdateToolRequest.mjs

@@ -6,7 +6,14 @@ export var UpdateToolRequest;
         Sync: "sync",
         Async: "async",
     };
-    /** HTTP method for webhook tools. When changing this value, all parameters must include explicit `location` values. */
+    let ParameterLocations;
+    (function (ParameterLocations) {
+        ParameterLocations.Value = {
+            RequestBody: "request_body",
+            QueryString: "query_string",
+        };
+    })(ParameterLocations = UpdateToolRequest.ParameterLocations || (UpdateToolRequest.ParameterLocations = {}));
+    /** HTTP method for webhook tools. When switching from POST to GET, a tool with request body parameters must also send new `parameters` (or `parameter_locations`) placing them in the query string. */
     UpdateToolRequest.EndpointMethod = {
         Get: "GET",
         Post: "POST",

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

@@ -84,7 +84,7 @@ export interface Agent {
     vad_min_silence_duration_ms?: number | undefined;
     /** Voice activity detection threshold. */
     vad_threshold?: number | undefined;
-    /** When `true`, PII and PHI are redacted from text transcripts (e.g. replaced with tags like `[PHONE NUMBER]`) and bleeped from audio recordings after the conversation ends. */
+    /** When `true`, PII and PHI are redacted from text transcripts (e.g. replaced with tags like `[PHONE]`) and bleeped from audio recordings after the conversation ends. */
     enable_redaction?: boolean | undefined;
     /** The URL-friendly slug of the agent. */
     slug?: string | undefined;

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

@@ -69,7 +69,7 @@ export interface ConfigOptions {
     tools?: Phonic.ToolDefinition[] | undefined;
     /** Template variables for system prompt and welcome message */
     template_variables?: Record<string, string> | undefined;
-    /** When `true`, PII and PHI are redacted from text transcripts (e.g. replaced with tags like `[PHONE NUMBER]`) and bleeped from audio recordings after the conversation ends. */
+    /** When `true`, PII and PHI are redacted from text transcripts (e.g. replaced with tags like `[PHONE]`) and bleeped from audio recordings after the conversation ends. */
     enable_redaction?: boolean | undefined;
     /** Names of pre-configured MCP servers to make available to the assistant. Names must be unique. */
     mcp_servers?: string[] | undefined;

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

@@ -86,7 +86,7 @@ export interface CreateAgentRequest {
     vad_min_silence_duration_ms?: number | undefined;
     /** Voice activity detection threshold. */
     vad_threshold?: number | undefined;
-    /** When `true`, PII and PHI are redacted from text transcripts (e.g. replaced with tags like `[PHONE NUMBER]`) and bleeped from audio recordings after the conversation ends. */
+    /** When `true`, PII and PHI are redacted from text transcripts (e.g. replaced with tags like `[PHONE]`) and bleeped from audio recordings after the conversation ends. */
     enable_redaction?: boolean | undefined;
     /** Array of MCP server IDs to make available to the agent. */
     mcp_server_ids?: string[] | undefined;

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

@@ -15,6 +15,8 @@ export interface InlineWebSocketTool {
     wait_for_speech_before_tool_call?: boolean | undefined;
     /** When true, prevents the assistant from speaking after executing the tool. */
     forbid_speech_after_tool_call?: boolean | undefined;
+    /** When true, prevents the assistant from calling the tool right after it has spoken. */
+    forbid_tool_call_after_speech?: boolean | undefined;
     /** When true, allows the assistant to call another tool after this tool. */
     allow_tool_chaining?: boolean | undefined;
     /** For async tools, when true, the assistant waits for the response and speaks when it arrives. */

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

@@ -47,7 +47,7 @@ export interface OutboundCallConfig {
     min_words_to_interrupt?: number | undefined;
     /** Array of built-in or custom tool names to use. */
     tools?: OutboundCallConfig.Tools.Item[] | undefined;
-    /** When `true`, PII and PHI are redacted from text transcripts (e.g. replaced with tags like `[PHONE NUMBER]`) and bleeped from audio recordings after the conversation ends. */
+    /** When `true`, PII and PHI are redacted from text transcripts (e.g. replaced with tags like `[PHONE]`) and bleeped from audio recordings after the conversation ends. */
     enable_redaction?: boolean | undefined;
     /** The speech-to-speech model to use. */
     model?: "merritt" | undefined;

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

@@ -11,8 +11,17 @@ export interface Tool {
     type: Tool.Type;
     /** Mode of operation - sync waits for response, async continues without waiting. */
     execution_mode?: Tool.ExecutionMode | undefined;
-    /** Array of parameter definitions for the tool. */
-    parameters: Phonic.ToolParameter[];
+    /**
+     * The tool's parameters, returned in the same form they were defined in.
+     * Tools defined with a flat list of parameters return an array of parameter definitions (with `location` included inline for `custom_webhook` tools).
+     * Tools defined with a raw JSON Schema object return that object; for `custom_webhook` tools the parameter placement is then returned separately in `parameter_locations`.
+     */
+    parameters: Tool.Parameters;
+    /**
+     * Where each top-level parameter is sent in the webhook request, as a map from parameter name to location.
+     * Only returned for `custom_webhook` tools whose `parameters` are a raw JSON Schema object. Tools defined with a flat list of parameters carry `location` inline on each parameter instead.
+     */
+    parameter_locations?: Record<string, Tool.ParameterLocations.Value> | undefined;
     /** HTTP method for webhook tools. */
     endpoint_method?: Tool.EndpointMethod | undefined;
     /** URL for webhook tools. */
@@ -43,6 +52,8 @@ export interface Tool {
     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. */
     forbid_speech_after_tool_call?: boolean | undefined;
+    /** When true, forbids the agent from calling the tool right after it has spoken. Available for custom_webhook and custom_websocket tools. */
+    forbid_tool_call_after_speech?: boolean | undefined;
     /** When true, allows the agent to chain and execute other tools after executing the tool. Available for custom_context, custom_webhook and custom_websocket tools. */
     allow_tool_chaining?: boolean | undefined;
     /** The agent doesn't typically wait for the response of async custom_websocket tools. When true, makes the agent wait for a response, not call other tools and inform the user of the result. Only available for async custom_websocket tools. */
@@ -73,6 +84,19 @@ export declare namespace Tool {
         readonly Async: "async";
     };
     type ExecutionMode = (typeof ExecutionMode)[keyof typeof ExecutionMode];
+    /**
+     * The tool's parameters, returned in the same form they were defined in.
+     * Tools defined with a flat list of parameters return an array of parameter definitions (with `location` included inline for `custom_webhook` tools).
+     * Tools defined with a raw JSON Schema object return that object; for `custom_webhook` tools the parameter placement is then returned separately in `parameter_locations`.
+     */
+    type Parameters = Phonic.ToolParameter[] | Phonic.ToolParametersJsonSchema;
+    namespace ParameterLocations {
+        const Value: {
+            readonly RequestBody: "request_body";
+            readonly QueryString: "query_string";
+        };
+        type Value = (typeof Value)[keyof typeof Value];
+    }
     /** HTTP method for webhook tools. */
     const EndpointMethod: {
         readonly Get: "GET";

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

@@ -17,6 +17,13 @@ export var Tool;
         Sync: "sync",
         Async: "async",
     };
+    let ParameterLocations;
+    (function (ParameterLocations) {
+        ParameterLocations.Value = {
+            RequestBody: "request_body",
+            QueryString: "query_string",
+        };
+    })(ParameterLocations = Tool.ParameterLocations || (Tool.ParameterLocations = {}));
     /** HTTP method for webhook tools. */
     Tool.EndpointMethod = {
         Get: "GET",

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

@@ -3,6 +3,8 @@ export interface ToolParameter {
     type: ToolParameter.Type;
     /** Required only when type is "array". The type of items in the array. */
     item_type?: ToolParameter.ItemType | undefined;
+    /** Required only when type is "enum". The fixed set of allowed string values for the parameter. Values must be unique and non-empty. */
+    enum_values?: string[] | undefined;
     /** The parameter name. */
     name: string;
     /** Description of the parameter. */
@@ -14,7 +16,7 @@ export interface ToolParameter {
      * - For GET webhooks: defaults to `"query_string"` and `"request_body"` is not allowed.
      * - For POST webhooks: required, can be either `"request_body"` or `"query_string"`.
      * - Not allowed for `custom_websocket`, `built_in_transfer_to_phone_number`, or `built_in_transfer_to_agent` tools.
-     * When updating a tool's type or endpoint_method, all parameters must include explicit `location` values.
+     * When switching a webhook tool's `endpoint_method` from POST to GET, its request body parameters must be re-sent with `"query_string"` locations.
      */
     location?: ToolParameter.Location | undefined;
 }
@@ -26,6 +28,7 @@ export declare namespace ToolParameter {
         readonly Number: "number";
         readonly Boolean: "boolean";
         readonly Array: "array";
+        readonly Enum: "enum";
     };
     type Type = (typeof Type)[keyof typeof Type];
     /** Required only when type is "array". The type of items in the array. */
@@ -41,7 +44,7 @@ export declare namespace ToolParameter {
      * - For GET webhooks: defaults to `"query_string"` and `"request_body"` is not allowed.
      * - For POST webhooks: required, can be either `"request_body"` or `"query_string"`.
      * - Not allowed for `custom_websocket`, `built_in_transfer_to_phone_number`, or `built_in_transfer_to_agent` tools.
-     * When updating a tool's type or endpoint_method, all parameters must include explicit `location` values.
+     * When switching a webhook tool's `endpoint_method` from POST to GET, its request body parameters must be re-sent with `"query_string"` locations.
      */
     const Location: {
         readonly RequestBody: "request_body";

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

@@ -8,6 +8,7 @@ export var ToolParameter;
         Number: "number",
         Boolean: "boolean",
         Array: "array",
+        Enum: "enum",
     };
     /** Required only when type is "array". The type of items in the array. */
     ToolParameter.ItemType = {
@@ -21,7 +22,7 @@ export var ToolParameter;
      * - For GET webhooks: defaults to `"query_string"` and `"request_body"` is not allowed.
      * - For POST webhooks: required, can be either `"request_body"` or `"query_string"`.
      * - Not allowed for `custom_websocket`, `built_in_transfer_to_phone_number`, or `built_in_transfer_to_agent` tools.
-     * When updating a tool's type or endpoint_method, all parameters must include explicit `location` values.
+     * When switching a webhook tool's `endpoint_method` from POST to GET, its request body parameters must be re-sent with `"query_string"` locations.
      */
     ToolParameter.Location = {
         RequestBody: "request_body",

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

@@ -0,0 +1,15 @@
+/**
+ * A tool's parameters expressed as a raw JSON Schema object, for parameters that the flat `ToolParameter` list cannot express: nested objects, arrays of objects, `anyOf` variants, `null`, and non-string enums.
+ * Each entry in `properties` is a JSON Schema value supporting `type` (`"string"`, `"integer"`, `"number"`, `"boolean"`, `"null"`, `"array"`, `"object"`), `description`, `enum` (string parameters only), `items` (for arrays), `properties`/`required`/`additionalProperties` (for objects) and `anyOf`. Values may be nested up to 5 levels deep.
+ * Parameter names cannot be any of the reserved names that Phonic injects into every tool call: `call_info`, `conversation_id`, `from_phone_number`, `to_phone_number`, `twilio_call_sid`.
+ * For `custom_webhook` tools, parameter placement is supplied separately in `parameter_locations` rather than inline on the schema.
+ */
+export interface ToolParametersJsonSchema {
+    type: "object";
+    /** The tool's top-level parameters, as a map from parameter name to its JSON Schema. */
+    properties: Record<string, unknown>;
+    /** The names of the required top-level parameters. Every name must be defined in `properties`. */
+    required?: string[] | undefined;
+    /** Must be `false`. Tool parameter schemas do not allow properties beyond the ones declared. */
+    additionalProperties?: false | undefined;
+}

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

@@ -0,0 +1,2 @@
+// This file was auto-generated by Fern from our API Definition.
+export {};

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

@@ -68,6 +68,7 @@ export * from "./ToolCallPayload.mjs";
 export * from "./ToolDefinition.mjs";
 export * from "./ToolName.mjs";
 export * from "./ToolParameter.mjs";
+export * from "./ToolParametersJsonSchema.mjs";
 export * from "./UnmutePayload.mjs";
 export * from "./UpdateSystemPromptPayload.mjs";
 export * from "./UpdateToolsSubsetPayload.mjs";

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

@@ -68,6 +68,7 @@ export * from "./ToolCallPayload.mjs";
 export * from "./ToolDefinition.mjs";
 export * from "./ToolName.mjs";
 export * from "./ToolParameter.mjs";
+export * from "./ToolParametersJsonSchema.mjs";
 export * from "./UnmutePayload.mjs";
 export * from "./UpdateSystemPromptPayload.mjs";
 export * from "./UpdateToolsSubsetPayload.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.12";
+export declare const SDK_VERSION = "0.32.14";

package/dist/esm/version.mjs

@@ -1 +1 @@
-export const SDK_VERSION = "0.32.12";
+export const SDK_VERSION = "0.32.14";

package/package.json

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