@livekit/protocol 1.52.1 → 1.53.1

package/dist/index.d.ts

@@ -133,6 +133,46 @@ declare enum ToolReplyStatus {
   TR_SKIPPED = 3,
 }
 
+/**
+ * Why an agent session closed. Agent evals read it from the recording upload's session
+ * summary (MetricsRecordingHeader.session_summary), as the value name.
+ *
+ * @generated from enum livekit.agent.CloseReason
+ */
+declare enum CloseReason {
+  /**
+   * not reported, or an SDK-specific reason
+   *
+   * @generated from enum value: CR_UNKNOWN = 0;
+   */
+  CR_UNKNOWN = 0,
+
+  /**
+   * @generated from enum value: CR_ERROR = 1;
+   */
+  CR_ERROR = 1,
+
+  /**
+   * @generated from enum value: CR_JOB_SHUTDOWN = 2;
+   */
+  CR_JOB_SHUTDOWN = 2,
+
+  /**
+   * @generated from enum value: CR_PARTICIPANT_DISCONNECTED = 3;
+   */
+  CR_PARTICIPANT_DISCONNECTED = 3,
+
+  /**
+   * @generated from enum value: CR_USER_INITIATED = 4;
+   */
+  CR_USER_INITIATED = 4,
+
+  /**
+   * @generated from enum value: CR_COMPLETED = 5;
+   */
+  CR_COMPLETED = 5,
+}
+
 /**
  * @generated from enum livekit.agent.AmdCategory
  */
@@ -404,6 +444,15 @@ declare class FunctionCall extends Message<FunctionCall> {
    */
   createdAt?: Timestamp;
 
+  /**
+   * Framework metadata recorded on the call, kept with the history. A delegating call records
+   * where the request went: lk.delegation.task_id, lk.delegation.endpoint,
+   * lk.delegation.transport and lk.delegation.profile.
+   *
+   * @generated from field: map<string, string> extra = 6;
+   */
+  extra: { [key: string]: string };
+
   constructor(data?: PartialMessage<FunctionCall>);
 
   static readonly runtime: typeof proto3;
@@ -2684,6 +2733,8 @@ type livekit_agent_session_pb_d_ChatMessage_ChatContent = ChatMessage_ChatConten
 declare const livekit_agent_session_pb_d_ChatMessage_ChatContent: typeof ChatMessage_ChatContent;
 type livekit_agent_session_pb_d_ChatRole = ChatRole;
 declare const livekit_agent_session_pb_d_ChatRole: typeof ChatRole;
+type livekit_agent_session_pb_d_CloseReason = CloseReason;
+declare const livekit_agent_session_pb_d_CloseReason: typeof CloseReason;
 type livekit_agent_session_pb_d_DebugMessage = DebugMessage;
 declare const livekit_agent_session_pb_d_DebugMessage: typeof DebugMessage;
 type livekit_agent_session_pb_d_EotModelUsage = EotModelUsage;
@@ -2798,6 +2849,7 @@ declare namespace livekit_agent_session_pb_d {
     ChatMessage$1 as ChatMessage,
     livekit_agent_session_pb_d_ChatMessage_ChatContent as ChatMessage_ChatContent,
     livekit_agent_session_pb_d_ChatRole as ChatRole,
+    livekit_agent_session_pb_d_CloseReason as CloseReason,
     livekit_agent_session_pb_d_DebugMessage as DebugMessage,
     livekit_agent_session_pb_d_EotModelUsage as EotModelUsage,
     livekit_agent_session_pb_d_FunctionCall as FunctionCall,
@@ -2857,341 +2909,1040 @@ declare namespace livekit_agent_session_pb_d {
 
 
 /**
- * @generated from enum livekit.agent.AudioEncoding
+ * @generated from message livekit.agent.AgentThread
  */
-declare enum AudioEncoding {
-  /**
-   * @generated from enum value: AUDIO_ENCODING_PCM_S16LE = 0;
-   */
-  PCM_S16LE = 0,
+declare class AgentThread extends Message<AgentThread> {
+  constructor(data?: PartialMessage<AgentThread>);
 
-  /**
-   * @generated from enum value: AUDIO_ENCODING_OPUS = 1;
-   */
-  OPUS = 1,
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.agent.AgentThread";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentThread;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentThread;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentThread;
+
+  static equals(a: AgentThread | PlainMessage<AgentThread> | undefined, b: AgentThread | PlainMessage<AgentThread> | undefined): boolean;
 }
 
 /**
- * @generated from message livekit.agent.SessionSettings
+ * Direction of a listing. Each request documents what unset means.
+ *
+ * @generated from enum livekit.agent.AgentThread.SortOrder
  */
-declare class SessionSettings extends Message<SessionSettings> {
+declare enum AgentThread_SortOrder {
   /**
-   * @generated from field: uint32 sample_rate = 1;
+   * @generated from enum value: SORT_ORDER_UNSPECIFIED = 0;
    */
-  sampleRate: number;
+  UNSPECIFIED = 0,
 
   /**
-   * @generated from field: livekit.agent.AudioEncoding encoding = 2;
+   * @generated from enum value: SORT_ORDER_ASC = 1;
    */
-  encoding: AudioEncoding;
+  ASC = 1,
 
   /**
-   * @generated from oneof livekit.agent.SessionSettings.type_settings
+   * @generated from enum value: SORT_ORDER_DESC = 2;
    */
-  typeSettings: {
-    /**
-     * @generated from field: livekit.agent.EotSettings eot_settings = 3;
-     */
-    value: EotSettings;
-    case: "eotSettings";
-  } | {
-    /**
-     * @generated from field: livekit.agent.InterruptionSettings interruption_settings = 4;
-     */
-    value: InterruptionSettings;
-    case: "interruptionSettings";
-  } | { case: undefined; value?: undefined };
-
-  constructor(data?: PartialMessage<SessionSettings>);
-
-  static readonly runtime: typeof proto3;
-  static readonly typeName = "livekit.agent.SessionSettings";
-  static readonly fields: FieldList;
-
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SessionSettings;
-
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SessionSettings;
-
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SessionSettings;
-
-  static equals(a: SessionSettings | PlainMessage<SessionSettings> | undefined, b: SessionSettings | PlainMessage<SessionSettings> | undefined): boolean;
+  DESC = 2,
 }
 
 /**
- * @generated from message livekit.agent.InferenceError
+ * @generated from message livekit.agent.AgentThread.CreateRequest
  */
-declare class InferenceError extends Message<InferenceError> {
+declare class AgentThread_CreateRequest extends Message<AgentThread_CreateRequest> {
   /**
-   * @generated from field: string message = 1;
+   * Groups threads, e.g. by user: an application-defined value, typically the
+   * user's identity. An AgentThreadGrant is scoped by it.
+   *
+   * @generated from field: string scope = 1;
    */
-  message: string;
+  scope: string;
 
   /**
-   * error code follows the HTTP status code convention
-   * 4xx for client errors
-   * 5xx for server errors
+   * @generated from field: map<string, string> attributes = 2;
+   */
+  attributes: { [key: string]: string };
+
+  /**
+   * Unset takes the server default.
    *
-   * @generated from field: uint32 code = 2;
+   * @generated from field: google.protobuf.Duration idle_ttl = 3;
    */
-  code: number;
+  idleTtl?: Duration;
 
-  constructor(data?: PartialMessage<InferenceError>);
+  constructor(data?: PartialMessage<AgentThread_CreateRequest>);
 
   static readonly runtime: typeof proto3;
-  static readonly typeName = "livekit.agent.InferenceError";
+  static readonly typeName = "livekit.agent.AgentThread.CreateRequest";
   static readonly fields: FieldList;
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InferenceError;
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentThread_CreateRequest;
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InferenceError;
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentThread_CreateRequest;
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InferenceError;
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentThread_CreateRequest;
 
-  static equals(a: InferenceError | PlainMessage<InferenceError> | undefined, b: InferenceError | PlainMessage<InferenceError> | undefined): boolean;
+  static equals(a: AgentThread_CreateRequest | PlainMessage<AgentThread_CreateRequest> | undefined, b: AgentThread_CreateRequest | PlainMessage<AgentThread_CreateRequest> | undefined): boolean;
 }
 
 /**
- * @generated from message livekit.agent.EotSettings
+ * @generated from message livekit.agent.AgentThread.GetRequest
  */
-declare class EotSettings extends Message<EotSettings> {
+declare class AgentThread_GetRequest extends Message<AgentThread_GetRequest> {
   /**
-   * @generated from field: google.protobuf.Duration detection_interval = 1;
+   * @generated from field: string thread_id = 1;
    */
-  detectionInterval?: Duration;
+  threadId: string;
 
-  constructor(data?: PartialMessage<EotSettings>);
+  constructor(data?: PartialMessage<AgentThread_GetRequest>);
 
   static readonly runtime: typeof proto3;
-  static readonly typeName = "livekit.agent.EotSettings";
+  static readonly typeName = "livekit.agent.AgentThread.GetRequest";
   static readonly fields: FieldList;
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EotSettings;
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentThread_GetRequest;
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EotSettings;
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentThread_GetRequest;
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EotSettings;
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentThread_GetRequest;
 
-  static equals(a: EotSettings | PlainMessage<EotSettings> | undefined, b: EotSettings | PlainMessage<EotSettings> | undefined): boolean;
+  static equals(a: AgentThread_GetRequest | PlainMessage<AgentThread_GetRequest> | undefined, b: AgentThread_GetRequest | PlainMessage<AgentThread_GetRequest> | undefined): boolean;
 }
 
 /**
- * @generated from message livekit.agent.InterruptionSettings
+ * The threads of one scope, newest first.
+ *
+ * @generated from message livekit.agent.AgentThread.ListRequest
  */
-declare class InterruptionSettings extends Message<InterruptionSettings> {
+declare class AgentThread_ListRequest extends Message<AgentThread_ListRequest> {
   /**
-   * detection threshold in range [0.0, 1.0]; higher values are less sensitive
-   *
-   * @generated from field: float threshold = 1;
+   * @generated from field: string scope = 1;
    */
-  threshold: number;
+  scope: string;
 
   /**
-   * minimum number of frames with probability greater than threshold to trigger an interruption
+   * next_page_token of the previous ListResponse; empty for the first page.
    *
-   * @generated from field: uint32 min_frames = 2;
-   */
-  minFrames: number;
-
-  /**
-   * @generated from field: google.protobuf.Duration max_audio_duration = 3;
-   */
-  maxAudioDuration?: Duration;
-
-  /**
-   * @generated from field: google.protobuf.Duration audio_prefix_duration = 4;
+   * @generated from field: string page_token = 2;
    */
-  audioPrefixDuration?: Duration;
+  pageToken: string;
 
   /**
-   * @generated from field: google.protobuf.Duration detection_interval = 5;
+   * @generated from field: int32 limit = 3;
    */
-  detectionInterval?: Duration;
+  limit: number;
 
-  constructor(data?: PartialMessage<InterruptionSettings>);
+  constructor(data?: PartialMessage<AgentThread_ListRequest>);
 
   static readonly runtime: typeof proto3;
-  static readonly typeName = "livekit.agent.InterruptionSettings";
+  static readonly typeName = "livekit.agent.AgentThread.ListRequest";
   static readonly fields: FieldList;
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InterruptionSettings;
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentThread_ListRequest;
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InterruptionSettings;
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentThread_ListRequest;
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InterruptionSettings;
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentThread_ListRequest;
 
-  static equals(a: InterruptionSettings | PlainMessage<InterruptionSettings> | undefined, b: InterruptionSettings | PlainMessage<InterruptionSettings> | undefined): boolean;
+  static equals(a: AgentThread_ListRequest | PlainMessage<AgentThread_ListRequest> | undefined, b: AgentThread_ListRequest | PlainMessage<AgentThread_ListRequest> | undefined): boolean;
 }
 
 /**
- * @generated from message livekit.agent.SessionCreate
+ * @generated from message livekit.agent.AgentThread.ListResponse
  */
-declare class SessionCreate extends Message<SessionCreate> {
+declare class AgentThread_ListResponse extends Message<AgentThread_ListResponse> {
   /**
-   * @generated from field: livekit.agent.SessionSettings settings = 1;
+   * @generated from field: repeated livekit.agent.AgentThread.Thread threads = 1;
    */
-  settings?: SessionSettings;
+  threads: AgentThread_Thread[];
 
-  constructor(data?: PartialMessage<SessionCreate>);
+  /**
+   * Empty when exhausted.
+   *
+   * @generated from field: string next_page_token = 2;
+   */
+  nextPageToken: string;
+
+  constructor(data?: PartialMessage<AgentThread_ListResponse>);
 
   static readonly runtime: typeof proto3;
-  static readonly typeName = "livekit.agent.SessionCreate";
+  static readonly typeName = "livekit.agent.AgentThread.ListResponse";
   static readonly fields: FieldList;
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SessionCreate;
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentThread_ListResponse;
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SessionCreate;
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentThread_ListResponse;
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SessionCreate;
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentThread_ListResponse;
 
-  static equals(a: SessionCreate | PlainMessage<SessionCreate> | undefined, b: SessionCreate | PlainMessage<SessionCreate> | undefined): boolean;
+  static equals(a: AgentThread_ListResponse | PlainMessage<AgentThread_ListResponse> | undefined, b: AgentThread_ListResponse | PlainMessage<AgentThread_ListResponse> | undefined): boolean;
 }
 
 /**
- * @generated from message livekit.agent.InputAudio
+ * @generated from message livekit.agent.AgentThread.UpdateRequest
  */
-declare class InputAudio extends Message<InputAudio> {
+declare class AgentThread_UpdateRequest extends Message<AgentThread_UpdateRequest> {
   /**
-   * @generated from field: bytes audio = 1;
+   * @generated from field: string thread_id = 1;
    */
-  audio: Uint8Array;
+  threadId: string;
 
   /**
-   * @generated from field: google.protobuf.Timestamp created_at = 2;
+   * Added to the existing attributes; an empty value deletes the entry.
+   *
+   * @generated from field: map<string, string> attributes = 2;
    */
-  createdAt?: Timestamp;
+  attributes: { [key: string]: string };
 
   /**
-   * @generated from field: uint32 num_samples = 3;
+   * Every update counts as activity and pushes expires_at out by idle_ttl.
+   *
+   * @generated from field: google.protobuf.Duration idle_ttl = 3;
    */
-  numSamples: number;
+  idleTtl?: Duration;
 
-  constructor(data?: PartialMessage<InputAudio>);
+  constructor(data?: PartialMessage<AgentThread_UpdateRequest>);
 
   static readonly runtime: typeof proto3;
-  static readonly typeName = "livekit.agent.InputAudio";
+  static readonly typeName = "livekit.agent.AgentThread.UpdateRequest";
   static readonly fields: FieldList;
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InputAudio;
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentThread_UpdateRequest;
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InputAudio;
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentThread_UpdateRequest;
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InputAudio;
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentThread_UpdateRequest;
 
-  static equals(a: InputAudio | PlainMessage<InputAudio> | undefined, b: InputAudio | PlainMessage<InputAudio> | undefined): boolean;
+  static equals(a: AgentThread_UpdateRequest | PlainMessage<AgentThread_UpdateRequest> | undefined, b: AgentThread_UpdateRequest | PlainMessage<AgentThread_UpdateRequest> | undefined): boolean;
 }
 
 /**
- * @generated from message livekit.agent.EotInputChatContext
+ * @generated from message livekit.agent.AgentThread.DeleteRequest
  */
-declare class EotInputChatContext extends Message<EotInputChatContext> {
+declare class AgentThread_DeleteRequest extends Message<AgentThread_DeleteRequest> {
   /**
-   * @generated from field: repeated livekit.agent.ChatMessage messages = 1;
+   * @generated from field: string thread_id = 1;
    */
-  messages: ChatMessage$1[];
+  threadId: string;
 
-  constructor(data?: PartialMessage<EotInputChatContext>);
+  constructor(data?: PartialMessage<AgentThread_DeleteRequest>);
 
   static readonly runtime: typeof proto3;
-  static readonly typeName = "livekit.agent.EotInputChatContext";
+  static readonly typeName = "livekit.agent.AgentThread.DeleteRequest";
   static readonly fields: FieldList;
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EotInputChatContext;
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentThread_DeleteRequest;
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EotInputChatContext;
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentThread_DeleteRequest;
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EotInputChatContext;
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentThread_DeleteRequest;
 
-  static equals(a: EotInputChatContext | PlainMessage<EotInputChatContext> | undefined, b: EotInputChatContext | PlainMessage<EotInputChatContext> | undefined): boolean;
+  static equals(a: AgentThread_DeleteRequest | PlainMessage<AgentThread_DeleteRequest> | undefined, b: AgentThread_DeleteRequest | PlainMessage<AgentThread_DeleteRequest> | undefined): boolean;
 }
 
 /**
- * @generated from message livekit.agent.SessionFlush
+ * @generated from message livekit.agent.AgentThread.DeleteResponse
  */
-declare class SessionFlush extends Message<SessionFlush> {
-  constructor(data?: PartialMessage<SessionFlush>);
+declare class AgentThread_DeleteResponse extends Message<AgentThread_DeleteResponse> {
+  constructor(data?: PartialMessage<AgentThread_DeleteResponse>);
 
   static readonly runtime: typeof proto3;
-  static readonly typeName = "livekit.agent.SessionFlush";
+  static readonly typeName = "livekit.agent.AgentThread.DeleteResponse";
   static readonly fields: FieldList;
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SessionFlush;
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentThread_DeleteResponse;
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SessionFlush;
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentThread_DeleteResponse;
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SessionFlush;
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentThread_DeleteResponse;
 
-  static equals(a: SessionFlush | PlainMessage<SessionFlush> | undefined, b: SessionFlush | PlainMessage<SessionFlush> | undefined): boolean;
+  static equals(a: AgentThread_DeleteResponse | PlainMessage<AgentThread_DeleteResponse> | undefined, b: AgentThread_DeleteResponse | PlainMessage<AgentThread_DeleteResponse> | undefined): boolean;
 }
 
 /**
- * @generated from message livekit.agent.SessionClose
+ * The thread's chat items, oldest first unless sort_order says otherwise.
+ *
+ * @generated from message livekit.agent.AgentThread.GetItemsRequest
  */
-declare class SessionClose extends Message<SessionClose> {
-  constructor(data?: PartialMessage<SessionClose>);
+declare class AgentThread_GetItemsRequest extends Message<AgentThread_GetItemsRequest> {
+  /**
+   * @generated from field: string thread_id = 1;
+   */
+  threadId: string;
+
+  /**
+   * One agent's items; empty for every agent's.
+   *
+   * @generated from field: string agent = 2;
+   */
+  agent: string;
+
+  /**
+   * next_page_token of the previous GetItemsResponse; empty for the first page.
+   *
+   * @generated from field: string page_token = 3;
+   */
+  pageToken: string;
+
+  /**
+   * @generated from field: int32 limit = 4;
+   */
+  limit: number;
+
+  /**
+   * Unset or ASC is oldest first. DESC starts from the latest item and each
+   * next_page_token walks back through older ones.
+   *
+   * @generated from field: livekit.agent.AgentThread.SortOrder sort_order = 5;
+   */
+  sortOrder: AgentThread_SortOrder;
+
+  constructor(data?: PartialMessage<AgentThread_GetItemsRequest>);
 
   static readonly runtime: typeof proto3;
-  static readonly typeName = "livekit.agent.SessionClose";
+  static readonly typeName = "livekit.agent.AgentThread.GetItemsRequest";
   static readonly fields: FieldList;
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SessionClose;
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentThread_GetItemsRequest;
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SessionClose;
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentThread_GetItemsRequest;
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SessionClose;
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentThread_GetItemsRequest;
 
-  static equals(a: SessionClose | PlainMessage<SessionClose> | undefined, b: SessionClose | PlainMessage<SessionClose> | undefined): boolean;
+  static equals(a: AgentThread_GetItemsRequest | PlainMessage<AgentThread_GetItemsRequest> | undefined, b: AgentThread_GetItemsRequest | PlainMessage<AgentThread_GetItemsRequest> | undefined): boolean;
 }
 
 /**
- * @generated from message livekit.agent.InferenceStart
+ * @generated from message livekit.agent.AgentThread.GetItemsResponse
  */
-declare class InferenceStart extends Message<InferenceStart> {
+declare class AgentThread_GetItemsResponse extends Message<AgentThread_GetItemsResponse> {
   /**
-   * @generated from field: string request_id = 1;
+   * @generated from field: repeated livekit.agent.AgentThread.Item items = 1;
    */
-  requestId: string;
+  items: AgentThread_Item[];
 
-  constructor(data?: PartialMessage<InferenceStart>);
+  /**
+   * Empty when exhausted.
+   *
+   * @generated from field: string next_page_token = 2;
+   */
+  nextPageToken: string;
+
+  constructor(data?: PartialMessage<AgentThread_GetItemsResponse>);
 
   static readonly runtime: typeof proto3;
-  static readonly typeName = "livekit.agent.InferenceStart";
+  static readonly typeName = "livekit.agent.AgentThread.GetItemsResponse";
   static readonly fields: FieldList;
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InferenceStart;
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentThread_GetItemsResponse;
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InferenceStart;
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentThread_GetItemsResponse;
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InferenceStart;
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentThread_GetItemsResponse;
 
-  static equals(a: InferenceStart | PlainMessage<InferenceStart> | undefined, b: InferenceStart | PlainMessage<InferenceStart> | undefined): boolean;
+  static equals(a: AgentThread_GetItemsResponse | PlainMessage<AgentThread_GetItemsResponse> | undefined, b: AgentThread_GetItemsResponse | PlainMessage<AgentThread_GetItemsResponse> | undefined): boolean;
 }
 
 /**
- * @generated from message livekit.agent.InferenceStop
+ * One chat item of an agent. Stored as the JSON of
+ * ChatContext.ChatItem (items.payload in thread_schema_v1.sql).
+ *
+ * @generated from message livekit.agent.AgentThread.Item
  */
-declare class InferenceStop extends Message<InferenceStop> {
+declare class AgentThread_Item extends Message<AgentThread_Item> {
   /**
-   * @generated from field: string request_id = 1;
+   * @generated from field: string agent = 1;
    */
-  requestId: string;
+  agent: string;
 
-  constructor(data?: PartialMessage<InferenceStop>);
+  /**
+   * Position in the agent's history.
+   *
+   * @generated from field: int64 seq = 2;
+   */
+  seq: bigint;
+
+  /**
+   * The A2A message the item came from.
+   *
+   * @generated from field: string message_id = 3;
+   */
+  messageId: string;
+
+  /**
+   * @generated from field: livekit.agent.ChatContext.ChatItem item = 4;
+   */
+  item?: ChatContext_ChatItem;
+
+  constructor(data?: PartialMessage<AgentThread_Item>);
 
   static readonly runtime: typeof proto3;
-  static readonly typeName = "livekit.agent.InferenceStop";
+  static readonly typeName = "livekit.agent.AgentThread.Item";
   static readonly fields: FieldList;
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InferenceStop;
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentThread_Item;
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InferenceStop;
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentThread_Item;
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InferenceStop;
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentThread_Item;
 
-  static equals(a: InferenceStop | PlainMessage<InferenceStop> | undefined, b: InferenceStop | PlainMessage<InferenceStop> | undefined): boolean;
+  static equals(a: AgentThread_Item | PlainMessage<AgentThread_Item> | undefined, b: AgentThread_Item | PlainMessage<AgentThread_Item> | undefined): boolean;
 }
 
 /**
- * audio buffer sentinel messages
+ * @generated from message livekit.agent.AgentThread.Thread
+ */
+declare class AgentThread_Thread extends Message<AgentThread_Thread> {
+  /**
+   * @generated from field: string thread_id = 1;
+   */
+  threadId: string;
+
+  /**
+   * @generated from field: string scope = 2;
+   */
+  scope: string;
+
+  /**
+   * @generated from field: map<string, string> attributes = 3;
+   */
+  attributes: { [key: string]: string };
+
+  /**
+   * @generated from field: google.protobuf.Timestamp created_at = 4;
+   */
+  createdAt?: Timestamp;
+
+  /**
+   * @generated from field: google.protobuf.Timestamp last_active = 5;
+   */
+  lastActive?: Timestamp;
+
+  /**
+   * last_active + idle_ttl; every update pushes it out. The thread and its
+   * database are deleted once it passes.
+   *
+   * @generated from field: google.protobuf.Timestamp expires_at = 6;
+   */
+  expiresAt?: Timestamp;
+
+  /**
+   * @generated from field: google.protobuf.Duration idle_ttl = 7;
+   */
+  idleTtl?: Duration;
+
+  /**
+   * The thread's database ("DB_..."), created with the thread.
+   *
+   * @generated from field: string database_id = 8;
+   */
+  databaseId: string;
+
+  constructor(data?: PartialMessage<AgentThread_Thread>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.agent.AgentThread.Thread";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentThread_Thread;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentThread_Thread;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentThread_Thread;
+
+  static equals(a: AgentThread_Thread | PlainMessage<AgentThread_Thread> | undefined, b: AgentThread_Thread | PlainMessage<AgentThread_Thread> | undefined): boolean;
+}
+
+/**
+ * AgentTask: background work an agent runs within a thread, such as a booking
+ * that takes minutes.
+ *
+ * @generated from message livekit.agent.AgentTask
+ */
+declare class AgentTask extends Message<AgentTask> {
+  constructor(data?: PartialMessage<AgentTask>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.agent.AgentTask";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentTask;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentTask;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentTask;
+
+  static equals(a: AgentTask | PlainMessage<AgentTask> | undefined, b: AgentTask | PlainMessage<AgentTask> | undefined): boolean;
+}
+
+/**
+ * A task is never UNSPECIFIED.
+ *
+ * @generated from enum livekit.agent.AgentTask.Status
+ */
+declare enum AgentTask_Status {
+  /**
+   * @generated from enum value: UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * @generated from enum value: RUNNING = 1;
+   */
+  RUNNING = 1,
+
+  /**
+   * @generated from enum value: COMPLETED = 2;
+   */
+  COMPLETED = 2,
+
+  /**
+   * @generated from enum value: FAILED = 3;
+   */
+  FAILED = 3,
+
+  /**
+   * @generated from enum value: CANCELED = 4;
+   */
+  CANCELED = 4,
+}
+
+/**
+ * A thread's tasks, oldest first.
+ *
+ * @generated from message livekit.agent.AgentTask.GetTasksRequest
+ */
+declare class AgentTask_GetTasksRequest extends Message<AgentTask_GetTasksRequest> {
+  /**
+   * @generated from field: string thread_id = 1;
+   */
+  threadId: string;
+
+  /**
+   * Unset for every status.
+   *
+   * @generated from field: optional livekit.agent.AgentTask.Status status = 2;
+   */
+  status?: AgentTask_Status;
+
+  /**
+   * next_page_token of the previous GetTasksResponse; empty for the first page.
+   *
+   * @generated from field: string page_token = 3;
+   */
+  pageToken: string;
+
+  /**
+   * @generated from field: int32 limit = 4;
+   */
+  limit: number;
+
+  constructor(data?: PartialMessage<AgentTask_GetTasksRequest>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.agent.AgentTask.GetTasksRequest";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentTask_GetTasksRequest;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentTask_GetTasksRequest;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentTask_GetTasksRequest;
+
+  static equals(a: AgentTask_GetTasksRequest | PlainMessage<AgentTask_GetTasksRequest> | undefined, b: AgentTask_GetTasksRequest | PlainMessage<AgentTask_GetTasksRequest> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.agent.AgentTask.GetTasksResponse
+ */
+declare class AgentTask_GetTasksResponse extends Message<AgentTask_GetTasksResponse> {
+  /**
+   * @generated from field: repeated livekit.agent.AgentTask.Task tasks = 1;
+   */
+  tasks: AgentTask_Task[];
+
+  /**
+   * Empty when exhausted.
+   *
+   * @generated from field: string next_page_token = 2;
+   */
+  nextPageToken: string;
+
+  constructor(data?: PartialMessage<AgentTask_GetTasksResponse>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.agent.AgentTask.GetTasksResponse";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentTask_GetTasksResponse;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentTask_GetTasksResponse;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentTask_GetTasksResponse;
+
+  static equals(a: AgentTask_GetTasksResponse | PlainMessage<AgentTask_GetTasksResponse> | undefined, b: AgentTask_GetTasksResponse | PlainMessage<AgentTask_GetTasksResponse> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.agent.AgentTask.Task
+ */
+declare class AgentTask_Task extends Message<AgentTask_Task> {
+  /**
+   * @generated from field: string task_id = 1;
+   */
+  taskId: string;
+
+  /**
+   * @generated from field: string thread_id = 2;
+   */
+  threadId: string;
+
+  /**
+   * The task's name, as the agent defines it.
+   *
+   * @generated from field: string name = 3;
+   */
+  name: string;
+
+  /**
+   * @generated from field: livekit.agent.AgentTask.Status status = 4;
+   */
+  status: AgentTask_Status;
+
+  /**
+   * @generated from field: google.protobuf.Timestamp updated_at = 5;
+   */
+  updatedAt?: Timestamp;
+
+  constructor(data?: PartialMessage<AgentTask_Task>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.agent.AgentTask.Task";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentTask_Task;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentTask_Task;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentTask_Task;
+
+  static equals(a: AgentTask_Task | PlainMessage<AgentTask_Task> | undefined, b: AgentTask_Task | PlainMessage<AgentTask_Task> | undefined): boolean;
+}
+
+type livekit_agent_thread_pb_d_AgentTask = AgentTask;
+declare const livekit_agent_thread_pb_d_AgentTask: typeof AgentTask;
+type livekit_agent_thread_pb_d_AgentTask_GetTasksRequest = AgentTask_GetTasksRequest;
+declare const livekit_agent_thread_pb_d_AgentTask_GetTasksRequest: typeof AgentTask_GetTasksRequest;
+type livekit_agent_thread_pb_d_AgentTask_GetTasksResponse = AgentTask_GetTasksResponse;
+declare const livekit_agent_thread_pb_d_AgentTask_GetTasksResponse: typeof AgentTask_GetTasksResponse;
+type livekit_agent_thread_pb_d_AgentTask_Status = AgentTask_Status;
+declare const livekit_agent_thread_pb_d_AgentTask_Status: typeof AgentTask_Status;
+type livekit_agent_thread_pb_d_AgentTask_Task = AgentTask_Task;
+declare const livekit_agent_thread_pb_d_AgentTask_Task: typeof AgentTask_Task;
+type livekit_agent_thread_pb_d_AgentThread = AgentThread;
+declare const livekit_agent_thread_pb_d_AgentThread: typeof AgentThread;
+type livekit_agent_thread_pb_d_AgentThread_CreateRequest = AgentThread_CreateRequest;
+declare const livekit_agent_thread_pb_d_AgentThread_CreateRequest: typeof AgentThread_CreateRequest;
+type livekit_agent_thread_pb_d_AgentThread_DeleteRequest = AgentThread_DeleteRequest;
+declare const livekit_agent_thread_pb_d_AgentThread_DeleteRequest: typeof AgentThread_DeleteRequest;
+type livekit_agent_thread_pb_d_AgentThread_DeleteResponse = AgentThread_DeleteResponse;
+declare const livekit_agent_thread_pb_d_AgentThread_DeleteResponse: typeof AgentThread_DeleteResponse;
+type livekit_agent_thread_pb_d_AgentThread_GetItemsRequest = AgentThread_GetItemsRequest;
+declare const livekit_agent_thread_pb_d_AgentThread_GetItemsRequest: typeof AgentThread_GetItemsRequest;
+type livekit_agent_thread_pb_d_AgentThread_GetItemsResponse = AgentThread_GetItemsResponse;
+declare const livekit_agent_thread_pb_d_AgentThread_GetItemsResponse: typeof AgentThread_GetItemsResponse;
+type livekit_agent_thread_pb_d_AgentThread_GetRequest = AgentThread_GetRequest;
+declare const livekit_agent_thread_pb_d_AgentThread_GetRequest: typeof AgentThread_GetRequest;
+type livekit_agent_thread_pb_d_AgentThread_Item = AgentThread_Item;
+declare const livekit_agent_thread_pb_d_AgentThread_Item: typeof AgentThread_Item;
+type livekit_agent_thread_pb_d_AgentThread_ListRequest = AgentThread_ListRequest;
+declare const livekit_agent_thread_pb_d_AgentThread_ListRequest: typeof AgentThread_ListRequest;
+type livekit_agent_thread_pb_d_AgentThread_ListResponse = AgentThread_ListResponse;
+declare const livekit_agent_thread_pb_d_AgentThread_ListResponse: typeof AgentThread_ListResponse;
+type livekit_agent_thread_pb_d_AgentThread_SortOrder = AgentThread_SortOrder;
+declare const livekit_agent_thread_pb_d_AgentThread_SortOrder: typeof AgentThread_SortOrder;
+type livekit_agent_thread_pb_d_AgentThread_Thread = AgentThread_Thread;
+declare const livekit_agent_thread_pb_d_AgentThread_Thread: typeof AgentThread_Thread;
+type livekit_agent_thread_pb_d_AgentThread_UpdateRequest = AgentThread_UpdateRequest;
+declare const livekit_agent_thread_pb_d_AgentThread_UpdateRequest: typeof AgentThread_UpdateRequest;
+declare namespace livekit_agent_thread_pb_d {
+  export {
+    livekit_agent_thread_pb_d_AgentTask as AgentTask,
+    livekit_agent_thread_pb_d_AgentTask_GetTasksRequest as AgentTask_GetTasksRequest,
+    livekit_agent_thread_pb_d_AgentTask_GetTasksResponse as AgentTask_GetTasksResponse,
+    livekit_agent_thread_pb_d_AgentTask_Status as AgentTask_Status,
+    livekit_agent_thread_pb_d_AgentTask_Task as AgentTask_Task,
+    livekit_agent_thread_pb_d_AgentThread as AgentThread,
+    livekit_agent_thread_pb_d_AgentThread_CreateRequest as AgentThread_CreateRequest,
+    livekit_agent_thread_pb_d_AgentThread_DeleteRequest as AgentThread_DeleteRequest,
+    livekit_agent_thread_pb_d_AgentThread_DeleteResponse as AgentThread_DeleteResponse,
+    livekit_agent_thread_pb_d_AgentThread_GetItemsRequest as AgentThread_GetItemsRequest,
+    livekit_agent_thread_pb_d_AgentThread_GetItemsResponse as AgentThread_GetItemsResponse,
+    livekit_agent_thread_pb_d_AgentThread_GetRequest as AgentThread_GetRequest,
+    livekit_agent_thread_pb_d_AgentThread_Item as AgentThread_Item,
+    livekit_agent_thread_pb_d_AgentThread_ListRequest as AgentThread_ListRequest,
+    livekit_agent_thread_pb_d_AgentThread_ListResponse as AgentThread_ListResponse,
+    livekit_agent_thread_pb_d_AgentThread_SortOrder as AgentThread_SortOrder,
+    livekit_agent_thread_pb_d_AgentThread_Thread as AgentThread_Thread,
+    livekit_agent_thread_pb_d_AgentThread_UpdateRequest as AgentThread_UpdateRequest,
+  };
+}
+
+// Copyright 2026 LiveKit, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+
+/**
+ * @generated from enum livekit.agent.AudioEncoding
+ */
+declare enum AudioEncoding {
+  /**
+   * @generated from enum value: AUDIO_ENCODING_PCM_S16LE = 0;
+   */
+  PCM_S16LE = 0,
+
+  /**
+   * @generated from enum value: AUDIO_ENCODING_OPUS = 1;
+   */
+  OPUS = 1,
+}
+
+/**
+ * @generated from message livekit.agent.SessionSettings
+ */
+declare class SessionSettings extends Message<SessionSettings> {
+  /**
+   * @generated from field: uint32 sample_rate = 1;
+   */
+  sampleRate: number;
+
+  /**
+   * @generated from field: livekit.agent.AudioEncoding encoding = 2;
+   */
+  encoding: AudioEncoding;
+
+  /**
+   * @generated from oneof livekit.agent.SessionSettings.type_settings
+   */
+  typeSettings: {
+    /**
+     * @generated from field: livekit.agent.EotSettings eot_settings = 3;
+     */
+    value: EotSettings;
+    case: "eotSettings";
+  } | {
+    /**
+     * @generated from field: livekit.agent.InterruptionSettings interruption_settings = 4;
+     */
+    value: InterruptionSettings;
+    case: "interruptionSettings";
+  } | { case: undefined; value?: undefined };
+
+  constructor(data?: PartialMessage<SessionSettings>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.agent.SessionSettings";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SessionSettings;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SessionSettings;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SessionSettings;
+
+  static equals(a: SessionSettings | PlainMessage<SessionSettings> | undefined, b: SessionSettings | PlainMessage<SessionSettings> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.agent.InferenceError
+ */
+declare class InferenceError extends Message<InferenceError> {
+  /**
+   * @generated from field: string message = 1;
+   */
+  message: string;
+
+  /**
+   * error code follows the HTTP status code convention
+   * 4xx for client errors
+   * 5xx for server errors
+   *
+   * @generated from field: uint32 code = 2;
+   */
+  code: number;
+
+  constructor(data?: PartialMessage<InferenceError>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.agent.InferenceError";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InferenceError;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InferenceError;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InferenceError;
+
+  static equals(a: InferenceError | PlainMessage<InferenceError> | undefined, b: InferenceError | PlainMessage<InferenceError> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.agent.EotSettings
+ */
+declare class EotSettings extends Message<EotSettings> {
+  /**
+   * @generated from field: google.protobuf.Duration detection_interval = 1;
+   */
+  detectionInterval?: Duration;
+
+  constructor(data?: PartialMessage<EotSettings>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.agent.EotSettings";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EotSettings;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EotSettings;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EotSettings;
+
+  static equals(a: EotSettings | PlainMessage<EotSettings> | undefined, b: EotSettings | PlainMessage<EotSettings> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.agent.InterruptionSettings
+ */
+declare class InterruptionSettings extends Message<InterruptionSettings> {
+  /**
+   * detection threshold in range [0.0, 1.0]; higher values are less sensitive
+   *
+   * @generated from field: float threshold = 1;
+   */
+  threshold: number;
+
+  /**
+   * minimum number of frames with probability greater than threshold to trigger an interruption
+   *
+   * @generated from field: uint32 min_frames = 2;
+   */
+  minFrames: number;
+
+  /**
+   * @generated from field: google.protobuf.Duration max_audio_duration = 3;
+   */
+  maxAudioDuration?: Duration;
+
+  /**
+   * @generated from field: google.protobuf.Duration audio_prefix_duration = 4;
+   */
+  audioPrefixDuration?: Duration;
+
+  /**
+   * @generated from field: google.protobuf.Duration detection_interval = 5;
+   */
+  detectionInterval?: Duration;
+
+  constructor(data?: PartialMessage<InterruptionSettings>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.agent.InterruptionSettings";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InterruptionSettings;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InterruptionSettings;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InterruptionSettings;
+
+  static equals(a: InterruptionSettings | PlainMessage<InterruptionSettings> | undefined, b: InterruptionSettings | PlainMessage<InterruptionSettings> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.agent.SessionCreate
+ */
+declare class SessionCreate extends Message<SessionCreate> {
+  /**
+   * @generated from field: livekit.agent.SessionSettings settings = 1;
+   */
+  settings?: SessionSettings;
+
+  constructor(data?: PartialMessage<SessionCreate>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.agent.SessionCreate";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SessionCreate;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SessionCreate;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SessionCreate;
+
+  static equals(a: SessionCreate | PlainMessage<SessionCreate> | undefined, b: SessionCreate | PlainMessage<SessionCreate> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.agent.InputAudio
+ */
+declare class InputAudio extends Message<InputAudio> {
+  /**
+   * @generated from field: bytes audio = 1;
+   */
+  audio: Uint8Array;
+
+  /**
+   * @generated from field: google.protobuf.Timestamp created_at = 2;
+   */
+  createdAt?: Timestamp;
+
+  /**
+   * @generated from field: uint32 num_samples = 3;
+   */
+  numSamples: number;
+
+  constructor(data?: PartialMessage<InputAudio>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.agent.InputAudio";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InputAudio;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InputAudio;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InputAudio;
+
+  static equals(a: InputAudio | PlainMessage<InputAudio> | undefined, b: InputAudio | PlainMessage<InputAudio> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.agent.EotInputChatContext
+ */
+declare class EotInputChatContext extends Message<EotInputChatContext> {
+  /**
+   * @generated from field: repeated livekit.agent.ChatMessage messages = 1;
+   */
+  messages: ChatMessage$1[];
+
+  constructor(data?: PartialMessage<EotInputChatContext>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.agent.EotInputChatContext";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EotInputChatContext;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EotInputChatContext;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EotInputChatContext;
+
+  static equals(a: EotInputChatContext | PlainMessage<EotInputChatContext> | undefined, b: EotInputChatContext | PlainMessage<EotInputChatContext> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.agent.SessionFlush
+ */
+declare class SessionFlush extends Message<SessionFlush> {
+  constructor(data?: PartialMessage<SessionFlush>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.agent.SessionFlush";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SessionFlush;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SessionFlush;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SessionFlush;
+
+  static equals(a: SessionFlush | PlainMessage<SessionFlush> | undefined, b: SessionFlush | PlainMessage<SessionFlush> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.agent.SessionClose
+ */
+declare class SessionClose extends Message<SessionClose> {
+  constructor(data?: PartialMessage<SessionClose>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.agent.SessionClose";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SessionClose;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SessionClose;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SessionClose;
+
+  static equals(a: SessionClose | PlainMessage<SessionClose> | undefined, b: SessionClose | PlainMessage<SessionClose> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.agent.InferenceStart
+ */
+declare class InferenceStart extends Message<InferenceStart> {
+  /**
+   * @generated from field: string request_id = 1;
+   */
+  requestId: string;
+
+  constructor(data?: PartialMessage<InferenceStart>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.agent.InferenceStart";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InferenceStart;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InferenceStart;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InferenceStart;
+
+  static equals(a: InferenceStart | PlainMessage<InferenceStart> | undefined, b: InferenceStart | PlainMessage<InferenceStart> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.agent.InferenceStop
+ */
+declare class InferenceStop extends Message<InferenceStop> {
+  /**
+   * @generated from field: string request_id = 1;
+   */
+  requestId: string;
+
+  constructor(data?: PartialMessage<InferenceStop>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.agent.InferenceStop";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InferenceStop;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InferenceStop;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InferenceStop;
+
+  static equals(a: InferenceStop | PlainMessage<InferenceStop> | undefined, b: InferenceStop | PlainMessage<InferenceStop> | undefined): boolean;
+}
+
+/**
+ * audio buffer sentinel messages
  *
  * @generated from message livekit.agent.BufferStart
  */
@@ -4886,6 +5637,15 @@ declare class MetricsRecordingHeader extends Message<MetricsRecordingHeader> {
    */
   redactionEnabled: boolean;
 
+  /**
+   * JSON object of session facts for agent evals, at most 16 KiB. Its schema is
+   * evalschema/session-summary.schema.json in livekit/cloud-protocol. The collector
+   * stores it without reading individual keys.
+   *
+   * @generated from field: string session_summary = 11;
+   */
+  sessionSummary: string;
+
   constructor(data?: PartialMessage<MetricsRecordingHeader>);
 
   static readonly runtime: typeof proto3;
@@ -5076,9 +5836,19 @@ declare enum DataTrackExtensionID {
   DTEI_INVALID = 0,
 
   /**
-   * @generated from enum value: DTEI_PARTICIPANT_SID = 1;
+   * @generated from enum value: DTEI_E2EE = 1;
+   */
+  DTEI_E2EE = 1,
+
+  /**
+   * @generated from enum value: DTEI_USER_TIMESTAMP = 2;
+   */
+  DTEI_USER_TIMESTAMP = 2,
+
+  /**
+   * @generated from enum value: DTEI_PARTICIPANT_SID = 255;
    */
-  DTEI_PARTICIPANT_SID = 1,
+  DTEI_PARTICIPANT_SID = 255,
 }
 
 /**
@@ -8406,6 +9176,11 @@ declare class RTPForwarderState extends Message<RTPForwarderState> {
    */
   senderReportState: RTCPSenderReportState[];
 
+  /**
+   * @generated from field: livekit.DependencyDescriptorForwarderState dependency_descriptor_forwarder = 9;
+   */
+  dependencyDescriptorForwarder?: DependencyDescriptorForwarderState;
+
   constructor(data?: PartialMessage<RTPForwarderState>);
 
   static readonly runtime: typeof proto3;
@@ -8421,6 +9196,35 @@ declare class RTPForwarderState extends Message<RTPForwarderState> {
   static equals(a: RTPForwarderState | PlainMessage<RTPForwarderState> | undefined, b: RTPForwarderState | PlainMessage<RTPForwarderState> | undefined): boolean;
 }
 
+/**
+ * State of a forwarder that writes the dependency descriptor for the subscriber, so
+ * its frame numbers continue on a migrated subscriber.
+ *
+ * @generated from message livekit.DependencyDescriptorForwarderState
+ */
+declare class DependencyDescriptorForwarderState extends Message<DependencyDescriptorForwarderState> {
+  /**
+   * highest extended frame number sent to the subscriber
+   *
+   * @generated from field: uint64 ext_last_frame_number = 1;
+   */
+  extLastFrameNumber: bigint;
+
+  constructor(data?: PartialMessage<DependencyDescriptorForwarderState>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.DependencyDescriptorForwarderState";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DependencyDescriptorForwarderState;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DependencyDescriptorForwarderState;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DependencyDescriptorForwarderState;
+
+  static equals(a: DependencyDescriptorForwarderState | PlainMessage<DependencyDescriptorForwarderState> | undefined, b: DependencyDescriptorForwarderState | PlainMessage<DependencyDescriptorForwarderState> | undefined): boolean;
+}
+
 /**
  * @generated from message livekit.RTPMungerState
  */
@@ -9060,6 +9864,51 @@ declare enum JobStatus {
    * @generated from enum value: JS_FAILED = 3;
    */
   JS_FAILED = 3,
+
+  /**
+   * the job ended before it was assigned to an agent
+   *
+   * @generated from enum value: JS_CANCELLED = 4;
+   */
+  JS_CANCELLED = 4,
+}
+
+/**
+ * @generated from enum livekit.JobStateReason
+ */
+declare enum JobStateReason {
+  /**
+   * @generated from enum value: JSR_UNSPECIFIED = 0;
+   */
+  JSR_UNSPECIFIED = 0,
+
+  /**
+   * no agent was available to accept the job
+   *
+   * @generated from enum value: JSR_NO_CAPACITY = 1;
+   */
+  JSR_NO_CAPACITY = 1,
+
+  /**
+   * the room closed before an agent was assigned
+   *
+   * @generated from enum value: JSR_ROOM_CLOSED = 2;
+   */
+  JSR_ROOM_CLOSED = 2,
+
+  /**
+   * the dispatch was deleted before an agent was assigned
+   *
+   * @generated from enum value: JSR_DISPATCH_DELETED = 3;
+   */
+  JSR_DISPATCH_DELETED = 3,
+
+  /**
+   * the job failed and is being dispatched again
+   *
+   * @generated from enum value: JSR_RETRYING = 4;
+   */
+  JSR_RETRYING = 4,
 }
 
 /**
@@ -9191,6 +10040,13 @@ declare class JobState extends Message<JobState> {
    */
   agentId: string;
 
+  /**
+   * why the job has no agent, for JS_PENDING and JS_CANCELLED jobs
+   *
+   * @generated from field: livekit.JobStateReason reason = 9;
+   */
+  reason: JobStateReason;
+
   constructor(data?: PartialMessage<JobState>);
 
   static readonly runtime: typeof proto3;
@@ -9323,8 +10179,17 @@ declare class ServerMessage extends Message<ServerMessage> {
     /**
      * @generated from field: livekit.WorkerPong pong = 4;
      */
-    value: WorkerPong;
-    case: "pong";
+    value: WorkerPong;
+    case: "pong";
+  } | {
+    /**
+     * the server is draining this control connection: re-register elsewhere,
+     * in-flight agent HTTP streams run to completion
+     *
+     * @generated from field: livekit.AgentHttp.GoAway go_away = 6;
+     */
+    value: AgentHttp_GoAway;
+    case: "goAway";
   } | { case: undefined; value?: undefined };
 
   constructor(data?: PartialMessage<ServerMessage>);
@@ -9444,15 +10309,11 @@ declare class RegisterWorkerRequest extends Message<RegisterWorkerRequest> {
   agentName: string;
 
   /**
-   * string worker_id = 2;
-   *
    * @generated from field: string version = 3;
    */
   version: string;
 
   /**
-   * string name = 4 [deprecated = true];
-   *
    * @generated from field: uint32 ping_interval = 5;
    */
   pingInterval: number;
@@ -9472,6 +10333,29 @@ declare class RegisterWorkerRequest extends Message<RegisterWorkerRequest> {
    */
   deployment: string;
 
+  /**
+   * HTTP endpoints this worker serves through the data plane, in route order.
+   * Empty means the worker exposes no endpoints and needs no data connections.
+   *
+   * @generated from field: repeated livekit.AgentHttp.AgentEndpoint endpoints = 10;
+   */
+  endpoints: AgentHttp_AgentEndpoint[];
+
+  /**
+   * random per process; a re-registration with a new instance_id supersedes the
+   * previous epoch and closes its remaining connections
+   *
+   * @generated from field: string instance_id = 11;
+   */
+  instanceId: string;
+
+  /**
+   * highest data-plane protocol version the worker supports; 0 = unsupported
+   *
+   * @generated from field: uint32 endpoint_protocol = 12;
+   */
+  endpointProtocol: number;
+
   constructor(data?: PartialMessage<RegisterWorkerRequest>);
 
   static readonly runtime: typeof proto3;
@@ -9501,6 +10385,13 @@ declare class RegisterWorkerResponse extends Message<RegisterWorkerResponse> {
    */
   serverInfo?: ServerInfo;
 
+  /**
+   * present iff the registration carried endpoints and the server supports the data plane
+   *
+   * @generated from field: livekit.AgentHttp.AgentEndpointSettings endpoint_settings = 4;
+   */
+  endpointSettings?: AgentHttp_AgentEndpointSettings;
+
   constructor(data?: PartialMessage<RegisterWorkerResponse>);
 
   static readonly runtime: typeof proto3;
@@ -9527,6 +10418,14 @@ declare class MigrateJobRequest extends Message<MigrateJobRequest> {
    */
   jobIds: string[];
 
+  /**
+   * the jobs in job_ids as they were assigned, with state.participant_identity
+   * set to the identity the worker accepted them with
+   *
+   * @generated from field: repeated livekit.Job jobs = 3;
+   */
+  jobs: Job[];
+
   constructor(data?: PartialMessage<MigrateJobRequest>);
 
   static readonly runtime: typeof proto3;
@@ -9609,162 +10508,487 @@ declare class AvailabilityResponse extends Message<AvailabilityResponse> {
   participantIdentity: string;
 
   /**
-   * @generated from field: string participant_metadata = 6;
+   * @generated from field: string participant_metadata = 6;
+   */
+  participantMetadata: string;
+
+  /**
+   * NEXT_ID: 9
+   *
+   * @generated from field: map<string, string> participant_attributes = 7;
+   */
+  participantAttributes: { [key: string]: string };
+
+  constructor(data?: PartialMessage<AvailabilityResponse>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.AvailabilityResponse";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AvailabilityResponse;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AvailabilityResponse;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AvailabilityResponse;
+
+  static equals(a: AvailabilityResponse | PlainMessage<AvailabilityResponse> | undefined, b: AvailabilityResponse | PlainMessage<AvailabilityResponse> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.UpdateJobStatus
+ */
+declare class UpdateJobStatus extends Message<UpdateJobStatus> {
+  /**
+   * @generated from field: string job_id = 1;
+   */
+  jobId: string;
+
+  /**
+   * The worker can indicate the job end by either specifying SUCCESS or FAILED
+   *
+   * @generated from field: livekit.JobStatus status = 2;
+   */
+  status: JobStatus;
+
+  /**
+   * metadata shown on the dashboard, useful for debugging
+   *
+   * @generated from field: string error = 3;
+   */
+  error: string;
+
+  constructor(data?: PartialMessage<UpdateJobStatus>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.UpdateJobStatus";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateJobStatus;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateJobStatus;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateJobStatus;
+
+  static equals(a: UpdateJobStatus | PlainMessage<UpdateJobStatus> | undefined, b: UpdateJobStatus | PlainMessage<UpdateJobStatus> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.UpdateWorkerStatus
+ */
+declare class UpdateWorkerStatus extends Message<UpdateWorkerStatus> {
+  /**
+   * @generated from field: optional livekit.WorkerStatus status = 1;
+   */
+  status?: WorkerStatus;
+
+  /**
+   * @generated from field: float load = 3;
+   */
+  load: number;
+
+  /**
+   * @generated from field: uint32 job_count = 4;
+   */
+  jobCount: number;
+
+  /**
+   * worker wants no new streams; existing streams run to completion
+   *
+   * @generated from field: bool draining = 5;
+   */
+  draining: boolean;
+
+  /**
+   * monotonic per registration; status updates may interleave across connections
+   * and a stale report must not regress newer state
+   *
+   * @generated from field: uint64 seq = 6;
+   */
+  seq: bigint;
+
+  constructor(data?: PartialMessage<UpdateWorkerStatus>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.UpdateWorkerStatus";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateWorkerStatus;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateWorkerStatus;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateWorkerStatus;
+
+  static equals(a: UpdateWorkerStatus | PlainMessage<UpdateWorkerStatus> | undefined, b: UpdateWorkerStatus | PlainMessage<UpdateWorkerStatus> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.JobAssignment
+ */
+declare class JobAssignment extends Message<JobAssignment> {
+  /**
+   * @generated from field: livekit.Job job = 1;
+   */
+  job?: Job;
+
+  /**
+   * @generated from field: optional string url = 2;
+   */
+  url?: string;
+
+  /**
+   * @generated from field: string token = 3;
+   */
+  token: string;
+
+  constructor(data?: PartialMessage<JobAssignment>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.JobAssignment";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobAssignment;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobAssignment;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobAssignment;
+
+  static equals(a: JobAssignment | PlainMessage<JobAssignment> | undefined, b: JobAssignment | PlainMessage<JobAssignment> | undefined): boolean;
+}
+
+/**
+ * @generated from message livekit.JobTermination
+ */
+declare class JobTermination extends Message<JobTermination> {
+  /**
+   * @generated from field: string job_id = 1;
+   */
+  jobId: string;
+
+  constructor(data?: PartialMessage<JobTermination>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.JobTermination";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobTermination;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobTermination;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobTermination;
+
+  static equals(a: JobTermination | PlainMessage<JobTermination> | undefined, b: JobTermination | PlainMessage<JobTermination> | undefined): boolean;
+}
+
+/**
+ * ----- agent HTTP endpoints data plane -----
+ *
+ * AgentHttp namespaces the data plane: workers expose HTTP endpoints served at
+ * /agents/{agent_name}/{deployment}/{path} without binding any local listener.
+ * The worker opens ONE WebTransport (QUIC) session to /agent that carries both
+ * its control stream (the same WorkerMessage/ServerMessage exchange as the
+ * WebSocket control connection, length-delimited) and every HTTP exchange: the
+ * node opens one bidirectional QUIC stream per request. QUIC provides the
+ * multiplexing and per-stream flow control, so there is no credit accounting
+ * and no attach handshake.
+ *
+ * Each exchange stream is:
+ *
+ *   [len:u32be][StreamPreamble]   the only LiveKit framing
+ *   [ ... opaque bytes ... ]      one HTTP/1.1 exchange, to FIN or RESET_STREAM
+ *
+ * After the preamble the stream is byte-transparent: the node writes a
+ * canonical HTTP/1.1 request and the worker replies with an HTTP/1.1 response,
+ * each parsed by whatever HTTP implementation the side already has. A WebSocket
+ * upgrade is therefore an ordinary request whose response is a 101, after which
+ * the stream is a byte pipe. The protocol evolves by version negotiation at
+ * registration, so the preamble carries no version of its own.
+ *
+ * Bodies use ordinary HTTP/1.1 framing, Content-Length or chunked, and are
+ * unbounded: a body may be many gigabytes and must be streamed. Request and
+ * response size limits are policy for the layer above.
+ *
+ * How one direction ends:
+ *
+ *   success             end of message per the body's own framing, then FIN.
+ *   failed mid-body     chunked trailer fields x-lk-completion and x-lk-error,
+ *                       in band, so the outcome cannot race the bytes it
+ *                       describes.
+ *   failed before any   RESET_STREAM carrying an HttpStreamResetCode, sound
+ *   bytes               only here, where nothing is in flight.
+ *
+ * FIN before the body's own framing says it is complete is truncation, and a
+ * receiver must surface it as such.
+ *
+ * The x-lk- header prefix is reserved for this signalling in both directions.
+ * A node strips it from client-supplied request headers, so a client cannot
+ * forge one, and strips it from responses, so it never reaches the end client.
+ *
+ * @generated from message livekit.AgentHttp
+ */
+declare class AgentHttp extends Message<AgentHttp> {
+  constructor(data?: PartialMessage<AgentHttp>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.AgentHttp";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentHttp;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentHttp;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentHttp;
+
+  static equals(a: AgentHttp | PlainMessage<AgentHttp> | undefined, b: AgentHttp | PlainMessage<AgentHttp> | undefined): boolean;
+}
+
+/**
+ * @generated from enum livekit.AgentHttp.AgentEndpointKind
+ */
+declare enum AgentHttp_AgentEndpointKind {
+  /**
+   * @generated from enum value: AEK_HTTP = 0;
+   */
+  AEK_HTTP = 0,
+
+  /**
+   * reserved for future text-mode endpoints
+   *
+   * @generated from enum value: AEK_TEXT = 1;
+   */
+  AEK_TEXT = 1,
+}
+
+/**
+ * why a stream was reset before any HTTP bytes flowed. This travels as the
+ * QUIC RESET_STREAM / STOP_SENDING error code, so it is a number with no room
+ * for detail: the reason string is logged by the side that reset and joined
+ * to this by request_id. An outcome after bytes have flowed travels in
+ * trailers instead, where it cannot race them.
+ *
+ * @generated from enum livekit.AgentHttp.HttpStreamResetCode
+ */
+declare enum AgentHttp_HttpStreamResetCode {
+  /**
+   * no information. The ordinary cancel code, sent whenever a stream is torn
+   * down without a specific outcome, so it must stay the zero value and must
+   * not imply that anything was or was not applied.
+   *
+   * @generated from enum value: HSR_ABORT = 0;
+   */
+  HSR_ABORT = 0,
+
+  /**
+   * the worker aborted before any application code observed the request, so
+   * nothing was applied and the exchange is safe to retry. Requires that the
+   * application was never entered; a 404 it returned is an ordinary response.
+   *
+   * @generated from enum value: HSR_REFUSED = 1;
+   */
+  HSR_REFUSED = 1,
+
+  /**
+   * the application was entered and then failed before producing a response
+   * head; side effects may already have happened, so this is not safe to
+   * retry.
+   *
+   * @generated from enum value: HSR_INTERNAL = 2;
+   */
+  HSR_INTERNAL = 2,
+
+  /**
+   * the deadline elapsed before a response head was produced
+   *
+   * @generated from enum value: HSR_TIMEOUT = 3;
+   */
+  HSR_TIMEOUT = 3,
+
+  /**
+   * the peer's bytes were not valid HTTP/1.1
+   *
+   * @generated from enum value: HSR_PROTOCOL = 4;
+   */
+  HSR_PROTOCOL = 4,
+}
+
+/**
+ * @generated from message livekit.AgentHttp.AgentEndpoint
+ */
+declare class AgentHttp_AgentEndpoint extends Message<AgentHttp_AgentEndpoint> {
+  /**
+   * starlette-style path template rooted at '/': {name} (one segment, default),
+   * {name:int}, {name:float}, {name:uuid} (constrained single segments),
+   * {name:path} (multi-segment). Custom converters are rejected.
+   *
+   * @generated from field: string path = 1;
+   */
+  path: string;
+
+  /**
+   * uppercase, exactly as the application routes them (FastAPI does not imply
+   * HEAD from GET)
+   *
+   * @generated from field: repeated string methods = 2;
+   */
+  methods: string[];
+
+  /**
+   * @generated from field: livekit.AgentHttp.AgentEndpointKind kind = 3;
    */
-  participantMetadata: string;
+  kind: AgentHttp_AgentEndpointKind;
 
   /**
-   * NEXT_ID: 9
+   * reachable without a project token
    *
-   * @generated from field: map<string, string> participant_attributes = 7;
+   * @generated from field: bool public = 4;
    */
-  participantAttributes: { [key: string]: string };
+  public: boolean;
 
-  constructor(data?: PartialMessage<AvailabilityResponse>);
+  constructor(data?: PartialMessage<AgentHttp_AgentEndpoint>);
 
   static readonly runtime: typeof proto3;
-  static readonly typeName = "livekit.AvailabilityResponse";
+  static readonly typeName = "livekit.AgentHttp.AgentEndpoint";
   static readonly fields: FieldList;
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AvailabilityResponse;
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentHttp_AgentEndpoint;
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AvailabilityResponse;
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentHttp_AgentEndpoint;
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AvailabilityResponse;
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentHttp_AgentEndpoint;
 
-  static equals(a: AvailabilityResponse | PlainMessage<AvailabilityResponse> | undefined, b: AvailabilityResponse | PlainMessage<AvailabilityResponse> | undefined): boolean;
+  static equals(a: AgentHttp_AgentEndpoint | PlainMessage<AgentHttp_AgentEndpoint> | undefined, b: AgentHttp_AgentEndpoint | PlainMessage<AgentHttp_AgentEndpoint> | undefined): boolean;
 }
 
 /**
- * @generated from message livekit.UpdateJobStatus
+ * registration-level settings negotiated on the control connection, returned
+ * in RegisterWorkerResponse when the worker declares endpoints and the server
+ * supports the data plane.
+ *
+ * @generated from message livekit.AgentHttp.AgentEndpointSettings
  */
-declare class UpdateJobStatus extends Message<UpdateJobStatus> {
-  /**
-   * @generated from field: string job_id = 1;
-   */
-  jobId: string;
-
-  /**
-   * The worker can indicate the job end by either specifying SUCCESS or FAILED
-   *
-   * @generated from field: livekit.JobStatus status = 2;
-   */
-  status: JobStatus;
-
+declare class AgentHttp_AgentEndpointSettings extends Message<AgentHttp_AgentEndpointSettings> {
   /**
-   * metadata shown on the dashboard, useful for debugging
+   * the negotiated data-plane protocol version; the worker speaks exactly this
+   * or closes the session
    *
-   * @generated from field: string error = 3;
+   * @generated from field: uint32 protocol = 1;
    */
-  error: string;
+  protocol: number;
 
-  constructor(data?: PartialMessage<UpdateJobStatus>);
+  constructor(data?: PartialMessage<AgentHttp_AgentEndpointSettings>);
 
   static readonly runtime: typeof proto3;
-  static readonly typeName = "livekit.UpdateJobStatus";
+  static readonly typeName = "livekit.AgentHttp.AgentEndpointSettings";
   static readonly fields: FieldList;
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateJobStatus;
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentHttp_AgentEndpointSettings;
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateJobStatus;
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentHttp_AgentEndpointSettings;
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateJobStatus;
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentHttp_AgentEndpointSettings;
 
-  static equals(a: UpdateJobStatus | PlainMessage<UpdateJobStatus> | undefined, b: UpdateJobStatus | PlainMessage<UpdateJobStatus> | undefined): boolean;
+  static equals(a: AgentHttp_AgentEndpointSettings | PlainMessage<AgentHttp_AgentEndpointSettings> | undefined, b: AgentHttp_AgentEndpointSettings | PlainMessage<AgentHttp_AgentEndpointSettings> | undefined): boolean;
 }
 
 /**
- * @generated from message livekit.UpdateWorkerStatus
+ * the first thing on every exchange stream, node -> worker. It carries only
+ * what the worker cannot derive from the HTTP bytes that follow and what it
+ * must not infer from client-supplied headers - identity above all.
+ *
+ * @generated from message livekit.AgentHttp.StreamPreamble
  */
-declare class UpdateWorkerStatus extends Message<UpdateWorkerStatus> {
+declare class AgentHttp_StreamPreamble extends Message<AgentHttp_StreamPreamble> {
   /**
-   * @generated from field: optional livekit.WorkerStatus status = 1;
+   * what the bytes after this preamble are. A field rather than a framing
+   * tag, so a new stream semantic costs no new mechanism.
+   *
+   * @generated from field: livekit.AgentHttp.AgentEndpointKind kind = 1;
    */
-  status?: WorkerStatus;
+  kind: AgentHttp_AgentEndpointKind;
 
   /**
-   * optional string metadata = 2 [deprecated=true];
-   *
-   * @generated from field: float load = 3;
+   * @generated from field: string request_id = 2;
    */
-  load: number;
+  requestId: string;
 
   /**
-   * @generated from field: uint32 job_count = 4;
+   * the caller holds agent-endpoint call permission for this agent and
+   * deployment. Always true on a non-public route.
+   *
+   * @generated from field: bool authorized = 3;
    */
-  jobCount: number;
-
-  constructor(data?: PartialMessage<UpdateWorkerStatus>);
-
-  static readonly runtime: typeof proto3;
-  static readonly typeName = "livekit.UpdateWorkerStatus";
-  static readonly fields: FieldList;
-
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateWorkerStatus;
-
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateWorkerStatus;
-
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateWorkerStatus;
+  authorized: boolean;
 
-  static equals(a: UpdateWorkerStatus | PlainMessage<UpdateWorkerStatus> | undefined, b: UpdateWorkerStatus | PlainMessage<UpdateWorkerStatus> | undefined): boolean;
-}
+  /**
+   * the manifest template that matched, e.g. "/items/{id}"
+   *
+   * @generated from field: string route = 4;
+   */
+  route: string;
 
-/**
- * @generated from message livekit.JobAssignment
- */
-declare class JobAssignment extends Message<JobAssignment> {
   /**
-   * @generated from field: livekit.Job job = 1;
+   * relative, because node and worker clocks are not synchronized. 0 imposes
+   * no deadline.
+   *
+   * @generated from field: uint32 timeout_ms = 5;
    */
-  job?: Job;
+  timeoutMs: number;
 
   /**
-   * @generated from field: optional string url = 2;
+   * end client address, host only
+   *
+   * @generated from field: string client_addr = 6;
    */
-  url?: string;
+  clientAddr: string;
 
   /**
-   * @generated from field: string token = 3;
+   * "http" or "https" as the end client saw it; not derivable worker-side
+   *
+   * NEXT_ID: 8
+   *
+   * @generated from field: string scheme = 7;
    */
-  token: string;
+  scheme: string;
 
-  constructor(data?: PartialMessage<JobAssignment>);
+  constructor(data?: PartialMessage<AgentHttp_StreamPreamble>);
 
   static readonly runtime: typeof proto3;
-  static readonly typeName = "livekit.JobAssignment";
+  static readonly typeName = "livekit.AgentHttp.StreamPreamble";
   static readonly fields: FieldList;
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobAssignment;
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentHttp_StreamPreamble;
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobAssignment;
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentHttp_StreamPreamble;
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobAssignment;
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentHttp_StreamPreamble;
 
-  static equals(a: JobAssignment | PlainMessage<JobAssignment> | undefined, b: JobAssignment | PlainMessage<JobAssignment> | undefined): boolean;
+  static equals(a: AgentHttp_StreamPreamble | PlainMessage<AgentHttp_StreamPreamble> | undefined, b: AgentHttp_StreamPreamble | PlainMessage<AgentHttp_StreamPreamble> | undefined): boolean;
 }
 
 /**
- * @generated from message livekit.JobTermination
+ * the server is draining: the worker should re-register elsewhere; in-flight
+ * HTTP exchanges run to completion
+ *
+ * @generated from message livekit.AgentHttp.GoAway
  */
-declare class JobTermination extends Message<JobTermination> {
+declare class AgentHttp_GoAway extends Message<AgentHttp_GoAway> {
   /**
-   * @generated from field: string job_id = 1;
+   * @generated from field: string reason = 1;
    */
-  jobId: string;
+  reason: string;
 
-  constructor(data?: PartialMessage<JobTermination>);
+  constructor(data?: PartialMessage<AgentHttp_GoAway>);
 
   static readonly runtime: typeof proto3;
-  static readonly typeName = "livekit.JobTermination";
+  static readonly typeName = "livekit.AgentHttp.GoAway";
   static readonly fields: FieldList;
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JobTermination;
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentHttp_GoAway;
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JobTermination;
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentHttp_GoAway;
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JobTermination;
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentHttp_GoAway;
 
-  static equals(a: JobTermination | PlainMessage<JobTermination> | undefined, b: JobTermination | PlainMessage<JobTermination> | undefined): boolean;
+  static equals(a: AgentHttp_GoAway | PlainMessage<AgentHttp_GoAway> | undefined, b: AgentHttp_GoAway | PlainMessage<AgentHttp_GoAway> | undefined): boolean;
 }
 
 // Copyright 2023 LiveKit, Inc.
@@ -10382,9 +11606,9 @@ declare class SimulationRun extends Message<SimulationRun> {
   /**
    * Absent when the run ran each scenario once and required it to pass.
    *
-   * @generated from field: optional livekit.SimulationRun.Sampling sampling = 23;
+   * @generated from field: optional livekit.SimulationRun.SamplingOptions sampling = 23;
    */
-  sampling?: SimulationRun_Sampling;
+  sampling?: SimulationRun_SamplingOptions;
 
   constructor(data?: PartialMessage<SimulationRun>);
 
@@ -10528,6 +11752,13 @@ declare class SimulationRun_Job extends Message<SimulationRun_Job> {
    */
   sample: number;
 
+  /**
+   * Set on a failed job whose cause is known; error stays the detail.
+   *
+   * @generated from field: livekit.SimulationRun.Job.FailureReason failure_reason = 19;
+   */
+  failureReason: SimulationRun_Job_FailureReason;
+
   constructor(data?: PartialMessage<SimulationRun_Job>);
 
   static readonly runtime: typeof proto3;
@@ -10573,6 +11804,23 @@ declare enum SimulationRun_Job_Status {
   CANCELLED = 4,
 }
 
+/**
+ * @generated from enum livekit.SimulationRun.Job.FailureReason
+ */
+declare enum SimulationRun_Job_FailureReason {
+  /**
+   * @generated from enum value: FAILURE_REASON_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * The agent under test never joined the simulation's room.
+   *
+   * @generated from enum value: FAILURE_REASON_AGENT_JOIN_TIMEOUT = 1;
+   */
+  AGENT_JOIN_TIMEOUT = 1,
+}
+
 /**
  * @generated from message livekit.SimulationRun.Job.Usage
  */
@@ -10706,6 +11954,36 @@ declare class SimulationRun_JobMetrics extends Message<SimulationRun_JobMetrics>
    */
   conversationProgression?: number;
 
+  /**
+   * How the call ended. A failing end also sets the job's error.
+   *
+   * @generated from field: livekit.SimulationRun.JobMetrics.EndReason end_reason = 21;
+   */
+  endReason: SimulationRun_JobMetrics_EndReason;
+
+  /**
+   * The simulated caller's language, as a language tag: what it spoke or wrote.
+   *
+   * @generated from field: string caller_language = 22;
+   */
+  callerLanguage: string;
+
+  /**
+   * Audio only: the language the caller transcribed the agent in; "" means
+   * caller_language.
+   *
+   * @generated from field: string caller_listen_language = 23;
+   */
+  callerListenLanguage: string;
+
+  /**
+   * Audio only: what the caller's audio went through before the agent heard
+   * it. Absent for a clean call.
+   *
+   * @generated from field: livekit.SimulationImpairments impairments = 24;
+   */
+  impairments?: SimulationImpairments;
+
   constructor(data?: PartialMessage<SimulationRun_JobMetrics>);
 
   static readonly runtime: typeof proto3;
@@ -10721,6 +11999,58 @@ declare class SimulationRun_JobMetrics extends Message<SimulationRun_JobMetrics>
   static equals(a: SimulationRun_JobMetrics | PlainMessage<SimulationRun_JobMetrics> | undefined, b: SimulationRun_JobMetrics | PlainMessage<SimulationRun_JobMetrics> | undefined): boolean;
 }
 
+/**
+ * @generated from enum livekit.SimulationRun.JobMetrics.EndReason
+ */
+declare enum SimulationRun_JobMetrics_EndReason {
+  /**
+   * @generated from enum value: END_REASON_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * the caller finished the scenario
+   *
+   * @generated from enum value: END_REASON_SCENARIO_COMPLETED = 1;
+   */
+  SCENARIO_COMPLETED = 1,
+
+  /**
+   * the agent under test ended the call
+   *
+   * @generated from enum value: END_REASON_AGENT_ENDED = 2;
+   */
+  AGENT_ENDED = 2,
+
+  /**
+   * the agent under test went silent
+   *
+   * @generated from enum value: END_REASON_INACTIVITY = 3;
+   */
+  INACTIVITY = 3,
+
+  /**
+   * the caller ran out of turns
+   *
+   * @generated from enum value: END_REASON_TURN_LIMIT = 4;
+   */
+  TURN_LIMIT = 4,
+
+  /**
+   * the agent under test kept replying with nothing
+   *
+   * @generated from enum value: END_REASON_EMPTY_RESPONSE = 5;
+   */
+  EMPTY_RESPONSE = 5,
+
+  /**
+   * the agent under test failed mid-call
+   *
+   * @generated from enum value: END_REASON_AGENT_ERROR = 6;
+   */
+  AGENT_ERROR = 6,
+}
+
 /**
  * The agent's perception of the caller. Audio only.
  *
@@ -11068,6 +12398,13 @@ declare class SimulationRun_JobMetrics_Conversation extends Message<SimulationRu
    */
   e2eLatencyMs?: number;
 
+  /**
+   * the caller's acknowledgements over the agent's speech
+   *
+   * @generated from field: optional uint32 backchannel_count = 16;
+   */
+  backchannelCount?: number;
+
   constructor(data?: PartialMessage<SimulationRun_JobMetrics_Conversation>);
 
   static readonly runtime: typeof proto3;
@@ -11104,6 +12441,15 @@ declare class SimulationRun_JobMetrics_Turn extends Message<SimulationRun_JobMet
    */
   role: ChatRole;
 
+  /**
+   * The words the judges read for this turn: the speaker's own, or as the
+   * other side heard them when those are unknown (the agent's, without a
+   * RemoteSession).
+   *
+   * @generated from field: string text = 18;
+   */
+  text: string;
+
   /**
    * audio only; relative to t0; unset if the turn could not be aligned to the audio
    *
@@ -11342,9 +12688,9 @@ declare class SimulationRun_CI extends Message<SimulationRun_CI> {
  * Runs each scenario more than once, so a flaky sample is distinguishable
  * from a broken scenario. Both fields are required when it is present.
  *
- * @generated from message livekit.SimulationRun.Sampling
+ * @generated from message livekit.SimulationRun.SamplingOptions
  */
-declare class SimulationRun_Sampling extends Message<SimulationRun_Sampling> {
+declare class SimulationRun_SamplingOptions extends Message<SimulationRun_SamplingOptions> {
   /**
    * Samples per scenario, > 1. The run holds scenarios × samples jobs,
    * subject to the usual job cap.
@@ -11362,19 +12708,19 @@ declare class SimulationRun_Sampling extends Message<SimulationRun_Sampling> {
    */
   passRate: number;
 
-  constructor(data?: PartialMessage<SimulationRun_Sampling>);
+  constructor(data?: PartialMessage<SimulationRun_SamplingOptions>);
 
   static readonly runtime: typeof proto3;
-  static readonly typeName = "livekit.SimulationRun.Sampling";
+  static readonly typeName = "livekit.SimulationRun.SamplingOptions";
   static readonly fields: FieldList;
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SimulationRun_Sampling;
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SimulationRun_SamplingOptions;
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SimulationRun_Sampling;
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SimulationRun_SamplingOptions;
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SimulationRun_Sampling;
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SimulationRun_SamplingOptions;
 
-  static equals(a: SimulationRun_Sampling | PlainMessage<SimulationRun_Sampling> | undefined, b: SimulationRun_Sampling | PlainMessage<SimulationRun_Sampling> | undefined): boolean;
+  static equals(a: SimulationRun_SamplingOptions | PlainMessage<SimulationRun_SamplingOptions> | undefined, b: SimulationRun_SamplingOptions | PlainMessage<SimulationRun_SamplingOptions> | undefined): boolean;
 }
 
 /**
@@ -11445,6 +12791,7 @@ declare class SimulationRun_Create_Request extends Message<SimulationRun_Create_
 
   /**
    * Impairments applied to the simulated user's audio; AUDIO mode only.
+   * TODO(u9g): migrate these to SimulationImpairments.
    *
    * @generated from field: bool background_noise = 10;
    */
@@ -11470,9 +12817,9 @@ declare class SimulationRun_Create_Request extends Message<SimulationRun_Create_
    * scenario_group. The run fails if any scenario fails; pass@k and
    * pass^k report over scenarios and neither gates.
    *
-   * @generated from field: optional livekit.SimulationRun.Sampling sampling = 14;
+   * @generated from field: optional livekit.SimulationRun.SamplingOptions sampling = 14;
    */
-  sampling?: SimulationRun_Sampling;
+  sampling?: SimulationRun_SamplingOptions;
 
   constructor(data?: PartialMessage<SimulationRun_Create_Request>);
 
@@ -12035,7 +13382,7 @@ declare class Scenario extends Message<Scenario> {
   agentExpectations: string;
 
   /**
-   * Set as participant attributes on the simulation participant's access token.
+   * Surfaced to the agent under test as SimulationContext scenario tags.
    *
    * @generated from field: map<string, string> tags = 4;
    */
@@ -12189,8 +13536,45 @@ declare class ScenarioGroup extends Message<ScenarioGroup> {
 }
 
 /**
- * Carried (protojson-encoded) in the simulation room's metadata so the agent
- * under test can read the scenario + run identity synchronously at connect.
+ * What the simulated caller's audio went through before the agent heard it.
+ *
+ * @generated from message livekit.SimulationImpairments
+ */
+declare class SimulationImpairments extends Message<SimulationImpairments> {
+  /**
+   * @generated from field: bool background_noise = 1;
+   */
+  backgroundNoise: boolean;
+
+  /**
+   * @generated from field: bool low_quality_microphone = 2;
+   */
+  lowQualityMicrophone: boolean;
+
+  /**
+   * @generated from field: bool packet_loss = 3;
+   */
+  packetLoss: boolean;
+
+  constructor(data?: PartialMessage<SimulationImpairments>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.SimulationImpairments";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SimulationImpairments;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SimulationImpairments;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SimulationImpairments;
+
+  static equals(a: SimulationImpairments | PlainMessage<SimulationImpairments> | undefined, b: SimulationImpairments | PlainMessage<SimulationImpairments> | undefined): boolean;
+}
+
+/**
+ * Carried (protojson-encoded) in the Job's lk.simulator.dispatch attribute, set
+ * on the agent dispatch, so the agent under test can read the scenario + run
+ * identity synchronously at job start.
  *
  * @generated from message livekit.SimulationDispatch
  */
@@ -12398,9 +13782,18 @@ declare enum SegmentedFileProtocol {
   DEFAULT_SEGMENTED_FILE_PROTOCOL = 0,
 
   /**
+   * MPEG-TS segments
+   *
    * @generated from enum value: HLS_PROTOCOL = 1;
    */
   HLS_PROTOCOL = 1,
+
+  /**
+   * fragmented MP4 segments
+   *
+   * @generated from enum value: HLS_FMP4_PROTOCOL = 2;
+   */
+  HLS_FMP4_PROTOCOL = 2,
 }
 
 /**
@@ -13119,12 +14512,19 @@ declare class StreamOutput extends Message<StreamOutput> {
   protocol: StreamProtocol;
 
   /**
-   * required
+   * urls or destinations required
    *
    * @generated from field: repeated string urls = 2;
    */
   urls: string[];
 
+  /**
+   * urls or destinations required
+   *
+   * @generated from field: repeated livekit.StreamDestination destinations = 3;
+   */
+  destinations: StreamDestination[];
+
   constructor(data?: PartialMessage<StreamOutput>);
 
   static readonly runtime: typeof proto3;
@@ -13140,6 +14540,39 @@ declare class StreamOutput extends Message<StreamOutput> {
   static equals(a: StreamOutput | PlainMessage<StreamOutput> | undefined, b: StreamOutput | PlainMessage<StreamOutput> | undefined): boolean;
 }
 
+/**
+ * @generated from message livekit.StreamDestination
+ */
+declare class StreamDestination extends Message<StreamDestination> {
+  /**
+   * required
+   *
+   * @generated from field: string id = 1;
+   */
+  id: string;
+
+  /**
+   * required
+   *
+   * @generated from field: string url = 2;
+   */
+  url: string;
+
+  constructor(data?: PartialMessage<StreamDestination>);
+
+  static readonly runtime: typeof proto3;
+  static readonly typeName = "livekit.StreamDestination";
+  static readonly fields: FieldList;
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StreamDestination;
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StreamDestination;
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StreamDestination;
+
+  static equals(a: StreamDestination | PlainMessage<StreamDestination> | undefined, b: StreamDestination | PlainMessage<StreamDestination> | undefined): boolean;
+}
+
 /**
  * Used to generate HLS segments or other kind of segmented output
  *
@@ -13960,6 +15393,13 @@ declare class StreamInfo extends Message<StreamInfo> {
    */
   retries: number;
 
+  /**
+   * StreamDestination.id this stream was started from; empty for plain urls
+   *
+   * @generated from field: string id = 9;
+   */
+  id: string;
+
   constructor(data?: PartialMessage<StreamInfo>);
 
   static readonly runtime: typeof proto3;
@@ -14970,6 +16410,11 @@ declare class UpdateStreamRequest extends Message<UpdateStreamRequest> {
    */
   removeOutputUrls: string[];
 
+  /**
+   * @generated from field: repeated livekit.StreamDestination add_destinations = 4;
+   */
+  addDestinations: StreamDestination[];
+
   constructor(data?: PartialMessage<UpdateStreamRequest>);
 
   static readonly runtime: typeof proto3;
@@ -18056,6 +19501,13 @@ declare class SIPInboundTrunkInfo extends Message<SIPInboundTrunkInfo> {
    */
   ringingTimeout?: Duration;
 
+  /**
+   * SIP status code if ringing_timeout elapses. Unset means using system default.
+   *
+   * @generated from field: livekit.SIPStatusCode ringing_timeout_status = 21;
+   */
+  ringingTimeoutStatus: SIPStatusCode;
+
   /**
    * Max call duration.
    *
@@ -21822,6 +23274,31 @@ declare enum StreamState {
   PAUSED = 1,
 }
 
+/**
+ * @generated from enum livekit.NegotiatedDataChannelID
+ */
+declare enum NegotiatedDataChannelID {
+  /**
+   * @generated from enum value: NDCI_INVALID = 0;
+   */
+  NDCI_INVALID = 0,
+
+  /**
+   * @generated from enum value: NDCI_RELIABLE = 100;
+   */
+  NDCI_RELIABLE = 100,
+
+  /**
+   * @generated from enum value: NDCI_LOSSY = 101;
+   */
+  NDCI_LOSSY = 101,
+
+  /**
+   * @generated from enum value: NDCI_DATA_TRACK = 102;
+   */
+  NDCI_DATA_TRACK = 102,
+}
+
 /**
  * @generated from enum livekit.CandidateProtocol
  */
@@ -25351,7 +26828,7 @@ declare class WebhookEvent extends Message<WebhookEvent> {
   /**
    * one of room_started, room_finished, participant_joined, participant_left, participant_connection_aborted,
    * track_published, track_unpublished, egress_started, egress_updated, egress_ended,
-   * ingress_started, ingress_ended, agent_job_started, agent_job_ended
+   * ingress_started, ingress_ended, agent_job_pending, agent_job_started, agent_job_ended
    *
    * @generated from field: string event = 1;
    */
@@ -25441,4 +26918,4 @@ declare class WebhookEvent extends Message<WebhookEvent> {
 
 declare const version: string;
 
-export { APICallInfo, APICallRequest, AcceptWhatsAppCallRequest, AcceptWhatsAppCallResponse, ActiveSpeakerUpdate, AddTrackRequest, livekit_agent_dev_pb_d as AgentDev, AgentDispatch, AgentDispatchState, livekit_agent_inference_pb_d as AgentInference, livekit_agent_session_pb_d as AgentSession, livekit_agent_text_pb_d as AgentText, AliOSSUpload, AnalyticsClientMeta, AnalyticsEvent, AnalyticsEventType, AnalyticsEvents, AnalyticsNodeRooms, AnalyticsRoom, AnalyticsRoomParticipant, AnalyticsStat, AnalyticsStats, AnalyticsStream, AnalyticsVideoLayer, AudioChannel, AudioCodec, AudioConfig, AudioMixing, AudioRoute, AudioTrackFeature, AutoParticipantEgress, AutoTrackEgress, AvailabilityRequest, AvailabilityResponse, AzureBlobUpload, BackupCodecPolicy, CandidateProtocol, ChatMessage, ClientConfigSetting, ClientConfiguration, ClientInfo, ClientInfo_Capability, ClientInfo_SDK, Codec, ConnectTwilioCallRequest, ConnectTwilioCallRequest_TwilioCallDirection, ConnectTwilioCallResponse, ConnectWhatsAppCallRequest, ConnectWhatsAppCallResponse, ConnectionQuality, ConnectionQualityInfo, ConnectionQualityUpdate, ConnectionSettings, ConnectorType, CreateAgentDispatchRequest, CreateIngressRequest, CreateRoomRequest, CreateSIPDispatchRuleRequest, CreateSIPInboundTrunkRequest, CreateSIPOutboundTrunkRequest, CreateSIPParticipantRequest, CreateSIPTrunkRequest, DataBlob, DataBlobKey, DataChannelInfo, DataChannelReceiveState, DataConfig, DataPacket, DataPacket_Kind, DataSelector, DataStream, DataStream_ByteHeader, DataStream_Chunk, DataStream_CompressionType, DataStream_Header, DataStream_OperationType, DataStream_TextHeader, DataStream_Trailer, DataTrackExtensionID, DataTrackExtensionParticipantSid, DataTrackFrameEncoding, DataTrackFrameEncoding_WellKnownFrameEncoding, DataTrackInfo, DataTrackSchemaEncoding, DataTrackSchemaEncoding_WellKnownSchemaEncoding, DataTrackSchemaId, DataTrackSubscriberHandles, DataTrackSubscriberHandles_PublishedDataTrack, DataTrackSubscriptionOptions, DeleteAgentDispatchRequest, DeleteIngressRequest, DeleteRoomRequest, DeleteRoomResponse, DeleteSIPDispatchRuleRequest, DeleteSIPTrunkRequest, Destination, DialWhatsAppCallRequest, DialWhatsAppCallResponse, DirectFileOutput, DisabledCodecs, DisconnectReason, DisconnectWhatsAppCallRequest, DisconnectWhatsAppCallRequest_DisconnectReason, DisconnectWhatsAppCallResponse, EgressInfo, EgressSourceType, EgressStatus, EncodedFileOutput, EncodedFileType, EncodingOptions, EncodingOptionsPreset, EncryptedPacket, EncryptedPacketPayload, Encryption, Encryption_Type, EventMetric, ExportReplayRequest, FeatureUsageInfo, FeatureUsageInfo_Feature, FileInfo, FileOutput, FilterParams, ForwardParticipantRequest, ForwardParticipantResponse, GCPUpload, GetDataBlobRequest, GetDataBlobResponse, GetSIPInboundTrunkRequest, GetSIPInboundTrunkResponse, GetSIPOutboundTrunkRequest, GetSIPOutboundTrunkResponse, ICEServer, ImageCodec, ImageFileSuffix, ImageOutput, ImagesInfo, IngressAudioEncodingOptions, IngressAudioEncodingPreset, IngressAudioOptions, IngressInfo, IngressInput, IngressState, IngressState_Status, IngressVideoEncodingOptions, IngressVideoEncodingPreset, IngressVideoOptions, InputAudioState, InputVideoState, Job, JobAssignment, JobRestartPolicy, JobState, JobStatus, JobTermination, JobType, JoinRequest, JoinResponse, LeaveRequest, LeaveRequest_Action, ListAgentDispatchRequest, ListAgentDispatchResponse, ListEgressRequest, ListEgressResponse, ListIngressRequest, ListIngressResponse, ListParticipantsRequest, ListParticipantsResponse, ListRoomsRequest, ListRoomsResponse, ListSIPDispatchRuleRequest, ListSIPDispatchRuleResponse, ListSIPInboundTrunkRequest, ListSIPInboundTrunkResponse, ListSIPOutboundTrunkRequest, ListSIPOutboundTrunkResponse, ListSIPTrunkRequest, ListSIPTrunkResponse, ListUpdate, MediaSectionsRequirement, MediaSource, MetricLabel, MetricSample, MetricsBatch, MetricsRecordingHeader, MigrateJobRequest, MoveParticipantRequest, MoveParticipantResponse, MuteRoomTrackRequest, MuteRoomTrackResponse, MuteTrackRequest, Output, PacketTrailerFeature, Pagination, ParticipantEgressRequest, ParticipantInfo, ParticipantInfo_Kind, ParticipantInfo_KindDetail, ParticipantInfo_State, ParticipantPermission, ParticipantTracks, ParticipantUpdate, ParticipantVideo, PerformRpcRequest, PerformRpcResponse, Ping, PlayoutDelay, Pong, ProviderInfo, ProviderType, ProxyConfig, PublishDataTrackRequest, PublishDataTrackResponse, RTCPSenderReportState, RTPDrift, RTPForwarderState, RTPMungerState, RTPStats, ReconnectReason, ReconnectResponse, RegionInfo, RegionSettings, RegisterWorkerRequest, RegisterWorkerResponse, RemoveParticipantResponse, ReportInfo, RequestResponse, RequestResponse_Reason, Room, RoomAgent, RoomAgentDispatch, RoomCompositeEgressRequest, RoomConfiguration, RoomEgress, RoomEndReason, RoomMovedResponse, RoomParticipantIdentity, RoomUpdate, RpcAck, RpcError, RpcRequest, RpcResponse, S3Upload, SIPCallDirection, SIPCallInfo, SIPCallStatus, SIPCodec, SIPDispatchRule, SIPDispatchRuleCallee, SIPDispatchRuleDirect, SIPDispatchRuleIndividual, SIPDispatchRuleInfo, SIPDispatchRuleUpdate, SIPFeature, SIPHeaderOptions, SIPInboundTrunkInfo, SIPInboundTrunkUpdate, SIPMediaConfig, SIPMediaEncryption, SIPNamedDest, SIPOutboundConfig, SIPOutboundTrunkInfo, SIPOutboundTrunkUpdate, SIPParticipantInfo, SIPRequestDest, SIPStatus, SIPStatusCode, SIPTransferError, SIPTransferInfo, SIPTransferReason, SIPTransferStatus, SIPTransport, SIPTrunkInfo, SIPTrunkInfo_TrunkKind, SIPUri, Scenario, ScenarioGroup, Scenario_CreateFromSession, Scenario_CreateFromSession_Request, Scenario_CreateFromSession_Response, SegmentedFileOutput, SegmentedFileProtocol, SegmentedFileSuffix, SegmentsInfo, SendDataRequest, SendDataResponse, ServerInfo, ServerInfo_Edition, ServerMessage, SessionDescription, SignalRequest, SignalResponse, SignalTarget, SimulateJobRequest, SimulateScenario, SimulationDispatch, SimulationMode, SimulationRun, SimulationRunSummary, SimulationRunSummary_Issue, SimulationRun_CI, SimulationRun_Cancel, SimulationRun_Cancel_Request, SimulationRun_Cancel_Response, SimulationRun_ConfirmSourceUpload, SimulationRun_ConfirmSourceUpload_Request, SimulationRun_ConfirmSourceUpload_Response, SimulationRun_Counts, SimulationRun_Counts_Bucket, SimulationRun_Counts_Request, SimulationRun_Counts_Response, SimulationRun_Create, SimulationRun_Create_Request, SimulationRun_Create_Response, SimulationRun_Get, SimulationRun_Get_Request, SimulationRun_Get_Response, SimulationRun_Job, SimulationRun_JobMetrics, SimulationRun_JobMetrics_Conversation, SimulationRun_JobMetrics_LLM, SimulationRun_JobMetrics_STT, SimulationRun_JobMetrics_TTS, SimulationRun_JobMetrics_Turn, SimulationRun_Job_Status, SimulationRun_Job_Usage, SimulationRun_List, SimulationRun_List_Request, SimulationRun_List_Response, SimulationRun_RunMetrics, SimulationRun_Sampling, SimulationRun_Status, SimulationRun_Usage, SimulcastCodec, SimulcastCodecInfo, SipDTMF, SpeakerInfo, SpeakersChanged, StartEgressRequest, StopEgressRequest, StorageConfig, StoreDataBlobRequest, StoreDataBlobResponse, StreamInfo, StreamInfoList, StreamInfo_Status, StreamOutput, StreamProtocol, StreamState, StreamStateInfo, StreamStateUpdate, StreamType, SubscribedAudioCodec, SubscribedAudioCodecUpdate, SubscribedCodec, SubscribedQuality, SubscribedQualityUpdate, SubscriptionError, SubscriptionPermission, SubscriptionPermissionUpdate, SubscriptionResponse, SyncState, TemplateSource, TimeRange, TimeSeriesMetric, TimedVersion, TokenPagination, TokenSourceRequest, TokenSourceResponse, TrackCompositeEgressRequest, TrackEgressRequest, TrackInfo, TrackPermission, TrackPublishedResponse, TrackSource, TrackSubscribed, TrackType, TrackUnpublishedResponse, Transcription, TranscriptionSegment, TransferSIPParticipantRequest, TransferSIPParticipantResponse, TrickleRequest, UnpublishDataTrackRequest, UnpublishDataTrackResponse, UpdateDataSubscription, UpdateDataSubscription_Update, UpdateIngressRequest, UpdateJobStatus, UpdateLayoutRequest, UpdateLocalAudioTrack, UpdateLocalVideoTrack, UpdateParticipantMetadata, UpdateParticipantRequest, UpdateRoomMetadataRequest, UpdateSIPDispatchRuleRequest, UpdateSIPInboundTrunkRequest, UpdateSIPOutboundTrunkRequest, UpdateStreamRequest, UpdateSubscription, UpdateSubscriptionsRequest, UpdateSubscriptionsResponse, UpdateTrackSettings, UpdateVideoLayers, UpdateWorkerStatus, UserPacket, VP8MungerState, VideoCodec, VideoConfiguration, VideoLayer, VideoLayer_Mode, VideoQuality, WebEgressRequest, WebSource, WebhookConfig, WebhookEvent, WebhookInfo, WhatsAppCall, WhatsAppCallDirection, WorkerMessage, WorkerPing, WorkerPong, WorkerStatus, WrappedJoinRequest, WrappedJoinRequest_Compression, version };
+export { APICallInfo, APICallRequest, AcceptWhatsAppCallRequest, AcceptWhatsAppCallResponse, ActiveSpeakerUpdate, AddTrackRequest, livekit_agent_dev_pb_d as AgentDev, AgentDispatch, AgentDispatchState, AgentHttp, AgentHttp_AgentEndpoint, AgentHttp_AgentEndpointKind, AgentHttp_AgentEndpointSettings, AgentHttp_GoAway, AgentHttp_HttpStreamResetCode, AgentHttp_StreamPreamble, livekit_agent_inference_pb_d as AgentInference, livekit_agent_session_pb_d as AgentSession, livekit_agent_text_pb_d as AgentText, livekit_agent_thread_pb_d as AgentThread, AliOSSUpload, AnalyticsClientMeta, AnalyticsEvent, AnalyticsEventType, AnalyticsEvents, AnalyticsNodeRooms, AnalyticsRoom, AnalyticsRoomParticipant, AnalyticsStat, AnalyticsStats, AnalyticsStream, AnalyticsVideoLayer, AudioChannel, AudioCodec, AudioConfig, AudioMixing, AudioRoute, AudioTrackFeature, AutoParticipantEgress, AutoTrackEgress, AvailabilityRequest, AvailabilityResponse, AzureBlobUpload, BackupCodecPolicy, CandidateProtocol, ChatMessage, ClientConfigSetting, ClientConfiguration, ClientInfo, ClientInfo_Capability, ClientInfo_SDK, Codec, ConnectTwilioCallRequest, ConnectTwilioCallRequest_TwilioCallDirection, ConnectTwilioCallResponse, ConnectWhatsAppCallRequest, ConnectWhatsAppCallResponse, ConnectionQuality, ConnectionQualityInfo, ConnectionQualityUpdate, ConnectionSettings, ConnectorType, CreateAgentDispatchRequest, CreateIngressRequest, CreateRoomRequest, CreateSIPDispatchRuleRequest, CreateSIPInboundTrunkRequest, CreateSIPOutboundTrunkRequest, CreateSIPParticipantRequest, CreateSIPTrunkRequest, DataBlob, DataBlobKey, DataChannelInfo, DataChannelReceiveState, DataConfig, DataPacket, DataPacket_Kind, DataSelector, DataStream, DataStream_ByteHeader, DataStream_Chunk, DataStream_CompressionType, DataStream_Header, DataStream_OperationType, DataStream_TextHeader, DataStream_Trailer, DataTrackExtensionID, DataTrackExtensionParticipantSid, DataTrackFrameEncoding, DataTrackFrameEncoding_WellKnownFrameEncoding, DataTrackInfo, DataTrackSchemaEncoding, DataTrackSchemaEncoding_WellKnownSchemaEncoding, DataTrackSchemaId, DataTrackSubscriberHandles, DataTrackSubscriberHandles_PublishedDataTrack, DataTrackSubscriptionOptions, DeleteAgentDispatchRequest, DeleteIngressRequest, DeleteRoomRequest, DeleteRoomResponse, DeleteSIPDispatchRuleRequest, DeleteSIPTrunkRequest, DependencyDescriptorForwarderState, Destination, DialWhatsAppCallRequest, DialWhatsAppCallResponse, DirectFileOutput, DisabledCodecs, DisconnectReason, DisconnectWhatsAppCallRequest, DisconnectWhatsAppCallRequest_DisconnectReason, DisconnectWhatsAppCallResponse, EgressInfo, EgressSourceType, EgressStatus, EncodedFileOutput, EncodedFileType, EncodingOptions, EncodingOptionsPreset, EncryptedPacket, EncryptedPacketPayload, Encryption, Encryption_Type, EventMetric, ExportReplayRequest, FeatureUsageInfo, FeatureUsageInfo_Feature, FileInfo, FileOutput, FilterParams, ForwardParticipantRequest, ForwardParticipantResponse, GCPUpload, GetDataBlobRequest, GetDataBlobResponse, GetSIPInboundTrunkRequest, GetSIPInboundTrunkResponse, GetSIPOutboundTrunkRequest, GetSIPOutboundTrunkResponse, ICEServer, ImageCodec, ImageFileSuffix, ImageOutput, ImagesInfo, IngressAudioEncodingOptions, IngressAudioEncodingPreset, IngressAudioOptions, IngressInfo, IngressInput, IngressState, IngressState_Status, IngressVideoEncodingOptions, IngressVideoEncodingPreset, IngressVideoOptions, InputAudioState, InputVideoState, Job, JobAssignment, JobRestartPolicy, JobState, JobStateReason, JobStatus, JobTermination, JobType, JoinRequest, JoinResponse, LeaveRequest, LeaveRequest_Action, ListAgentDispatchRequest, ListAgentDispatchResponse, ListEgressRequest, ListEgressResponse, ListIngressRequest, ListIngressResponse, ListParticipantsRequest, ListParticipantsResponse, ListRoomsRequest, ListRoomsResponse, ListSIPDispatchRuleRequest, ListSIPDispatchRuleResponse, ListSIPInboundTrunkRequest, ListSIPInboundTrunkResponse, ListSIPOutboundTrunkRequest, ListSIPOutboundTrunkResponse, ListSIPTrunkRequest, ListSIPTrunkResponse, ListUpdate, MediaSectionsRequirement, MediaSource, MetricLabel, MetricSample, MetricsBatch, MetricsRecordingHeader, MigrateJobRequest, MoveParticipantRequest, MoveParticipantResponse, MuteRoomTrackRequest, MuteRoomTrackResponse, MuteTrackRequest, NegotiatedDataChannelID, Output, PacketTrailerFeature, Pagination, ParticipantEgressRequest, ParticipantInfo, ParticipantInfo_Kind, ParticipantInfo_KindDetail, ParticipantInfo_State, ParticipantPermission, ParticipantTracks, ParticipantUpdate, ParticipantVideo, PerformRpcRequest, PerformRpcResponse, Ping, PlayoutDelay, Pong, ProviderInfo, ProviderType, ProxyConfig, PublishDataTrackRequest, PublishDataTrackResponse, RTCPSenderReportState, RTPDrift, RTPForwarderState, RTPMungerState, RTPStats, ReconnectReason, ReconnectResponse, RegionInfo, RegionSettings, RegisterWorkerRequest, RegisterWorkerResponse, RemoveParticipantResponse, ReportInfo, RequestResponse, RequestResponse_Reason, Room, RoomAgent, RoomAgentDispatch, RoomCompositeEgressRequest, RoomConfiguration, RoomEgress, RoomEndReason, RoomMovedResponse, RoomParticipantIdentity, RoomUpdate, RpcAck, RpcError, RpcRequest, RpcResponse, S3Upload, SIPCallDirection, SIPCallInfo, SIPCallStatus, SIPCodec, SIPDispatchRule, SIPDispatchRuleCallee, SIPDispatchRuleDirect, SIPDispatchRuleIndividual, SIPDispatchRuleInfo, SIPDispatchRuleUpdate, SIPFeature, SIPHeaderOptions, SIPInboundTrunkInfo, SIPInboundTrunkUpdate, SIPMediaConfig, SIPMediaEncryption, SIPNamedDest, SIPOutboundConfig, SIPOutboundTrunkInfo, SIPOutboundTrunkUpdate, SIPParticipantInfo, SIPRequestDest, SIPStatus, SIPStatusCode, SIPTransferError, SIPTransferInfo, SIPTransferReason, SIPTransferStatus, SIPTransport, SIPTrunkInfo, SIPTrunkInfo_TrunkKind, SIPUri, Scenario, ScenarioGroup, Scenario_CreateFromSession, Scenario_CreateFromSession_Request, Scenario_CreateFromSession_Response, SegmentedFileOutput, SegmentedFileProtocol, SegmentedFileSuffix, SegmentsInfo, SendDataRequest, SendDataResponse, ServerInfo, ServerInfo_Edition, ServerMessage, SessionDescription, SignalRequest, SignalResponse, SignalTarget, SimulateJobRequest, SimulateScenario, SimulationDispatch, SimulationImpairments, SimulationMode, SimulationRun, SimulationRunSummary, SimulationRunSummary_Issue, SimulationRun_CI, SimulationRun_Cancel, SimulationRun_Cancel_Request, SimulationRun_Cancel_Response, SimulationRun_ConfirmSourceUpload, SimulationRun_ConfirmSourceUpload_Request, SimulationRun_ConfirmSourceUpload_Response, SimulationRun_Counts, SimulationRun_Counts_Bucket, SimulationRun_Counts_Request, SimulationRun_Counts_Response, SimulationRun_Create, SimulationRun_Create_Request, SimulationRun_Create_Response, SimulationRun_Get, SimulationRun_Get_Request, SimulationRun_Get_Response, SimulationRun_Job, SimulationRun_JobMetrics, SimulationRun_JobMetrics_Conversation, SimulationRun_JobMetrics_EndReason, SimulationRun_JobMetrics_LLM, SimulationRun_JobMetrics_STT, SimulationRun_JobMetrics_TTS, SimulationRun_JobMetrics_Turn, SimulationRun_Job_FailureReason, SimulationRun_Job_Status, SimulationRun_Job_Usage, SimulationRun_List, SimulationRun_List_Request, SimulationRun_List_Response, SimulationRun_RunMetrics, SimulationRun_SamplingOptions, SimulationRun_Status, SimulationRun_Usage, SimulcastCodec, SimulcastCodecInfo, SipDTMF, SpeakerInfo, SpeakersChanged, StartEgressRequest, StopEgressRequest, StorageConfig, StoreDataBlobRequest, StoreDataBlobResponse, StreamDestination, StreamInfo, StreamInfoList, StreamInfo_Status, StreamOutput, StreamProtocol, StreamState, StreamStateInfo, StreamStateUpdate, StreamType, SubscribedAudioCodec, SubscribedAudioCodecUpdate, SubscribedCodec, SubscribedQuality, SubscribedQualityUpdate, SubscriptionError, SubscriptionPermission, SubscriptionPermissionUpdate, SubscriptionResponse, SyncState, TemplateSource, TimeRange, TimeSeriesMetric, TimedVersion, TokenPagination, TokenSourceRequest, TokenSourceResponse, TrackCompositeEgressRequest, TrackEgressRequest, TrackInfo, TrackPermission, TrackPublishedResponse, TrackSource, TrackSubscribed, TrackType, TrackUnpublishedResponse, Transcription, TranscriptionSegment, TransferSIPParticipantRequest, TransferSIPParticipantResponse, TrickleRequest, UnpublishDataTrackRequest, UnpublishDataTrackResponse, UpdateDataSubscription, UpdateDataSubscription_Update, UpdateIngressRequest, UpdateJobStatus, UpdateLayoutRequest, UpdateLocalAudioTrack, UpdateLocalVideoTrack, UpdateParticipantMetadata, UpdateParticipantRequest, UpdateRoomMetadataRequest, UpdateSIPDispatchRuleRequest, UpdateSIPInboundTrunkRequest, UpdateSIPOutboundTrunkRequest, UpdateStreamRequest, UpdateSubscription, UpdateSubscriptionsRequest, UpdateSubscriptionsResponse, UpdateTrackSettings, UpdateVideoLayers, UpdateWorkerStatus, UserPacket, VP8MungerState, VideoCodec, VideoConfiguration, VideoLayer, VideoLayer_Mode, VideoQuality, WebEgressRequest, WebSource, WebhookConfig, WebhookEvent, WebhookInfo, WhatsAppCall, WhatsAppCallDirection, WorkerMessage, WorkerPing, WorkerPong, WorkerStatus, WrappedJoinRequest, WrappedJoinRequest_Compression, version };