@elevenlabs/elevenlabs-js 2.19.0 → 2.20.0

package/dist/wrapper/realtime/scribe.js

@@ -0,0 +1,262 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScribeRealtime = exports.CommitStrategy = exports.AudioFormat = void 0;
+const ws_1 = __importDefault(require("ws"));
+const connection_1 = require("./connection");
+const core = __importStar(require("../../core"));
+const environments = __importStar(require("../../environments"));
+var AudioFormat;
+(function (AudioFormat) {
+    AudioFormat["PCM_8000"] = "pcm_8000";
+    AudioFormat["PCM_16000"] = "pcm_16000";
+    AudioFormat["PCM_22050"] = "pcm_22050";
+    AudioFormat["PCM_24000"] = "pcm_24000";
+    AudioFormat["PCM_44100"] = "pcm_44100";
+    AudioFormat["PCM_48000"] = "pcm_48000";
+    AudioFormat["ULAW_8000"] = "ulaw_8000";
+})(AudioFormat || (exports.AudioFormat = AudioFormat = {}));
+var CommitStrategy;
+(function (CommitStrategy) {
+    CommitStrategy["MANUAL"] = "manual";
+    CommitStrategy["VAD"] = "vad";
+})(CommitStrategy || (exports.CommitStrategy = CommitStrategy = {}));
+/**
+ * Real-time speech-to-text transcription client.
+ * @remarks
+ * **Node.js only**: This class uses Node.js-specific APIs (WebSocket from 'ws', child_process).
+ * It will not work in browsers, Deno, or Cloudflare Workers without modifications.
+ */
+class ScribeRealtime {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    getWebSocketUri() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // Get base URL from options, preferring baseUrl, then environment, then default Production
+            const baseUrl = (_b = (_a = (yield core.Supplier.get(this.options.baseUrl))) !== null && _a !== void 0 ? _a : (yield core.Supplier.get(this.options.environment))) !== null && _b !== void 0 ? _b : environments.ElevenLabsEnvironment.Production;
+            // Convert HTTP(S) to WS(S)
+            const wsUrl = baseUrl.replace(/^https?:\/\//i, (match) => match.toLowerCase() === "https://" ? "wss://" : "ws://");
+            return `${wsUrl}/v1/speech-to-text/realtime-beta`;
+        });
+    }
+    checkFfmpegInstalled() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { execSync } = yield Promise.resolve().then(() => __importStar(require("node:child_process")));
+                const command = process.platform === "win32" ? "where ffmpeg" : "which ffmpeg";
+                execSync(command, { stdio: "ignore" });
+            }
+            catch (_a) {
+                throw new Error("ffmpeg is required for URL streaming but was not found. " +
+                    "Please install ffmpeg and ensure it is available in your PATH. " +
+                    "Visit https://ffmpeg.org/download.html for installation instructions.");
+            }
+        });
+    }
+    buildWebSocketUri(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const baseUri = yield this.getWebSocketUri();
+            const params = new URLSearchParams();
+            // Model ID is required, so no check required
+            params.append("model_id", options.modelId);
+            // Add optional parameters if provided, with validation
+            if (options.commitStrategy !== undefined) {
+                params.append("commit_strategy", options.commitStrategy);
+            }
+            if (options.vadSilenceThresholdSecs !== undefined) {
+                if (options.vadSilenceThresholdSecs <= 0.3 || options.vadSilenceThresholdSecs > 3.0) {
+                    throw new Error("vadSilenceThresholdSecs must be between 0.3 and 3.0");
+                }
+                params.append("vad_silence_threshold_secs", options.vadSilenceThresholdSecs.toString());
+            }
+            if (options.vadThreshold !== undefined) {
+                if (options.vadThreshold < 0.1 || options.vadThreshold > 0.9) {
+                    throw new Error("vadThreshold must be between 0.1 and 0.9");
+                }
+                params.append("vad_threshold", options.vadThreshold.toString());
+            }
+            if (options.minSpeechDurationMs !== undefined) {
+                if (options.minSpeechDurationMs <= 50 || options.minSpeechDurationMs > 2000) {
+                    throw new Error("minSpeechDurationMs must be between 50 and 2000");
+                }
+                params.append("min_speech_duration_ms", options.minSpeechDurationMs.toString());
+            }
+            if (options.minSilenceDurationMs !== undefined) {
+                if (options.minSilenceDurationMs <= 50 || options.minSilenceDurationMs > 2000) {
+                    throw new Error("minSilenceDurationMs must be between 50 and 2000");
+                }
+                params.append("min_silence_duration_ms", options.minSilenceDurationMs.toString());
+            }
+            const queryString = params.toString();
+            return queryString ? `${baseUri}?${queryString}` : baseUri;
+        });
+    }
+    /**
+     * Establishes a WebSocket connection for real-time speech-to-text transcription.
+     *
+     * @param options - Configuration options for the connection
+     * @returns A promise that resolves to a RealtimeConnection instance
+     *
+     * @remarks
+     * **Node.js only**: This method uses Node.js-specific APIs.
+     *
+     * When using `UrlOptions` with a URL, ffmpeg must be installed and available in PATH.
+     * The SDK will automatically convert the stream to 16kHz mono PCM format.
+     *
+     * @example
+     * ```typescript
+     * // Manual audio streaming
+     * const connection = await client.speechToText.realtime.connect({
+     *     modelId: "scribe_realtime_v2",
+     *     audioFormat: AudioFormat.PCM_16000,
+     *     sampleRate: 16000,
+     * });
+     *
+     * // Automatic URL streaming (requires ffmpeg)
+     * const connection = await client.speechToText.realtime.connect({
+     *     modelId: "scribe_realtime_v2",
+     *     url: "https://example.com/stream.mp3",
+     * });
+     * ```
+     */
+    connect(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let apiKey = this.options.apiKey;
+            if (!apiKey) {
+                throw new Error("API key is required");
+            }
+            // Resolve API key if it's a function or promise
+            if (typeof apiKey === "function") {
+                apiKey = apiKey();
+            }
+            if (apiKey instanceof Promise) {
+                apiKey = yield apiKey;
+            }
+            if (!apiKey) {
+                throw new Error("API key is required");
+            }
+            if (!options.modelId) {
+                throw new Error("modelId is required");
+            }
+            // Create connection object first so users can attach event listeners before messages arrive
+            const sampleRate = "url" in options ? 16000 : options.sampleRate;
+            const connection = new connection_1.RealtimeConnection(sampleRate);
+            // Build WebSocket URI with query parameters
+            const uri = yield this.buildWebSocketUri(options);
+            return new Promise((resolve) => {
+                const websocket = new ws_1.default(uri, {
+                    headers: {
+                        "xi-api-key": apiKey,
+                    },
+                });
+                // Attach websocket to connection immediately so error handlers are registered
+                // This ensures errors during handshake (like 403) are properly emitted via event emitter
+                connection.setWebSocket(websocket);
+                // Resolve immediately with connection so users can attach listeners
+                resolve(connection);
+                websocket.on("open", () => {
+                    var _a;
+                    // If UrlOptions, start streaming from URL with ffmpeg
+                    if ("url" in options) {
+                        const commitStrategy = (_a = options.commitStrategy) !== null && _a !== void 0 ? _a : CommitStrategy.MANUAL;
+                        this.streamFromUrl(options, connection, commitStrategy);
+                    }
+                });
+            });
+        });
+    }
+    streamFromUrl(options, connection, commitStrategy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            // Check if ffmpeg is installed before attempting to use it
+            yield this.checkFfmpegInstalled();
+            // Dynamically import spawn to avoid bundling issues in non-Node.js environments
+            const { spawn } = yield Promise.resolve().then(() => __importStar(require("node:child_process")));
+            // Spawn ffmpeg to convert the stream to 16kHz mono PCM
+            const ffmpegProcess = spawn("ffmpeg", [
+                "-i", options.url,
+                "-f", "s16le", // 16-bit PCM, little-endian
+                "-acodec", "pcm_s16le", // PCM codec
+                "-ar", "16000", // 16kHz sample rate
+                "-ac", "1", // mono (1 channel)
+                "pipe:1" // output to stdout
+            ]);
+            connection.setFfmpegProcess(ffmpegProcess);
+            (_a = ffmpegProcess.stdout) === null || _a === void 0 ? void 0 : _a.on("data", (chunk) => {
+                const base64Audio = chunk.toString("base64");
+                connection.send({
+                    audioBase64: base64Audio,
+                });
+            });
+            (_b = ffmpegProcess.stdout) === null || _b === void 0 ? void 0 : _b.on("end", () => {
+                if (commitStrategy === CommitStrategy.MANUAL) {
+                    // Manual strategy: commit to finalize transcription, then close
+                    console.log("Stream ended, sending final commit");
+                    connection.commit();
+                }
+                // Close connection since no more audio will be sent
+                connection.close();
+            });
+            (_c = ffmpegProcess.stderr) === null || _c === void 0 ? void 0 : _c.on("data", (data) => {
+                // ffmpeg outputs progress info to stderr, only log errors
+                const message = data.toString();
+                if (message.includes("Error") || message.includes("error")) {
+                    console.error("ffmpeg error:", message);
+                }
+            });
+            ffmpegProcess.on("error", (error) => {
+                console.error("Failed to start ffmpeg:", error);
+            });
+            ffmpegProcess.on("close", (code) => {
+                console.log(`ffmpeg process exited with code ${code}`);
+            });
+        });
+    }
+}
+exports.ScribeRealtime = ScribeRealtime;

package/dist/wrapper/speechToText.d.ts

@@ -0,0 +1,6 @@
+import { SpeechToText as GeneratedSpeechToText } from "../api/resources/speechToText/client/Client";
+import { ScribeRealtime } from "./realtime";
+export declare class SpeechToText extends GeneratedSpeechToText {
+    private _realtime;
+    get realtime(): ScribeRealtime;
+}

package/dist/wrapper/speechToText.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeechToText = void 0;
+const Client_1 = require("../api/resources/speechToText/client/Client");
+const realtime_1 = require("./realtime");
+class SpeechToText extends Client_1.SpeechToText {
+    get realtime() {
+        if (!this._realtime) {
+            this._realtime = new realtime_1.ScribeRealtime(this._options);
+        }
+        return this._realtime;
+    }
+}
+exports.SpeechToText = SpeechToText;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@elevenlabs/elevenlabs-js",
-    "version": "v2.19.0",
+    "version": "v2.20.0",
     "private": false,
     "repository": "github:elevenlabs/elevenlabs-js",
     "license": "MIT",

package/reference.md

@@ -2074,6 +2074,7 @@ Create and auto-convert a podcast project. Currently, the LLM cost is covered by
 
 ```typescript
 await client.studio.createPodcast({
+    safetyIdentifier: "safety-identifier",
     modelId: "eleven_multilingual_v2",
     mode: {
         type: "conversation",
@@ -4334,7 +4335,7 @@ await client.conversationalAi.agents.create({
 </dl>
 </details>
 
-<details><summary><code>client.conversationalAi.agents.<a href="/src/api/resources/conversationalAi/resources/agents/client/Client.ts">get</a>(agentId, { ...params }) -> ElevenLabs.GetAgentResponseModel</code></summary>
+<details><summary><code>client.conversationalAi.agents.<a href="/src/api/resources/conversationalAi/resources/agents/client/Client.ts">get</a>(agentId) -> ElevenLabs.GetAgentResponseModel</code></summary>
 <dl>
 <dd>
 
@@ -4362,9 +4363,7 @@ Retrieve config for an agent
 <dd>
 
 ```typescript
-await client.conversationalAi.agents.get("agent_3701k3ttaq12ewp8b7qv5rfyszkz", {
-    versionId: "version_id",
-});
+await client.conversationalAi.agents.get("agent_3701k3ttaq12ewp8b7qv5rfyszkz");
 ```
 
 </dd>
@@ -4388,14 +4387,6 @@ await client.conversationalAi.agents.get("agent_3701k3ttaq12ewp8b7qv5rfyszkz", {
 <dl>
 <dd>
 
-**request:** `ElevenLabs.conversationalAi.AgentsGetRequest`
-
-</dd>
-</dl>
-
-<dl>
-<dd>
-
 **requestOptions:** `Agents.RequestOptions`
 
 </dd>
@@ -4572,6 +4563,7 @@ Returns a list of your agents and their metadata.
 await client.conversationalAi.agents.list({
     pageSize: 1,
     search: "search",
+    archived: true,
     sortDirection: "asc",
     sortBy: "name",
     cursor: "cursor",

package/serialization/resources/studio/client/requests/BodyCreatePodcastV1StudioPodcastsPost.d.ts

@@ -6,7 +6,7 @@ import { BodyCreatePodcastV1StudioPodcastsPostSource } from "../../types/BodyCre
 import { BodyCreatePodcastV1StudioPodcastsPostQualityPreset } from "../../types/BodyCreatePodcastV1StudioPodcastsPostQualityPreset";
 import { BodyCreatePodcastV1StudioPodcastsPostDurationScale } from "../../types/BodyCreatePodcastV1StudioPodcastsPostDurationScale";
 import { BodyCreatePodcastV1StudioPodcastsPostApplyTextNormalization } from "../../types/BodyCreatePodcastV1StudioPodcastsPostApplyTextNormalization";
-export declare const BodyCreatePodcastV1StudioPodcastsPost: core.serialization.Schema<serializers.BodyCreatePodcastV1StudioPodcastsPost.Raw, ElevenLabs.BodyCreatePodcastV1StudioPodcastsPost>;
+export declare const BodyCreatePodcastV1StudioPodcastsPost: core.serialization.Schema<serializers.BodyCreatePodcastV1StudioPodcastsPost.Raw, Omit<ElevenLabs.BodyCreatePodcastV1StudioPodcastsPost, "safetyIdentifier">>;
 export declare namespace BodyCreatePodcastV1StudioPodcastsPost {
     interface Raw {
         model_id: string;

package/serialization/types/AgentDefinitionSource.d.ts

@@ -0,0 +1,7 @@
+import * as serializers from "../index";
+import * as ElevenLabs from "../../api/index";
+import * as core from "../../core";
+export declare const AgentDefinitionSource: core.serialization.Schema<serializers.AgentDefinitionSource.Raw, ElevenLabs.AgentDefinitionSource>;
+export declare namespace AgentDefinitionSource {
+    type Raw = "cli" | "ui" | "api" | "unknown";
+}

package/serialization/types/{WhatsAppChangeMessages.js → AgentDefinitionSource.js}

@@ -34,6 +34,6 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WhatsAppChangeMessages = void 0;
+exports.AgentDefinitionSource = void 0;
 const core = __importStar(require("../../core"));
-exports.WhatsAppChangeMessages = core.serialization.object({});
+exports.AgentDefinitionSource = core.serialization.enum_(["cli", "ui", "api", "unknown"]);

package/serialization/types/AgentSummaryResponseModel.d.ts

@@ -11,5 +11,6 @@ export declare namespace AgentSummaryResponseModel {
         created_at_unix_secs: number;
         access_info: ResourceAccessInfo.Raw;
         last_call_time_unix_secs?: number | null;
+        archived?: boolean | null;
     }
 }

package/serialization/types/AgentSummaryResponseModel.js

@@ -44,4 +44,5 @@ exports.AgentSummaryResponseModel = core.serialization.object({
     createdAtUnixSecs: core.serialization.property("created_at_unix_secs", core.serialization.number()),
     accessInfo: core.serialization.property("access_info", ResourceAccessInfo_1.ResourceAccessInfo),
     lastCallTimeUnixSecs: core.serialization.property("last_call_time_unix_secs", core.serialization.number().optional()),
+    archived: core.serialization.boolean().optional(),
 });

package/serialization/types/ClientToolConfigInput.d.ts

@@ -3,6 +3,7 @@ import * as ElevenLabs from "../../api/index";
 import * as core from "../../core";
 import { DynamicVariableAssignment } from "./DynamicVariableAssignment";
 import { DynamicVariablesConfig } from "./DynamicVariablesConfig";
+import { ToolExecutionMode } from "./ToolExecutionMode";
 export declare const ClientToolConfigInput: core.serialization.ObjectSchema<serializers.ClientToolConfigInput.Raw, ElevenLabs.ClientToolConfigInput>;
 export declare namespace ClientToolConfigInput {
     interface Raw {
@@ -15,5 +16,6 @@ export declare namespace ClientToolConfigInput {
         parameters?: serializers.ObjectJsonSchemaPropertyInput.Raw | null;
         expects_response?: boolean | null;
         dynamic_variables?: DynamicVariablesConfig.Raw | null;
+        execution_mode?: ToolExecutionMode.Raw | null;
     }
 }

package/serialization/types/ClientToolConfigInput.js

@@ -39,6 +39,7 @@ const serializers = __importStar(require("../index"));
 const core = __importStar(require("../../core"));
 const DynamicVariableAssignment_1 = require("./DynamicVariableAssignment");
 const DynamicVariablesConfig_1 = require("./DynamicVariablesConfig");
+const ToolExecutionMode_1 = require("./ToolExecutionMode");
 exports.ClientToolConfigInput = core.serialization.object({
     name: core.serialization.string(),
     description: core.serialization.string(),
@@ -49,4 +50,5 @@ exports.ClientToolConfigInput = core.serialization.object({
     parameters: core.serialization.lazyObject(() => serializers.ObjectJsonSchemaPropertyInput).optional(),
     expectsResponse: core.serialization.property("expects_response", core.serialization.boolean().optional()),
     dynamicVariables: core.serialization.property("dynamic_variables", DynamicVariablesConfig_1.DynamicVariablesConfig.optional()),
+    executionMode: core.serialization.property("execution_mode", ToolExecutionMode_1.ToolExecutionMode.optional()),
 });

package/serialization/types/ClientToolConfigOutput.d.ts

@@ -3,6 +3,7 @@ import * as ElevenLabs from "../../api/index";
 import * as core from "../../core";
 import { DynamicVariableAssignment } from "./DynamicVariableAssignment";
 import { DynamicVariablesConfig } from "./DynamicVariablesConfig";
+import { ToolExecutionMode } from "./ToolExecutionMode";
 export declare const ClientToolConfigOutput: core.serialization.ObjectSchema<serializers.ClientToolConfigOutput.Raw, ElevenLabs.ClientToolConfigOutput>;
 export declare namespace ClientToolConfigOutput {
     interface Raw {
@@ -15,5 +16,6 @@ export declare namespace ClientToolConfigOutput {
         parameters?: serializers.ObjectJsonSchemaPropertyOutput.Raw | null;
         expects_response?: boolean | null;
         dynamic_variables?: DynamicVariablesConfig.Raw | null;
+        execution_mode?: ToolExecutionMode.Raw | null;
     }
 }

package/serialization/types/ClientToolConfigOutput.js

@@ -39,6 +39,7 @@ const serializers = __importStar(require("../index"));
 const core = __importStar(require("../../core"));
 const DynamicVariableAssignment_1 = require("./DynamicVariableAssignment");
 const DynamicVariablesConfig_1 = require("./DynamicVariablesConfig");
+const ToolExecutionMode_1 = require("./ToolExecutionMode");
 exports.ClientToolConfigOutput = core.serialization.object({
     name: core.serialization.string(),
     description: core.serialization.string(),
@@ -49,4 +50,5 @@ exports.ClientToolConfigOutput = core.serialization.object({
     parameters: core.serialization.lazyObject(() => serializers.ObjectJsonSchemaPropertyOutput).optional(),
     expectsResponse: core.serialization.property("expects_response", core.serialization.boolean().optional()),
     dynamicVariables: core.serialization.property("dynamic_variables", DynamicVariablesConfig_1.DynamicVariablesConfig.optional()),
+    executionMode: core.serialization.property("execution_mode", ToolExecutionMode_1.ToolExecutionMode.optional()),
 });

package/serialization/types/ConversationHistoryMetadataCommonModel.d.ts

@@ -14,6 +14,8 @@ import { ConversationHistoryElevenAssistantCommonModel } from "./ConversationHis
 import { ConversationInitiationSource } from "./ConversationInitiationSource";
 import { ConversationHistoryMetadataCommonModelInitiationTrigger } from "./ConversationHistoryMetadataCommonModelInitiationTrigger";
 import { AsyncConversationMetadata } from "./AsyncConversationMetadata";
+import { WhatsAppConversationInfo } from "./WhatsAppConversationInfo";
+import { AgentDefinitionSource } from "./AgentDefinitionSource";
 export declare const ConversationHistoryMetadataCommonModel: core.serialization.ObjectSchema<serializers.ConversationHistoryMetadataCommonModel.Raw, ElevenLabs.ConversationHistoryMetadataCommonModel>;
 export declare namespace ConversationHistoryMetadataCommonModel {
     interface Raw {
@@ -40,5 +42,8 @@ export declare namespace ConversationHistoryMetadataCommonModel {
         timezone?: string | null;
         initiation_trigger?: ConversationHistoryMetadataCommonModelInitiationTrigger.Raw | null;
         async_metadata?: AsyncConversationMetadata.Raw | null;
+        whatsapp?: WhatsAppConversationInfo.Raw | null;
+        agent_created_from?: AgentDefinitionSource.Raw | null;
+        agent_last_updated_from?: AgentDefinitionSource.Raw | null;
     }
 }

package/serialization/types/ConversationHistoryMetadataCommonModel.js

@@ -49,6 +49,8 @@ const ConversationHistoryElevenAssistantCommonModel_1 = require("./ConversationH
 const ConversationInitiationSource_1 = require("./ConversationInitiationSource");
 const ConversationHistoryMetadataCommonModelInitiationTrigger_1 = require("./ConversationHistoryMetadataCommonModelInitiationTrigger");
 const AsyncConversationMetadata_1 = require("./AsyncConversationMetadata");
+const WhatsAppConversationInfo_1 = require("./WhatsAppConversationInfo");
+const AgentDefinitionSource_1 = require("./AgentDefinitionSource");
 exports.ConversationHistoryMetadataCommonModel = core.serialization.object({
     startTimeUnixSecs: core.serialization.property("start_time_unix_secs", core.serialization.number()),
     acceptedTimeUnixSecs: core.serialization.property("accepted_time_unix_secs", core.serialization.number().optional()),
@@ -73,4 +75,7 @@ exports.ConversationHistoryMetadataCommonModel = core.serialization.object({
     timezone: core.serialization.string().optional(),
     initiationTrigger: core.serialization.property("initiation_trigger", ConversationHistoryMetadataCommonModelInitiationTrigger_1.ConversationHistoryMetadataCommonModelInitiationTrigger.optional()),
     asyncMetadata: core.serialization.property("async_metadata", AsyncConversationMetadata_1.AsyncConversationMetadata.optional()),
+    whatsapp: WhatsAppConversationInfo_1.WhatsAppConversationInfo.optional(),
+    agentCreatedFrom: core.serialization.property("agent_created_from", AgentDefinitionSource_1.AgentDefinitionSource.optional()),
+    agentLastUpdatedFrom: core.serialization.property("agent_last_updated_from", AgentDefinitionSource_1.AgentDefinitionSource.optional()),
 });

package/serialization/types/CreateAgentResponseModel.d.ts

@@ -5,7 +5,5 @@ export declare const CreateAgentResponseModel: core.serialization.ObjectSchema<s
 export declare namespace CreateAgentResponseModel {
     interface Raw {
         agent_id: string;
-        main_branch_id?: string | null;
-        initial_version_id?: string | null;
     }
 }

package/serialization/types/CreateAgentResponseModel.js

@@ -38,6 +38,4 @@ exports.CreateAgentResponseModel = void 0;
 const core = __importStar(require("../../core"));
 exports.CreateAgentResponseModel = core.serialization.object({
     agentId: core.serialization.property("agent_id", core.serialization.string()),
-    mainBranchId: core.serialization.property("main_branch_id", core.serialization.string().optional()),
-    initialVersionId: core.serialization.property("initial_version_id", core.serialization.string().optional()),
 });

package/serialization/types/GetAgentResponseModel.d.ts

@@ -19,6 +19,5 @@ export declare namespace GetAgentResponseModel {
         workflow?: AgentWorkflowResponseModel.Raw | null;
         access_info?: ResourceAccessInfo.Raw | null;
         tags?: string[] | null;
-        version_id?: string | null;
     }
 }

package/serialization/types/GetAgentResponseModel.js

@@ -52,5 +52,4 @@ exports.GetAgentResponseModel = core.serialization.object({
     workflow: AgentWorkflowResponseModel_1.AgentWorkflowResponseModel.optional(),
     accessInfo: core.serialization.property("access_info", ResourceAccessInfo_1.ResourceAccessInfo.optional()),
     tags: core.serialization.list(core.serialization.string()).optional(),
-    versionId: core.serialization.property("version_id", core.serialization.string().optional()),
 });

package/serialization/types/ProjectExtendedResponse.d.ts

@@ -20,6 +20,7 @@ export declare namespace ProjectExtendedResponse {
         project_id: string;
         name: string;
         create_date_unix: number;
+        created_by_user_id?: string | null;
         default_title_voice_id: string;
         default_paragraph_voice_id: string;
         default_model_id: string;

package/serialization/types/ProjectExtendedResponse.js

@@ -53,6 +53,7 @@ exports.ProjectExtendedResponse = core.serialization.object({
     projectId: core.serialization.property("project_id", core.serialization.string()),
     name: core.serialization.string(),
     createDateUnix: core.serialization.property("create_date_unix", core.serialization.number()),
+    createdByUserId: core.serialization.property("created_by_user_id", core.serialization.string().optional()),
     defaultTitleVoiceId: core.serialization.property("default_title_voice_id", core.serialization.string()),
     defaultParagraphVoiceId: core.serialization.property("default_paragraph_voice_id", core.serialization.string()),
     defaultModelId: core.serialization.property("default_model_id", core.serialization.string()),

package/serialization/types/ProjectResponse.d.ts

@@ -15,6 +15,7 @@ export declare namespace ProjectResponse {
         project_id: string;
         name: string;
         create_date_unix: number;
+        created_by_user_id?: string | null;
         default_title_voice_id: string;
         default_paragraph_voice_id: string;
         default_model_id: string;

package/serialization/types/ProjectResponse.js

@@ -48,6 +48,7 @@ exports.ProjectResponse = core.serialization.object({
     projectId: core.serialization.property("project_id", core.serialization.string()),
     name: core.serialization.string(),
     createDateUnix: core.serialization.property("create_date_unix", core.serialization.number()),
+    createdByUserId: core.serialization.property("created_by_user_id", core.serialization.string().optional()),
     defaultTitleVoiceId: core.serialization.property("default_title_voice_id", core.serialization.string()),
     defaultParagraphVoiceId: core.serialization.property("default_paragraph_voice_id", core.serialization.string()),
     defaultModelId: core.serialization.property("default_model_id", core.serialization.string()),

package/serialization/types/ToolExecutionMode.d.ts

@@ -0,0 +1,7 @@
+import * as serializers from "../index";
+import * as ElevenLabs from "../../api/index";
+import * as core from "../../core";
+export declare const ToolExecutionMode: core.serialization.Schema<serializers.ToolExecutionMode.Raw, ElevenLabs.ToolExecutionMode>;
+export declare namespace ToolExecutionMode {
+    type Raw = "immediate" | "post_tool_speech" | "async";
+}

package/{dist/serialization/types/WhatsAppCallDirection.js → serialization/types/ToolExecutionMode.js}

@@ -34,6 +34,6 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WhatsAppCallDirection = void 0;
+exports.ToolExecutionMode = void 0;
 const core = __importStar(require("../../core"));
-exports.WhatsAppCallDirection = core.serialization.enum_(["USER_INITIATED", "BUSINESS_INITIATED"]);
+exports.ToolExecutionMode = core.serialization.enum_(["immediate", "post_tool_speech", "async"]);

package/serialization/types/WebhookToolConfigInput.d.ts

@@ -4,6 +4,7 @@ import * as core from "../../core";
 import { DynamicVariableAssignment } from "./DynamicVariableAssignment";
 import { WebhookToolApiSchemaConfigInput } from "./WebhookToolApiSchemaConfigInput";
 import { DynamicVariablesConfig } from "./DynamicVariablesConfig";
+import { ToolExecutionMode } from "./ToolExecutionMode";
 export declare const WebhookToolConfigInput: core.serialization.ObjectSchema<serializers.WebhookToolConfigInput.Raw, ElevenLabs.WebhookToolConfigInput>;
 export declare namespace WebhookToolConfigInput {
     interface Raw {
@@ -15,5 +16,6 @@ export declare namespace WebhookToolConfigInput {
         assignments?: DynamicVariableAssignment.Raw[] | null;
         api_schema: WebhookToolApiSchemaConfigInput.Raw;
         dynamic_variables?: DynamicVariablesConfig.Raw | null;
+        execution_mode?: ToolExecutionMode.Raw | null;
     }
 }

package/serialization/types/WebhookToolConfigInput.js

@@ -39,6 +39,7 @@ const core = __importStar(require("../../core"));
 const DynamicVariableAssignment_1 = require("./DynamicVariableAssignment");
 const WebhookToolApiSchemaConfigInput_1 = require("./WebhookToolApiSchemaConfigInput");
 const DynamicVariablesConfig_1 = require("./DynamicVariablesConfig");
+const ToolExecutionMode_1 = require("./ToolExecutionMode");
 exports.WebhookToolConfigInput = core.serialization.object({
     name: core.serialization.string(),
     description: core.serialization.string(),
@@ -48,4 +49,5 @@ exports.WebhookToolConfigInput = core.serialization.object({
     assignments: core.serialization.list(DynamicVariableAssignment_1.DynamicVariableAssignment).optional(),
     apiSchema: core.serialization.property("api_schema", WebhookToolApiSchemaConfigInput_1.WebhookToolApiSchemaConfigInput),
     dynamicVariables: core.serialization.property("dynamic_variables", DynamicVariablesConfig_1.DynamicVariablesConfig.optional()),
+    executionMode: core.serialization.property("execution_mode", ToolExecutionMode_1.ToolExecutionMode.optional()),
 });

package/serialization/types/WebhookToolConfigOutput.d.ts

@@ -4,6 +4,7 @@ import * as core from "../../core";
 import { DynamicVariableAssignment } from "./DynamicVariableAssignment";
 import { WebhookToolApiSchemaConfigOutput } from "./WebhookToolApiSchemaConfigOutput";
 import { DynamicVariablesConfig } from "./DynamicVariablesConfig";
+import { ToolExecutionMode } from "./ToolExecutionMode";
 export declare const WebhookToolConfigOutput: core.serialization.ObjectSchema<serializers.WebhookToolConfigOutput.Raw, ElevenLabs.WebhookToolConfigOutput>;
 export declare namespace WebhookToolConfigOutput {
     interface Raw {
@@ -15,5 +16,6 @@ export declare namespace WebhookToolConfigOutput {
         assignments?: DynamicVariableAssignment.Raw[] | null;
         api_schema: WebhookToolApiSchemaConfigOutput.Raw;
         dynamic_variables?: DynamicVariablesConfig.Raw | null;
+        execution_mode?: ToolExecutionMode.Raw | null;
     }
 }

package/serialization/types/WebhookToolConfigOutput.js

@@ -39,6 +39,7 @@ const core = __importStar(require("../../core"));
 const DynamicVariableAssignment_1 = require("./DynamicVariableAssignment");
 const WebhookToolApiSchemaConfigOutput_1 = require("./WebhookToolApiSchemaConfigOutput");
 const DynamicVariablesConfig_1 = require("./DynamicVariablesConfig");
+const ToolExecutionMode_1 = require("./ToolExecutionMode");
 exports.WebhookToolConfigOutput = core.serialization.object({
     name: core.serialization.string(),
     description: core.serialization.string(),
@@ -48,4 +49,5 @@ exports.WebhookToolConfigOutput = core.serialization.object({
     assignments: core.serialization.list(DynamicVariableAssignment_1.DynamicVariableAssignment).optional(),
     apiSchema: core.serialization.property("api_schema", WebhookToolApiSchemaConfigOutput_1.WebhookToolApiSchemaConfigOutput),
     dynamicVariables: core.serialization.property("dynamic_variables", DynamicVariablesConfig_1.DynamicVariablesConfig.optional()),
+    executionMode: core.serialization.property("execution_mode", ToolExecutionMode_1.ToolExecutionMode.optional()),
 });