@d-id/client-sdk 3.0.0-staging.413 → 3.0.0-staging.414

package/dist/src/types/entities/agents/manager.d.ts

@@ -1,10 +1,10 @@
-import { STTTokenResponse } from '../..';
+import { SttTokenResponse } from '../..';
 import { Auth } from '../../auth';
-import { AgentActivityState, ClientToolHandler, CompatibilityMode, ConnectionState, ConnectivityState, PublicDataChannelTopic, SendStreamPayloadResponse, StreamCreatedInfo, StreamEvents, StreamType, StreamingState } from '../../stream';
-import { SupportedStreamScript } from '../../stream-script';
+import { AgentActivityState, ClientToolHandler, CompatibilityMode, ConnectionState, ConnectivityState, DataChannelTopic, SpeakResponse, StreamCreatedInfo, StreamEvents, StreamType, StreamingState } from '../../stream';
+import { SpeakScript } from '../../stream-script';
 import { StreamingManagerCallbacks as StreamManagerCallbacks } from '../../stream/stream';
 import { Agent } from './agent';
-import { ChatMode, ChatResponse, Interrupt, Message, RatingEntity, SubmitFeedbackResponse } from './chat';
+import { ChatMode, ChatResponse, InterruptOptions, Message, Rating, SubmitFeedbackResponse } from './chat';
 
 /**
  * Types of events provided in Chat Progress Callback
@@ -159,7 +159,7 @@ export interface AgentManagerCallbacks {
      * given, and again on every {@link AgentManager.connect | connect()} after the first — both
      * with type `answer`. The array is a fresh copy on each call, oldest message first; every
      * {@link Message} carries an `id`, a `role` of `user` or `assistant` (the agent), its `content`
-     * and a `created_at` timestamp.
+     * and a `createdAt` timestamp.
      *
      * @param messages - The chat so far.
      * @param type - `partial` while the agent's answer is still streaming in, `answer` for the full
@@ -253,15 +253,15 @@ export interface AgentManagerCallbacks {
      * Fires before the connection reaches {@link ConnectionState.Connected | 'connected'}. The ids
      * are useful when correlating a session with D-ID support or with your own logs.
      *
-     * @param stream - The new stream's `stream_id`, `session_id` and `agent_id`.
+     * @param stream - The new stream's `streamId`, `sessionId` and `agentId`.
      */
     onStreamCreated?: (stream: StreamCreatedInfo) => void;
     /**
      * Called when the agent starts, finishes or fails a tool call.
      *
      * Expressive (V4) agents only. The handler takes two arguments and returns nothing: `event`,
-     * one of {@link StreamEvents.ToolCallStarted}, {@link StreamEvents.ToolCallDone} or
-     * {@link StreamEvents.ToolCallError}; and `data`, the payload that event narrows to —
+     * one of {@link ToolCallEvent.Started}, {@link ToolCallEvent.Done} or
+     * {@link ToolCallEvent.Error}; and `data`, the payload that event narrows to —
      * {@link ToolCallStartedPayload}, {@link ToolCallDonePayload} or
      * {@link ToolCallErrorPayload} respectively. The overloads that do the narrowing are on
      * {@link ToolEventCallback}, with an example handler.
@@ -273,7 +273,7 @@ export interface AgentManagerCallbacks {
      * Expressive (V4) agents only, and about whether interrupting is allowed *right now*: it goes
      * `false` while a `blocking` client tool call is outstanding, because the agent is suspended
      * waiting for it, and back to `true` when the call finishes. That is a different question from
-     * {@link AgentManager.getIsInterruptAvailable | getIsInterruptAvailable()}, which says whether
+     * {@link AgentManager.isInterruptAvailable | isInterruptAvailable()}, which says whether
      * the session supports interrupting at all. Use this one to enable or disable an interrupt
      * button. Talks (V2) and Clips (V3) agents never report a change.
      */
@@ -438,7 +438,7 @@ export interface AgentManagerOptions {
      * Extra properties merged into every analytics event the SDK sends.
      *
      * A flat object — use it to tag events with your own identifiers. More properties can be added
-     * later with {@link AgentManager.enrichAnalytics | enrichAnalytics()}.
+     * later with `enrichAnalytics()`.
      */
     mixpanelAdditionalProperties?: Record<string, unknown>;
     /**
@@ -533,7 +533,7 @@ export interface AgentManager {
      *
      * @returns `true` when {@link AgentManager.interrupt | interrupt()} can do anything.
      */
-    getIsInterruptAvailable(): boolean;
+    isInterruptAvailable(): boolean;
     /**
      * The agent's starter messages.
      *
@@ -547,12 +547,12 @@ export interface AgentManager {
      * The SDK sends the request whenever it is called, connected or not; the service decides
      * whether to issue a token for the agent.
      *
-     * @returns The {@link STTTokenResponse} for this agent.
+     * @returns The {@link SttTokenResponse} for this agent.
      * @throws {@link HttpError} When the service does not answer with a token, or the request comes
      * back non-2xx for any other reason.
      * @throws {@link NetworkError} When the request never reaches the server.
      */
-    getSTTToken(): Promise<STTTokenResponse>;
+    getSttToken(): Promise<SttTokenResponse>;
     /**
      * Opens a new session with the agent: a new WebRTC connection, a new web socket and a new chat.
      *
@@ -701,24 +701,24 @@ export interface AgentManager {
      * @param messageId - Id of the message being rated.
      * @param score - 1 for a positive rating, -1 for a negative one.
      * @param rateId - Id of an existing rating to update; omit to create a new one.
-     * @returns The created or updated {@link RatingEntity}.
+     * @returns The created or updated {@link Rating}.
      * @throws {@link ValidationError} When no chat has started, or when no message with that id is
      * in the transcript.
      * @throws {@link HttpError} When the rating request comes back non-2xx.
      * @throws {@link NetworkError} When the rating request never reaches the server.
      */
-    rate(messageId: string, score: 1 | -1, rateId?: string): Promise<RatingEntity>;
+    rate(messageId: string, score: 1 | -1, rateId?: string): Promise<Rating>;
     /**
      * Removes a rating the user gave to an answer in the chat.
      *
      * @param id - Id of the rating to remove, as returned by
      * {@link AgentManager.rate | rate()}.
-     * @returns The {@link RatingEntity} that was deleted.
+     * @returns The {@link Rating} that was deleted.
      * @throws {@link ValidationError} When no chat has started.
      * @throws {@link HttpError} When the delete request comes back non-2xx.
      * @throws {@link NetworkError} When the delete request never reaches the server.
      */
-    deleteRate(id: string): Promise<RatingEntity>;
+    deleteRate(id: string): Promise<Rating>;
     /**
      * Submits end-of-call feedback for the whole conversation.
      *
@@ -738,7 +738,7 @@ export interface AgentManager {
      *
      * Unlike {@link AgentManager.chat | chat()} the agent's LLM is not involved, so this is how you
      * script greetings and canned lines. Pass a plain string as a shorthand for a text script. See
-     * {@link SupportedStreamScript}, {@link TextStreamScript} and {@link AudioStreamScript}. Text
+     * {@link SpeakScript}, {@link TextStreamScript} and {@link AudioStreamScript}. Text
      * scripts also accept an optional `sentiment`, for Expressive (V4) agents only; if the
      * requested sentiment is not supported by the agent, the default sentiment is used.
      *
@@ -747,8 +747,8 @@ export interface AgentManager {
      * @see [Control the Agent](https://docs.d-id.com/docs/livekit-commands) — the `did.speak` command
      * sent over the data channel for Expressive (V4) agents.
      * @param payload - A text or audio script, or a string treated as the text to speak.
-     * @returns The {@link SendStreamPayloadResponse} for the video that was produced, or the same
-     * response with `duration` `0` and an empty `video_id` when the call produced no discrete video
+     * @returns The {@link SpeakResponse} for the video that was produced, or the same
+     * response with `duration` `0` and an empty `videoId` when the call produced no discrete video
      * — on Expressive (V4) agents, and in a text-only chat mode.
      * @throws {@link ValidationError} When the manager is not connected to a stream yet.
      * @throws {@link HttpError} On Talks (V2) and Clips (V3) agents, when the Agents API answers
@@ -779,7 +779,7 @@ export interface AgentManager {
      * });
      * ```
      */
-    speak(payload: SupportedStreamScript | string): Promise<SendStreamPayloadResponse>;
+    speak(payload: SpeakScript | string): Promise<SpeakResponse>;
     /**
      * Switches the chat to another mode.
      *
@@ -804,6 +804,7 @@ export interface AgentManager {
      *
      * @param properties - A flat JSON object whose properties are added to every analytics event
      * the SDK sends from now on.
+     * @internal Used by D-ID's own embedded widget; not part of the public SDK surface.
      */
     enrichAnalytics(properties: Record<string, unknown>): void;
     /**
@@ -813,7 +814,7 @@ export interface AgentManager {
      * (V4) agent. It never throws: on every agent type it returns without doing anything when
      * interrupting is not available for the session, when it is not allowed right now, and — on
      * Talks (V2) and Clips (V3) agents — when the stream is not a fluent stream or no video is
-     * playing. Check {@link AgentManager.getIsInterruptAvailable | getIsInterruptAvailable()}
+     * playing. Check {@link AgentManager.isInterruptAvailable | isInterruptAvailable()}
      * before offering the control at all; on Expressive (V4) agents
      * {@link AgentManagerCallbacks.onInterruptibleChange | onInterruptibleChange} tracks whether it
      * is allowed right now.
@@ -823,11 +824,11 @@ export interface AgentManager {
      * actually sent. A call that finds nothing to interrupt leaves the message untouched and fires
      * no callback.
      *
-     * @param interrupt - What caused the interruption, as an {@link Interrupt}: `text`, `audio`,
-     * `click` or `manual`. Expressive (V4) agents drop `text` interrupts, because the orchestrator
-     * does not cancel the in-flight answer for them.
+     * @param options - What caused the interruption, as an {@link InterruptOptions}: `text`,
+     * `audio`, `click` or `manual`. Expressive (V4) agents drop `text` interrupts, because the
+     * orchestrator does not cancel the in-flight answer for them.
      */
-    interrupt(interrupt: Interrupt): void;
+    interrupt(options: InterruptOptions): void;
     /**
      * Switches the speech-to-text language in the middle of a session.
      *
@@ -850,7 +851,7 @@ export interface AgentManager {
      * to change slide. Expressive (V4) agents only, after {@link AgentManager.connect | connect()};
      * otherwise the returned promise rejects with a {@link ValidationError}.
      *
-     * @param topic - Data-channel topic to send on. {@link PublicDataChannelTopic} is exported from
+     * @param topic - Data-channel topic to send on. {@link DataChannelTopic} is exported from
      * the package root and lists every topic this method accepts.
      * @param payload - A plain object, sent as JSON.
      * @returns Resolves once the payload has been sent. A room that has dropped since
@@ -860,15 +861,15 @@ export interface AgentManager {
      * {@link AgentManager.connect | connect()} has not run yet.
      * @example
      * ```ts
-     * import { PublicDataChannelTopic } from '@d-id/client-sdk';
+     * import { DataChannelTopic } from '@d-id/client-sdk';
      *
-     * await agentManager.sendDataChannelMessage(PublicDataChannelTopic.Presentation, {
+     * await agentManager.sendDataChannelMessage(DataChannelTopic.Presentation, {
      *     type: 'navigate',
      *     slide: 3,
      * });
      * ```
      */
-    sendDataChannelMessage(topic: PublicDataChannelTopic, payload: Record<string, unknown>): Promise<void>;
+    sendDataChannelMessage(topic: DataChannelTopic, payload: Record<string, unknown>): Promise<void>;
     /**
      * Registers a handler for a client tool, run in the browser when the agent's LLM calls it.
      *

package/dist/src/types/stream/data-channel.d.ts

@@ -5,9 +5,9 @@
  * Internal on purpose: this module is deliberately left out of the `stream`
  * barrel so the topics driven by dedicated methods (`chat`, `speak`,
  * `interrupt`, `setSttLanguage`) never reach the package's public API.
- * Customers get `PublicDataChannelTopic` instead.
+ * Customers get the public `DataChannelTopic` enum instead.
  */
-export declare enum DataChannelTopic {
+export declare enum InternalDataChannelTopic {
     Chat = "lk.chat",
     Speak = "did.speak",
     Interrupt = "did.interrupt",

package/dist/src/types/stream/rtc.d.ts

@@ -79,14 +79,14 @@ export interface Status {
  *
  * The fields come from the Talks (V2) and Clips (V3) API, which generates a discrete video while
  * answering the request. Where no such video exists the call still resolves, with the same stub —
- * `status` `'success'`, `duration` `0` and an empty `video_id`: on Expressive (V4) agents, whose
+ * `status` `'success'`, `duration` `0` and an empty `videoId`: on Expressive (V4) agents, whose
  * speech is streamed over the data channel rather than rendered as a separate video, and in a
  * text-only chat mode ({@link ChatMode.TextOnly}, {@link ChatMode.Playground} or
  * {@link ChatMode.Maintenance}), which produces no video at all.
  *
  * @category Speak & Scripts
  */
-export interface SendStreamPayloadResponse {
+export interface SpeakResponse {
     /**
      * Whether the server accepted the speak request — `'success'` when it did.
      */
@@ -94,7 +94,7 @@ export interface SendStreamPayloadResponse {
     /**
      * Id of the session this call was made on; the SDK sends it back on later streaming requests.
      */
-    session_id?: string;
+    sessionId?: string;
     /**
      * Duration of the generated video as reported by the Agents API for Talks (V2) and Clips (V3)
      * agents. `0` when the call produced no discrete video — on Expressive (V4) agents, and in a
@@ -109,6 +109,17 @@ export interface SendStreamPayloadResponse {
      * end of, and which {@link AgentManager.interrupt | interrupt()} cancels. Empty when the call
      * produced no discrete video — on Expressive (V4) agents, and in a text-only chat mode.
      */
+    videoId: string;
+}
+/**
+ * What the Agents API answers a speak request with, converted to {@link SpeakResponse} before it
+ * reaches the application.
+ * @internal Wire type of the streaming transport; not part of the public SDK surface.
+ */
+export interface SpeakWireResponse {
+    status: string;
+    session_id?: string;
+    duration: number;
     video_id: string;
 }
 export {};

package/dist/src/types/stream/stream.d.ts

@@ -3,7 +3,7 @@ import { VideoRTCStatsReport } from '../../services/streaming-manager/stats/repo
 import { Auth } from '../auth';
 import { ChatProgressCallback } from '../entities/agents/manager';
 import { CreateClipStreamRequest, CreateTalkStreamRequest, SendClipStreamPayload, SendTalkStreamPayload } from './api';
-import { ICreateStreamRequestResponse, IceCandidate, SendStreamPayloadResponse, Status } from './rtc';
+import { ICreateStreamRequestResponse, IceCandidate, SpeakResponse, Status } from './rtc';
 
 /**
  * Which video codec the stream should negotiate.
@@ -83,14 +83,11 @@ export declare enum AgentActivityState {
     ToolActive = "TOOL_ACTIVE"
 }
 /**
- * The tool-call events delivered to
- * {@link AgentManagerCallbacks.onToolEvent | onToolEvent}.
+ * Every event the SDK receives on a stream's data channel or web socket.
  *
- * Switch on the first argument of the handler to tell them apart; it narrows the payload to
- * {@link ToolCallStartedPayload}, {@link ToolCallDonePayload} or {@link ToolCallErrorPayload} —
- * see {@link ToolEventCallback}. Expressive (V4) agents only.
- *
- * @category Callbacks & Events
+ * The three tool-call members are the only ones an application ever sees, and they reach it as
+ * {@link ToolCallEvent} instead; the rest are consumed by the SDK and surfaced as callbacks.
+ * @internal Implementation type; not part of the public SDK surface.
  */
 export declare enum StreamEvents {
     /**
@@ -192,6 +189,45 @@ export declare enum StreamEvents {
      */
     TurnEnded = "turn/ended"
 }
+/**
+ * The tool-call events delivered to {@link AgentManagerCallbacks.onToolEvent | onToolEvent}.
+ *
+ * Switch on the first argument of the handler to tell them apart: it narrows the second argument to
+ * the payload that event carries — see {@link ToolEventCallback}. The members' values are the wire
+ * strings the server sends, so compare against the enum rather than writing the string out.
+ * Expressive (V4) agents only.
+ *
+ * @example
+ * ```ts
+ * import { ToolCallEvent } from '@d-id/client-sdk';
+ *
+ * const callbacks = {
+ *     onToolEvent(event, data) {
+ *         if (event === ToolCallEvent.Started) {
+ *             console.log('started', data.name, data.input);
+ *         }
+ *     },
+ * };
+ * ```
+ * @category Callbacks & Events
+ */
+export declare enum ToolCallEvent {
+    /**
+     * The agent has begun a tool call; the payload is a {@link ToolCallStartedPayload}, carrying the
+     * call's id, the tool's name and the arguments the agent's LLM produced.
+     */
+    Started = "tool-call/started",
+    /**
+     * A tool call finished successfully; the payload is a {@link ToolCallDonePayload}, carrying the
+     * result the tool returned and how long the call took.
+     */
+    Done = "tool-call/done",
+    /**
+     * A tool call failed; the payload is a {@link ToolCallErrorPayload}, carrying whatever the
+     * server reported about the failure. The agent carries on with the conversation.
+     */
+    Error = "tool-call/error"
+}
 /**
  * The data-channel topics an application may send on with
  * {@link AgentManager.sendDataChannelMessage | sendDataChannelMessage()}.
@@ -207,16 +243,16 @@ export declare enum StreamEvents {
  *
  * @example
  * ```ts
- * import { PublicDataChannelTopic } from '@d-id/client-sdk';
+ * import { DataChannelTopic } from '@d-id/client-sdk';
  *
- * await agentManager.sendDataChannelMessage(PublicDataChannelTopic.Presentation, {
+ * await agentManager.sendDataChannelMessage(DataChannelTopic.Presentation, {
  *     type: 'navigate',
  *     slide: 3,
  * });
  * ```
  * @category Agent Manager
  */
-export declare enum PublicDataChannelTopic {
+export declare enum DataChannelTopic {
     /**
      * Messages that drive a presentation the agent is showing alongside its video, such as moving
      * to another slide. Sent on the wire as `did.presentation`; the payload shape is whatever the
@@ -316,16 +352,17 @@ export interface StreamCreatedInfo {
     /**
      * Id of the agent the stream was opened for.
      */
-    agent_id: string;
+    agentId: string;
     /**
      * Id of the session; the SDK sends it back on every subsequent request for this stream.
-     * On Expressive (V4) agents it is the same value as `stream_id`.
+     * On Expressive (V4) agents it is the same value as
+     * {@link StreamCreatedInfo.streamId | streamId}.
      */
-    session_id: string;
+    sessionId: string;
     /**
      * Id of the stream itself.
      */
-    stream_id: string;
+    streamId: string;
 }
 /**
  * Callback set consumed by the streaming managers (WebRTC and LiveKit).
@@ -406,7 +443,7 @@ export interface RtcApi {
     createStream(options: CreateStreamOptions, signal?: AbortSignal): Promise<ICreateStreamRequestResponse>;
     startConnection(streamId: string, answer: RTCSessionDescriptionInit, sessionId?: string, signal?: AbortSignal): Promise<Status>;
     addIceCandidate(streamId: string, candidate: IceCandidate, sessionId: string, signal?: AbortSignal): Promise<Status>;
-    sendStreamRequest(streamId: string, sessionId: string, payload: SendClipStreamPayload | SendTalkStreamPayload): Promise<SendStreamPayloadResponse>;
+    sendStreamRequest(streamId: string, sessionId: string, payload: SendClipStreamPayload | SendTalkStreamPayload): Promise<SpeakResponse>;
     close(streamId: string, sessionId: string): Promise<Status>;
 }
 /**
@@ -540,7 +577,7 @@ export type ClientToolHandler = (args: Record<string, unknown>) => Promise<strin
  * Whether the agent waits for a tool call to finish before it carries on.
  *
  * Set on the agent's tool configuration, and reported on {@link RunningToolCall.executionMode} and
- * {@link ToolCallStartedPayload.execution_mode}. Only a `blocking` call suspends the agent, which
+ * {@link ToolCallStartedPayload.executionMode}. Only a `blocking` call suspends the agent, which
  * is why one being outstanding is what makes the agent uninterruptible — see
  * {@link AgentManagerCallbacks.onInterruptibleChange | onInterruptibleChange}.
  *
@@ -555,14 +592,13 @@ export type ToolExecutionMode = 'blocking' | 'async';
  * when it starts and disappears when it finishes, fails, or — for a `blocking` call — when its turn
  * ends; an `async` call outlives its turn.
  *
- * The fields are camelCase because this is the SDK's own view of a call; the same call arrives in
- * {@link AgentManagerCallbacks.onToolEvent | onToolEvent} as a raw server payload, where the
- * equivalent fields are snake_case — `callId` here is `call_id` there.
- *
  * @category Callbacks & Events
  */
 export interface RunningToolCall {
-    /** Id of this call, matching the `call_id` of the {@link ToolCallStartedPayload} that announced it. */
+    /**
+     * Id of this call, matching the {@link ToolCallStartedPayload.callId | callId} of the
+     * {@link ToolCallStartedPayload} that announced it.
+     */
     callId: string;
     /** Name of the tool being called, as configured on the agent. */
     name: string;
@@ -575,7 +611,7 @@ export interface RunningToolCall {
     executionMode: ToolExecutionMode;
 }
 /**
- * The payload of a {@link StreamEvents.ToolCallStarted} event: the agent has begun a tool call.
+ * The payload of a {@link ToolCallEvent.Started} event: the agent has begun a tool call.
  *
  * Delivered to {@link AgentManagerCallbacks.onToolEvent | onToolEvent} — see
  * {@link ToolEventCallback}.
@@ -584,7 +620,7 @@ export interface RunningToolCall {
  */
 export interface ToolCallStartedPayload {
     /** Id of this call. The matching done or error payload carries the same id. */
-    call_id: string;
+    callId: string;
     /** Name of the tool the agent is calling, as configured on the agent. */
     name: string;
     /** The arguments the agent's LLM produced for this call. */
@@ -596,7 +632,7 @@ export interface ToolCallStartedPayload {
      *
      * Informational: the SDK does not forward it.
      * {@link AgentManagerCallbacks.onInterruptibleChange | onInterruptibleChange} is derived from
-     * the {@link ToolCallStartedPayload.execution_mode | execution_mode} of the calls still
+     * the {@link ToolCallStartedPayload.executionMode | executionMode} of the calls still
      * running, not from this field.
      */
     interruptible: boolean;
@@ -604,14 +640,14 @@ export interface ToolCallStartedPayload {
      * Whether the agent waits for this call. See {@link ToolExecutionMode}; anything other than
      * `async` is treated as `blocking`.
      */
-    execution_mode?: ToolExecutionMode;
+    executionMode?: ToolExecutionMode;
     /** The conversational turn this call belongs to, or `null` when it belongs to no turn. */
-    turn_id?: number | null;
+    turnId?: number | null;
     /** When the call started, as reported by the server. */
     timestamp: string;
 }
 /**
- * The payload of a {@link StreamEvents.ToolCallDone} event: a tool call finished successfully.
+ * The payload of a {@link ToolCallEvent.Done} event: a tool call finished successfully.
  *
  * Delivered to {@link AgentManagerCallbacks.onToolEvent | onToolEvent} — see
  * {@link ToolEventCallback}.
@@ -620,7 +656,7 @@ export interface ToolCallStartedPayload {
  */
 export interface ToolCallDonePayload {
     /** Id of the call that finished, matching the {@link ToolCallStartedPayload} that announced it. */
-    call_id: string;
+    callId: string;
     /** Name of the tool that was called. */
     name: string;
     /** The arguments the call was made with. */
@@ -628,14 +664,14 @@ export interface ToolCallDonePayload {
     /** The result the tool returned. */
     output: Record<string, unknown>;
     /** How long the call took, in milliseconds. */
-    duration_ms: number;
+    durationMs: number;
     /** Any additional metadata the tool reported alongside its result. */
     extra: Record<string, unknown>;
     /** When the call finished, as reported by the server. */
     timestamp: string;
 }
 /**
- * The payload of a {@link StreamEvents.ToolCallError} event: a tool call failed.
+ * The payload of a {@link ToolCallEvent.Error} event: a tool call failed.
  *
  * Delivered to {@link AgentManagerCallbacks.onToolEvent | onToolEvent} — see
  * {@link ToolEventCallback}. The agent carries on with the conversation; the SDK does not retry.
@@ -644,7 +680,7 @@ export interface ToolCallDonePayload {
  */
 export interface ToolCallErrorPayload {
     /** Id of the call that failed, matching the {@link ToolCallStartedPayload} that announced it. */
-    call_id: string;
+    callId: string;
     /** Name of the tool that was called. */
     name: string;
     /** The arguments the call was made with. */
@@ -652,7 +688,7 @@ export interface ToolCallErrorPayload {
     /** Whatever the failed call produced, if anything. */
     output: Record<string, unknown>;
     /** How long the call ran before failing, in milliseconds. */
-    duration_ms: number;
+    durationMs: number;
     /** Any additional metadata the server reported with the failure. */
     extra: Record<string, unknown>;
     /** When the call failed, as reported by the server. */
@@ -663,6 +699,41 @@ export interface ToolCallErrorPayload {
  * @internal Implementation type; not part of the public SDK surface.
  */
 export type ToolEventPayload = ToolCallStartedPayload | ToolCallDonePayload | ToolCallErrorPayload;
+/**
+ * Data-channel wire shape of a `tool-call/started` event, converted to
+ * {@link ToolCallStartedPayload} before it reaches the application.
+ * @internal Wire type of the streaming transport; not part of the public SDK surface.
+ */
+export interface ToolCallStartedWirePayload {
+    call_id: string;
+    name: string;
+    input: Record<string, unknown>;
+    output: Record<string, unknown>;
+    interruptible?: boolean;
+    execution_mode?: ToolExecutionMode;
+    turn_id?: number | null;
+    timestamp: string;
+}
+/**
+ * Data-channel wire shape of a `tool-call/done` event, converted to {@link ToolCallDonePayload}
+ * before it reaches the application.
+ * @internal Wire type of the streaming transport; not part of the public SDK surface.
+ */
+export interface ToolCallDoneWirePayload {
+    call_id: string;
+    name: string;
+    input: Record<string, unknown>;
+    output: Record<string, unknown>;
+    duration_ms: number;
+    extra: Record<string, unknown>;
+    timestamp: string;
+}
+/**
+ * Data-channel wire shape of a `tool-call/error` event, converted to {@link ToolCallErrorPayload}
+ * before it reaches the application.
+ * @internal Wire type of the streaming transport; not part of the public SDK surface.
+ */
+export type ToolCallErrorWirePayload = ToolCallDoneWirePayload;
 /**
  * Data-channel payload identifying the conversational turn a `turn/started` or `turn/ended` event belongs to.
  * @internal Implementation type; not part of the public SDK surface.
@@ -750,14 +821,14 @@ export declare enum StreamEndReason {
  *
  * @example
  * ```ts
- * import { StreamEvents } from '@d-id/client-sdk';
+ * import { ToolCallEvent } from '@d-id/client-sdk';
  *
  * const callbacks = {
  *     onToolEvent(event, data) {
- *         if (event === StreamEvents.ToolCallStarted) {
+ *         if (event === ToolCallEvent.Started) {
  *             console.log('started', data.name, data.input);
- *         } else if (event === StreamEvents.ToolCallDone) {
- *             console.log('done', data.name, data.output, data.duration_ms);
+ *         } else if (event === ToolCallEvent.Done) {
+ *             console.log('done', data.name, data.output, data.durationMs);
  *         } else {
  *             console.log('failed', data.name, data.extra);
  *         }
@@ -768,18 +839,18 @@ export declare enum StreamEndReason {
  */
 export type ToolEventCallback = {
     /**
-     * @param event - Always {@link StreamEvents.ToolCallStarted} in this overload.
+     * @param event - Always {@link ToolCallEvent.Started} in this overload.
      * @param data - The call the agent has just begun, with the arguments its LLM produced.
      */
-    (event: StreamEvents.ToolCallStarted, data: ToolCallStartedPayload): void;
+    (event: ToolCallEvent.Started, data: ToolCallStartedPayload): void;
     /**
-     * @param event - Always {@link StreamEvents.ToolCallDone} in this overload.
+     * @param event - Always {@link ToolCallEvent.Done} in this overload.
      * @param data - The call that has just finished, with the result the tool returned.
      */
-    (event: StreamEvents.ToolCallDone, data: ToolCallDonePayload): void;
+    (event: ToolCallEvent.Done, data: ToolCallDonePayload): void;
     /**
-     * @param event - Always {@link StreamEvents.ToolCallError} in this overload.
+     * @param event - Always {@link ToolCallEvent.Error} in this overload.
      * @param data - The call that has just failed, with whatever the server reported about it.
      */
-    (event: StreamEvents.ToolCallError, data: ToolCallErrorPayload): void;
+    (event: ToolCallEvent.Error, data: ToolCallErrorPayload): void;
 };

package/dist/src/types/stream-script.d.ts

@@ -1,5 +1,5 @@
 import { Message } from './entities';
-import { StreamTextToSpeechProviders } from './voice/tts';
+import { TtsProvider } from './voice/tts';
 
 /**
  * A script that makes the agent say text you supply, synthesised by a text-to-speech provider.
@@ -38,12 +38,12 @@ export interface TextStreamScript {
      * The text-to-speech provider and voice that synthesise
      * {@link TextStreamScript.input | input}, from the list of supported providers.
      *
-     * One of the objects in {@link StreamTextToSpeechProviders}: a `type` naming the provider, the
+     * One of the objects in {@link TtsProvider}: a `type` naming the provider, the
      * `voice_id` to speak with, and optional provider-specific `voice_config`. Leave it out and the
      * SDK sends the script without a provider, so the voice is chosen server-side; the Agents API
      * documents Microsoft TTS as its default when no provider is given.
      */
-    provider?: StreamTextToSpeechProviders;
+    provider?: TtsProvider;
     /**
      * The text to be synthesised into speech.
      *
@@ -111,7 +111,7 @@ export interface AudioStreamScript {
  */
 export interface LlmStreamScript {
     type: 'llm';
-    provider: StreamTextToSpeechProviders;
+    provider: TtsProvider;
     ssml?: boolean;
     llm: {
         messages: Message[];
@@ -135,4 +135,4 @@ export type StreamScript = TextStreamScript | AudioStreamScript | LlmStreamScrip
  *
  * @category Speak & Scripts
  */
-export type SupportedStreamScript = TextStreamScript | AudioStreamScript;
+export type SpeakScript = TextStreamScript | AudioStreamScript;

package/dist/src/types/voice/stt.d.ts

@@ -1,14 +1,14 @@
 /**
  * A short-lived credential for the D-ID speech-to-text service.
  *
- * What {@link AgentManager.getSTTToken | getSTTToken()} resolves with, fetched fresh from the
+ * What {@link AgentManager.getSttToken | getSttToken()} resolves with, fetched fresh from the
  * Agents API each time. It lets an application drive its own speech recognition against the
  * service the agent uses without putting D-ID credentials in the browser. The token expires, so request one per recognition session
  * rather than holding on to it.
  *
  * @category Agent Manager
  */
-export interface STTTokenResponse {
+export interface SttTokenResponse {
     /** The authorization token to present to the speech service. */
     token: string;
     /** The speech service region the token is valid in. */

package/dist/src/types/voice/tts.d.ts

@@ -235,4 +235,4 @@ export interface VoiceConfigElevenlabs {
  * ```
  * @category Voice
  */
-export type StreamTextToSpeechProviders = MicrosoftTtsProvider | AzureOpenAiTtsProvider | ElevenlabsTtsProvider | AmazonTtsProvider;
+export type TtsProvider = MicrosoftTtsProvider | AzureOpenAiTtsProvider | ElevenlabsTtsProvider | AmazonTtsProvider;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@d-id/client-sdk",
   "private": false,
-  "version": "3.0.0-staging.413",
+  "version": "3.0.0-staging.414",
   "type": "module",
   "description": "d-id client sdk",
   "repository": {