@meshagent/meshagent-agents 0.47.0 → 0.48.0

package/dist/node/agent-messages.d.ts

@@ -1,6 +1,6 @@
-import { type AgentInputContent } from "@meshagent/meshagent";
+import { type Content } from "@meshagent/meshagent";
 export type AgentPayload = Record<string, unknown>;
-export type JsonMap = Record<string, any>;
+type JsonMap = Record<string, any>;
 export declare const agentRoomMessageType = "agent-message";
 export declare const agentTurnStartType = "meshagent.agent.turn.start";
 export declare const agentTurnSteerType = "meshagent.agent.turn.steer";
@@ -14,6 +14,7 @@ export declare const agentThreadLoadedType = "meshagent.agent.thread.loaded";
 export declare const agentThreadStartRejectedType = "meshagent.agent.thread.start.rejected";
 export declare const agentThreadOpenType = "meshagent.agent.thread.open";
 export declare const agentThreadCloseType = "meshagent.agent.thread.close";
+export declare const agentMessagesInjectType = "meshagent.agent.messages.inject";
 export declare const agentParticipantConnectType = "meshagent.agent.participant.connect";
 export declare const agentParticipantDisconnectType = "meshagent.agent.participant.disconnect";
 export declare const agentThreadDeleteType = "meshagent.agent.thread.delete";
@@ -83,16 +84,38 @@ export declare const agentToolApproveType = "meshagent.agent.tool_call.approve";
 export declare const agentToolRejectType = "meshagent.agent.tool_call.reject";
 export declare const agentSecretResponseType = "meshagent.agent.secret.response";
 export declare const agentClientToolCallResponseType = "meshagent.agent.client_tool_call.response";
+type AgentTextInputContent = {
+    type: "text";
+    text: string;
+};
+type AgentInputContent = AgentTextInputContent | AgentFileContent;
+export declare class AgentFileContent {
+    readonly type: "file";
+    readonly url: string;
+    readonly name?: string;
+    constructor({ url, name }: {
+        url: string;
+        name?: string;
+    });
+    static fromJson(json: JsonMap): AgentFileContent;
+    toJson(): JsonMap;
+    formatWith(values: Record<string, string>): AgentFileContent;
+}
 export declare class ToolChoice {
     readonly toolkitName: string;
     readonly toolName: string;
-    constructor({ toolkitName, toolName, toolkit_name, tool_name }: JsonMap);
+    constructor({ toolkitName, toolName }: {
+        toolkitName: string;
+        toolName: string;
+    });
     static fromJson(json: JsonMap): ToolChoice;
     toJson(): JsonMap;
 }
 export declare class TurnMcpConfig {
     readonly servers: JsonMap[];
-    constructor({ servers }?: JsonMap);
+    constructor({ servers }?: {
+        servers?: JsonMap[];
+    });
     static fromJson(json: JsonMap): TurnMcpConfig;
     toJson(): JsonMap;
 }
@@ -101,13 +124,20 @@ export declare class ClientToolkitDescription {
     readonly title?: string;
     readonly description?: string;
     readonly inputSchema: JsonMap;
-    constructor({ name, title, description, inputSchema, input_schema }: JsonMap);
+    constructor({ name, title, description, inputSchema }: {
+        name: string;
+        title?: string;
+        description?: string;
+        inputSchema: JsonMap;
+    });
     static fromJson(json: JsonMap): ClientToolkitDescription;
     toJson(): JsonMap;
 }
 export declare class TurnToolkitConfig {
     readonly clientOptions?: JsonMap;
-    constructor({ clientOptions, client_options }?: JsonMap);
+    constructor({ clientOptions }?: {
+        clientOptions?: JsonMap;
+    });
     static fromJson(json: JsonMap): TurnToolkitConfig;
     toJson(): JsonMap;
 }
@@ -115,7 +145,11 @@ export declare class AgentAudioFormat {
     readonly type: string;
     readonly sampleRate?: number;
     readonly bitrate?: number;
-    constructor({ type, sampleRate, sample_rate, bitrate }?: JsonMap);
+    constructor({ type, sampleRate, bitrate }?: {
+        type?: string;
+        sampleRate?: number | null;
+        bitrate?: number;
+    });
     static fromJson(json: JsonMap): AgentAudioFormat;
     toJson(): JsonMap;
 }
@@ -133,7 +167,11 @@ export declare class ToolkitToolCapabilities {
     readonly name: string;
     readonly title?: string;
     readonly description?: string;
-    constructor({ name, title, description }: JsonMap);
+    constructor({ name, title, description }: {
+        name: string;
+        title?: string;
+        description?: string;
+    });
     static fromJson(json: JsonMap): ToolkitToolCapabilities;
     toJson(): JsonMap;
 }
@@ -141,12 +179,19 @@ export declare class ToolkitCapabilities {
     readonly name: string;
     readonly title?: string;
     readonly description?: string;
-    readonly thumbnailUrl?: string;
     readonly rules: string[];
     readonly clientOptions?: JsonMap;
     readonly hidden: boolean;
     readonly tools: ToolkitToolCapabilities[];
-    constructor(params: JsonMap);
+    constructor({ name, title, description, rules, clientOptions, hidden, tools }: {
+        name: string;
+        title?: string;
+        description?: string;
+        rules?: string[];
+        clientOptions?: JsonMap;
+        hidden?: boolean;
+        tools?: ToolkitToolCapabilities[];
+    });
     static fromJson(json: JsonMap): ToolkitCapabilities;
     toJson(): JsonMap;
 }
@@ -163,8 +208,26 @@ export declare class AgentModelInfo {
     readonly outputFormat?: AgentAudioFormat;
     readonly turnDetection?: string;
     readonly realtimeProtocols: string[];
+    readonly supportsAttachments: boolean;
+    readonly accepts: string[];
     readonly active: boolean;
-    constructor(params: JsonMap);
+    constructor({ name, friendlyName, description, contextWindow, pricing, modalities, availableVoices, defaultOutputVoice, inputFormat, outputFormat, turnDetection, realtimeProtocols, supportsAttachments, accepts, active }: {
+        name: string;
+        friendlyName?: string;
+        description?: string;
+        contextWindow?: number;
+        pricing?: Record<string, number>;
+        modalities?: string[];
+        availableVoices?: string[];
+        defaultOutputVoice?: string;
+        inputFormat?: AgentAudioFormat;
+        outputFormat?: AgentAudioFormat;
+        turnDetection?: string;
+        realtimeProtocols?: string[];
+        supportsAttachments?: boolean;
+        accepts?: string[];
+        active?: boolean;
+    });
     static fromJson(json: JsonMap): AgentModelInfo;
     toJson(): JsonMap;
 }
@@ -175,7 +238,14 @@ export declare class AgentProviderInfo {
     readonly backend?: string;
     readonly defaultModel: string;
     readonly models: AgentModelInfo[];
-    constructor(params: JsonMap);
+    constructor({ name, friendlyName, description, backend, defaultModel, models }: {
+        name: string;
+        friendlyName: string;
+        description?: string;
+        backend?: string;
+        defaultModel: string;
+        models?: AgentModelInfo[];
+    });
     static fromJson(json: JsonMap): AgentProviderInfo;
     toJson(): JsonMap;
 }
@@ -184,7 +254,12 @@ export declare class AgentThreadListEntry {
     readonly name: string;
     readonly createdAt: string;
     readonly modifiedAt: string;
-    constructor(params: JsonMap);
+    constructor({ path, name, createdAt, modifiedAt }: {
+        path: string;
+        name: string;
+        createdAt: string;
+        modifiedAt: string;
+    });
     static fromJson(json: JsonMap): AgentThreadListEntry;
     toJson(): JsonMap;
 }
@@ -193,14 +268,22 @@ export declare class AgentRealtimeConnectionInfo {
     readonly url: string;
     readonly headers: Record<string, string>;
     readonly webOnlyProtocol?: string;
-    constructor(params: JsonMap);
+    constructor({ protocol, url, headers, webOnlyProtocol }: {
+        protocol: string;
+        url: string;
+        headers?: Record<string, string>;
+        webOnlyProtocol?: string;
+    });
     static fromJson(json: JsonMap): AgentRealtimeConnectionInfo;
     toJson(): JsonMap;
 }
 export declare class AgentToolCallLogLine {
     readonly source: string;
     readonly text: string;
-    constructor({ source, text }: JsonMap);
+    constructor({ source, text }: {
+        source: string;
+        text: string;
+    });
     static fromJson(json: JsonMap): AgentToolCallLogLine;
     toJson(): JsonMap;
 }
@@ -212,7 +295,15 @@ export declare class AgentGeneratedImage {
     readonly width?: number;
     readonly height?: number;
     readonly status?: string;
-    constructor(params?: JsonMap);
+    constructor({ uri, mimeType, createdAt, createdBy, width, height, status }?: {
+        uri?: string;
+        mimeType?: string;
+        createdAt?: string;
+        createdBy?: string;
+        width?: number;
+        height?: number;
+        status?: string;
+    });
     static fromJson(json: JsonMap): AgentGeneratedImage;
     toJson(): JsonMap;
 }
@@ -223,7 +314,14 @@ export declare class AgentGeneratedAudio {
     readonly createdBy?: string;
     readonly status?: string;
     readonly transcript?: string;
-    constructor(params?: JsonMap);
+    constructor({ uri, mimeType, createdAt, createdBy, status, transcript }?: {
+        uri?: string;
+        mimeType?: string;
+        createdAt?: string;
+        createdBy?: string;
+        status?: string;
+        transcript?: string;
+    });
     static fromJson(json: JsonMap): AgentGeneratedAudio;
     toJson(): JsonMap;
 }
@@ -232,16 +330,20 @@ export declare class AgentContextWindowUsage {
     readonly totalTokens?: number;
     readonly compactionMode?: string;
     readonly compactionThreshold?: number;
-    constructor(params: JsonMap);
+    constructor({ usedTokens, totalTokens, compactionMode, compactionThreshold }: {
+        usedTokens: number;
+        totalTokens?: number;
+        compactionMode?: string;
+        compactionThreshold?: number;
+    });
     static fromJson(json: JsonMap): AgentContextWindowUsage;
     toJson(): JsonMap;
 }
 export declare abstract class AgentMessage {
-    [key: string]: any;
     readonly type: string;
     readonly messageId: string;
     readonly senderName?: string;
-    readonly createdAt: string;
+    readonly createdAtUtc: Date;
     readonly metadata: JsonMap;
     protected constructor({ type, messageId, message_id, senderName, sender_name, createdAt, created_at, metadata }: JsonMap);
     toJson(): JsonMap;
@@ -258,93 +360,1332 @@ export declare abstract class AgentLLMMessage extends AgentThreadMessage {
     protected constructor(params: JsonMap);
     toJson(): JsonMap;
 }
-type MessageCtor = {
-    new (params?: JsonMap): AgentMessage;
-    fromJson(json: JsonMap): AgentMessage;
-};
-export declare const StartThread: MessageCtor;
-export declare const TurnStart: MessageCtor;
-export declare const TurnSteer: MessageCtor;
-export declare const TurnInterrupt: MessageCtor;
-export declare const AgentRealtimeAudioChunk: MessageCtor;
-export declare const AgentRealtimeAudioCommit: MessageCtor;
-export declare const ClearThread: MessageCtor;
-export declare const OpenThread: MessageCtor;
-export declare const CloseThread: MessageCtor;
-export declare const ParticipantConnect: MessageCtor;
-export declare const ParticipantDisconnect: MessageCtor;
-export declare const DeleteThread: MessageCtor;
-export declare const RenameThread: MessageCtor;
-export declare const ListThreads: MessageCtor;
-export declare const WatchThreads: MessageCtor;
-export declare const UnwatchThreads: MessageCtor;
-export declare const ThreadsListed: MessageCtor;
-export declare const ThreadCreated: MessageCtor;
-export declare const ThreadUpdated: MessageCtor;
-export declare const ThreadDeleted: MessageCtor;
-export declare const CapabilitiesRequest: MessageCtor;
-export declare const CapabilitiesResponse: MessageCtor;
-export declare const ModelsRequest: MessageCtor;
-export declare const ModelsResponse: MessageCtor;
-export declare const ChangeModel: MessageCtor;
-export declare const AgentModelChanged: MessageCtor;
-export declare const ThreadCleared: MessageCtor;
-export declare const TurnStartAccepted: MessageCtor;
-export declare const TurnStartRejected: MessageCtor;
-export declare const TurnInterruptAccepted: MessageCtor;
-export declare const TurnInterrupted: MessageCtor;
-export declare const TurnSteerAccepted: MessageCtor;
-export declare const TurnSteered: MessageCtor;
-export declare const TurnSteerRejected: MessageCtor;
-export declare const TurnStarted: MessageCtor;
-export declare const TurnEnded: MessageCtor;
-export declare const ThreadStarted: MessageCtor;
-export declare const ThreadLoaded: MessageCtor;
-export declare const ThreadStartRejected: MessageCtor;
-export declare const AgentReasoningContentStarted: MessageCtor;
-export declare const AgentReasoningContentDelta: MessageCtor;
-export declare const AgentReasoningContentEnded: MessageCtor;
-export declare const AgentTextContentStarted: MessageCtor;
-export declare const AgentTextContentDelta: MessageCtor;
-export declare const AgentTextContentEnded: MessageCtor;
-export declare const AgentFileContentStarted: MessageCtor;
-export declare const AgentFileContentDelta: MessageCtor;
-export declare const AgentFileContentEnded: MessageCtor;
-export declare const AgentToolCallPending: MessageCtor;
-export declare const AgentToolCallInProgress: MessageCtor;
-export declare const AgentToolCallStarted: MessageCtor;
-export declare const AgentToolCallArgumentsDelta: MessageCtor;
-export declare const AgentToolCallLogDelta: MessageCtor;
-export declare const AgentToolCallEnded: MessageCtor;
-export declare const AgentToolCallApprovalRequested: MessageCtor;
-export declare const AgentSecretRequested: MessageCtor;
-export declare const AgentClientToolCallRequested: MessageCtor;
-export declare const AgentClientToolCallCancelled: MessageCtor;
-export declare const AgentThreadStatus: MessageCtor;
-export declare const AgentConnectionStatus: MessageCtor;
-export declare const AgentThreadEvent: MessageCtor;
-export declare const AgentImageGenerationStarted: MessageCtor;
-export declare const AgentImageGenerationPartial: MessageCtor;
-export declare const AgentImageGenerationCompleted: MessageCtor;
-export declare const AgentImageGenerationFailed: MessageCtor;
-export declare const AgentAudioGenerationStarted: MessageCtor;
-export declare const AgentAudioGenerationDelta: MessageCtor;
-export declare const AgentAudioGenerationCompleted: MessageCtor;
-export declare const AgentAudioGenerationFailed: MessageCtor;
-export declare const AgentAudioTranscriptionStarted: MessageCtor;
-export declare const AgentAudioTranscriptionDelta: MessageCtor;
-export declare const AgentAudioTranscriptionCompleted: MessageCtor;
-export declare const AgentAudioTranscriptionFailed: MessageCtor;
-export declare const AgentAudioInputSpeechStarted: MessageCtor;
-export declare const AgentAudioInputSpeechEnded: MessageCtor;
-export declare const AgentContextCompacted: MessageCtor;
-export declare const AgentUsageUpdated: MessageCtor;
-export declare const ApproveAgentToolCall: MessageCtor;
-export declare const RejectAgentToolCall: MessageCtor;
-export declare const AgentSecretResponse: MessageCtor;
-export declare const AgentClientToolCallResponse: MessageCtor;
-export declare function agentInputContent({ text, attachments }: {
+type MessageCtor<T extends AgentMessage, Arguments extends JsonMap, Optional extends boolean> = (Optional extends true ? {
+    new (params?: Arguments): T;
+} : {
+    new (params: Arguments): T;
+}) & {
+    fromJson(json: JsonMap): T;
+};
+export interface StartThread extends AgentMessage {
+    readonly content?: AgentInputContent[];
+    readonly name?: string;
+    readonly realtimeProtocol?: string;
+    readonly provider?: string;
+    readonly backend?: string;
+    readonly model?: string;
+    readonly voice?: string;
+    readonly outputModalities?: string[];
+    readonly instructions?: string;
+    readonly mcp?: TurnMcpConfig;
+    readonly clientToolkits?: ClientToolkitDescription[];
+    readonly toolkits?: Record<string, TurnToolkitConfig>;
+    readonly toolChoice?: ToolChoice;
+}
+type StartThreadArguments = {
+    messageId?: string;
+    senderName?: string;
+    content?: AgentInputContent[];
+    name?: string;
+    realtimeProtocol?: string;
+    backend?: string;
+    provider?: string;
+    model?: string;
+    voice?: string;
+    outputModalities?: string[];
+    instructions?: string;
+    mcp?: TurnMcpConfig;
+    clientToolkits?: ClientToolkitDescription[];
+    toolkits?: Record<string, TurnToolkitConfig>;
+    toolChoice?: ToolChoice;
+};
+export interface TurnStart extends AgentThreadMessage {
+    readonly turnId?: string;
+    readonly content: AgentInputContent[];
+    readonly provider?: string;
+    readonly backend?: string;
+    readonly model?: string;
+    readonly voice?: string;
+    readonly outputModalities?: string[];
+    readonly instructions?: string;
+    readonly mcp?: TurnMcpConfig;
+    readonly clientToolkits?: ClientToolkitDescription[];
+    readonly toolkits?: Record<string, TurnToolkitConfig>;
+    readonly toolChoice?: ToolChoice;
+}
+type TurnStartArguments = {
+    threadId: string;
+    messageId?: string;
+    senderName?: string;
+    turnId?: string;
+    content?: AgentInputContent[];
+    backend?: string;
+    provider?: string;
+    model?: string;
+    voice?: string;
+    outputModalities?: string[];
+    instructions?: string;
+    mcp?: TurnMcpConfig;
+    clientToolkits?: ClientToolkitDescription[];
+    toolkits?: Record<string, TurnToolkitConfig>;
+    toolChoice?: ToolChoice;
+};
+export interface TurnSteer extends AgentThreadMessage {
+    readonly turnId: string;
+    readonly content: AgentInputContent[];
+}
+type TurnSteerArguments = {
+    threadId: string;
+    turnId: string;
+    content: AgentInputContent[];
+    messageId?: string;
+    senderName?: string;
+};
+export interface TurnInterrupt extends AgentThreadMessage {
+    readonly turnId: string;
+}
+type TurnInterruptArguments = {
+    threadId: string;
+    turnId: string;
+    messageId?: string;
+    senderName?: string;
+};
+export interface AgentRealtimeAudioChunk extends AgentThreadMessage {
+    readonly data: Uint8Array;
+    readonly format: AgentAudioFormat;
+}
+type AgentRealtimeAudioChunkArguments = {
+    threadId: string;
+    messageId?: string;
+    senderName?: string;
+    data?: Uint8Array;
+    format?: AgentAudioFormat;
+};
+export interface AgentRealtimeAudioCommit extends AgentThreadMessage {
+    readonly turnId?: string;
+    readonly text?: string;
+    readonly status?: string;
+    readonly transcriptionItemId?: string;
+}
+type AgentRealtimeAudioCommitArguments = {
+    threadId: string;
+    messageId?: string;
+    senderName?: string;
+    turnId?: string;
+    text?: string;
+    status?: string;
+    transcriptionItemId?: string;
+};
+export interface ClearThread extends AgentThreadMessage {
+}
+type ClearThreadArguments = {
+    threadId: string;
+    messageId?: string;
+    senderName?: string;
+};
+export interface OpenThread extends AgentThreadMessage {
+    readonly backend?: string;
+    readonly load?: boolean;
+    readonly sinceTurn?: string;
+}
+type OpenThreadArguments = {
+    threadId: string;
+    messageId?: string;
+    senderName?: string;
+    backend?: string;
+    load?: boolean;
+    sinceTurn?: string;
+};
+export interface CloseThread extends AgentThreadMessage {
+}
+type CloseThreadArguments = {
+    threadId: string;
+    messageId?: string;
+    senderName?: string;
+};
+export interface InjectMessages extends AgentThreadMessage {
+    readonly messages: AgentMessage[];
+}
+type InjectMessagesArguments = {
+    threadId: string;
+    messageId?: string;
+    senderName?: string;
+    messages?: AgentMessage[];
+};
+export interface ParticipantConnect extends AgentMessage {
+    readonly participantId: string;
+}
+type ParticipantConnectArguments = {
+    participantId: string;
+    messageId?: string;
+    senderName?: string;
+};
+export interface ParticipantDisconnect extends AgentMessage {
+    readonly participantId: string;
+}
+type ParticipantDisconnectArguments = {
+    participantId: string;
+    messageId?: string;
+    senderName?: string;
+};
+export interface DeleteThread extends AgentThreadMessage {
+}
+type DeleteThreadArguments = {
+    threadId: string;
+    messageId?: string;
+    senderName?: string;
+};
+export interface RenameThread extends AgentThreadMessage {
+    readonly name: string;
+}
+type RenameThreadArguments = {
+    threadId: string;
+    name: string;
+    messageId?: string;
+    senderName?: string;
+};
+export interface ListThreads extends AgentMessage {
+    readonly limit: number;
+    readonly offset: number;
+}
+type ListThreadsArguments = {
+    messageId?: string;
+    senderName?: string;
+    limit?: number;
+    offset?: number;
+};
+export interface WatchThreads extends AgentMessage {
+}
+type WatchThreadsArguments = {
+    messageId?: string;
+    senderName?: string;
+};
+export interface UnwatchThreads extends AgentMessage {
+}
+type UnwatchThreadsArguments = {
+    messageId?: string;
+    senderName?: string;
+};
+export interface ThreadsListed extends AgentMessage {
+    readonly sourceMessageId: string;
+    readonly threads: AgentThreadListEntry[];
+    readonly total: number;
+    readonly offset: number;
+    readonly limit: number;
+}
+type ThreadsListedArguments = {
+    sourceMessageId: string;
+    threads: AgentThreadListEntry[];
+    total: number;
+    offset: number;
+    limit: number;
+    messageId?: string;
+    senderName?: string;
+};
+export interface ThreadCreated extends AgentMessage {
+    readonly thread: AgentThreadListEntry;
+}
+type ThreadCreatedArguments = {
+    thread: AgentThreadListEntry;
+    messageId?: string;
+    senderName?: string;
+};
+export interface ThreadUpdated extends AgentMessage {
+    readonly thread: AgentThreadListEntry;
+}
+type ThreadUpdatedArguments = {
+    thread: AgentThreadListEntry;
+    messageId?: string;
+    senderName?: string;
+};
+export interface ThreadDeleted extends AgentMessage {
+    readonly path: string;
+}
+type ThreadDeletedArguments = {
+    path: string;
+    messageId?: string;
+    senderName?: string;
+};
+export interface CapabilitiesRequest extends AgentThreadMessage {
+}
+type CapabilitiesRequestArguments = {
+    threadId: string;
+    messageId?: string;
+    senderName?: string;
+};
+export interface CapabilitiesResponse extends AgentThreadMessage {
+    readonly sourceMessageId: string;
+    readonly version: string;
+    readonly toolkits: ToolkitCapabilities[];
+}
+type CapabilitiesResponseArguments = {
+    threadId: string;
+    sourceMessageId: string;
+    version: string;
+    toolkits: ToolkitCapabilities[];
+    messageId?: string;
+    senderName?: string;
+};
+export interface ModelsRequest extends AgentMessage {
+}
+type ModelsRequestArguments = {
+    messageId?: string;
+    senderName?: string;
+};
+export interface ModelsResponse extends AgentMessage {
+    readonly sourceMessageId: string;
+    readonly providers: AgentProviderInfo[];
+}
+type ModelsResponseArguments = {
+    sourceMessageId: string;
+    providers: AgentProviderInfo[];
+    messageId?: string;
+    senderName?: string;
+};
+export interface ChangeModel extends AgentThreadMessage {
+    readonly backend?: string;
+    readonly provider?: string;
+    readonly model?: string;
+    readonly voice?: string;
+}
+type ChangeModelArguments = {
+    threadId: string;
+    messageId?: string;
+    senderName?: string;
+    backend?: string;
+    provider?: string;
+    model?: string;
+    voice?: string;
+};
+export interface AgentModelChanged extends AgentThreadMessage {
+    readonly sourceMessageId?: string;
+    readonly backend?: string;
+    readonly provider: string;
+    readonly model: string;
+    readonly voice?: string;
+    readonly inputFormat?: AgentAudioFormat;
+    readonly outputFormat?: AgentAudioFormat;
+    readonly turnDetection?: string;
+    readonly outputModalities: string[];
+    readonly realtimeProtocols: string[];
+    readonly supportsAttachments: boolean;
+    readonly accepts: string[];
+}
+type AgentModelChangedArguments = {
+    threadId: string;
+    provider: string;
+    model: string;
+    messageId?: string;
+    senderName?: string;
+    sourceMessageId?: string;
+    backend?: string;
+    voice?: string;
+    inputFormat?: AgentAudioFormat;
+    outputFormat?: AgentAudioFormat;
+    turnDetection?: string;
+    outputModalities?: string[];
+    realtimeProtocols?: string[];
+    supportsAttachments?: boolean;
+    accepts?: string[];
+};
+export interface ThreadCleared extends AgentThreadMessage {
+    readonly sourceMessageId: string;
+}
+type ThreadClearedArguments = {
+    threadId: string;
+    sourceMessageId: string;
+    messageId?: string;
+    senderName?: string;
+};
+export interface TurnStartAccepted extends AgentThreadMessage {
+    readonly turnId?: string;
+    readonly sourceMessageId: string;
+    readonly content: AgentInputContent[];
+}
+type TurnStartAcceptedArguments = {
+    threadId: string;
+    sourceMessageId: string;
+    messageId?: string;
+    senderName?: string;
+    turnId?: string;
+    content?: AgentInputContent[];
+};
+export interface TurnStartRejected extends AgentThreadMessage {
+    readonly sourceMessageId: string;
+    readonly error: AgentError;
+}
+type TurnStartRejectedArguments = {
+    threadId: string;
+    sourceMessageId: string;
+    error: AgentError;
+    messageId?: string;
+    senderName?: string;
+};
+export interface TurnInterruptAccepted extends AgentThreadMessage {
+    readonly turnId: string;
+    readonly sourceMessageId: string;
+}
+type TurnInterruptAcceptedArguments = {
+    threadId: string;
+    turnId: string;
+    sourceMessageId: string;
+    messageId?: string;
+    senderName?: string;
+};
+export interface TurnInterrupted extends TurnInterruptAccepted {
+    readonly turnId: string;
+    readonly sourceMessageId: string;
+}
+type TurnInterruptedArguments = {
+    threadId: string;
+    turnId: string;
+    sourceMessageId: string;
+    messageId?: string;
+    senderName?: string;
+};
+export interface TurnSteerAccepted extends TurnStartAccepted {
+    readonly turnId?: string;
+    readonly sourceMessageId: string;
+    readonly content: AgentInputContent[];
+}
+type TurnSteerAcceptedArguments = {
+    threadId: string;
+    sourceMessageId: string;
+    turnId: string;
+    messageId?: string;
+    senderName?: string;
+    content?: AgentInputContent[];
+};
+export interface TurnSteered extends TurnInterruptAccepted {
+    readonly turnId: string;
+    readonly sourceMessageId: string;
+}
+type TurnSteeredArguments = {
+    threadId: string;
+    turnId: string;
+    sourceMessageId: string;
+    messageId?: string;
+    senderName?: string;
+};
+export interface TurnSteerRejected extends AgentThreadMessage {
+    readonly turnId: string;
+    readonly sourceMessageId: string;
+    readonly error: AgentError;
+}
+type TurnSteerRejectedArguments = {
+    threadId: string;
+    turnId: string;
+    sourceMessageId: string;
+    error: AgentError;
+    messageId?: string;
+    senderName?: string;
+};
+export interface TurnStarted extends TurnInterruptAccepted {
+    readonly turnId: string;
+    readonly sourceMessageId: string;
+}
+type TurnStartedArguments = {
+    threadId: string;
+    turnId: string;
+    sourceMessageId: string;
+    messageId?: string;
+    senderName?: string;
+};
+export interface TurnEnded extends AgentThreadMessage {
+    readonly turnId: string;
+    readonly error?: AgentError;
+}
+type TurnEndedArguments = {
+    threadId: string;
+    turnId: string;
+    messageId?: string;
+    senderName?: string;
+    error?: AgentError;
+};
+export interface ThreadStarted extends AgentMessage {
+    readonly sourceMessageId: string;
+    readonly threadId: string;
+    readonly realtimeConnection?: AgentRealtimeConnectionInfo;
+}
+type ThreadStartedArguments = {
+    sourceMessageId: string;
+    threadId: string;
+    messageId?: string;
+    senderName?: string;
+    realtimeConnection?: AgentRealtimeConnectionInfo;
+};
+export interface ThreadLoaded extends AgentThreadMessage {
+    readonly sourceMessageId?: string;
+    readonly sinceTurn?: string;
+}
+type ThreadLoadedArguments = {
+    threadId: string;
+    messageId?: string;
+    senderName?: string;
+    sourceMessageId?: string;
+    sinceTurn?: string;
+};
+export interface ThreadStartRejected extends AgentMessage {
+    readonly sourceMessageId: string;
+    readonly error: AgentError;
+}
+type ThreadStartRejectedArguments = {
+    sourceMessageId: string;
+    error: AgentError;
+    messageId?: string;
+    senderName?: string;
+};
+export interface AgentReasoningContentStarted extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+}
+type AgentReasoningContentStartedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+};
+export interface AgentReasoningContentDelta extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly text: string;
+}
+type AgentReasoningContentDeltaArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    text: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+};
+export interface AgentReasoningContentEnded extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+}
+type AgentReasoningContentEndedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+};
+export interface AgentTextContentStarted extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly phase?: string;
+}
+type AgentTextContentStartedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    phase?: string;
+};
+export interface AgentTextContentDelta extends AgentTextContentStarted {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly phase?: string;
+    readonly text: string;
+}
+type AgentTextContentDeltaArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    text: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    phase?: string;
+};
+export interface AgentTextContentEnded extends AgentTextContentStarted {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly phase?: string;
+}
+type AgentTextContentEndedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    phase?: string;
+};
+export interface AgentFileContentStarted extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+}
+type AgentFileContentStartedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+};
+export interface AgentFileContentDelta extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly url: string;
+}
+type AgentFileContentDeltaArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    url: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+};
+export interface AgentFileContentEnded extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+}
+type AgentFileContentEndedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+};
+export interface AgentToolCallPending extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly namespace: string;
+    readonly callId?: string;
+    readonly toolkit: string;
+    readonly tool: string;
+    readonly arguments?: JsonMap;
+    readonly argumentBytes?: number;
+}
+type AgentToolCallPendingArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    toolkit: string;
+    tool: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    namespace?: string;
+    callId?: string;
+    arguments?: JsonMap;
+    argumentBytes?: number;
+};
+export interface AgentToolCallInProgress extends AgentToolCallPending {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly namespace: string;
+    readonly callId?: string;
+    readonly toolkit: string;
+    readonly tool: string;
+    readonly arguments?: JsonMap;
+    readonly argumentBytes?: number;
+}
+type AgentToolCallInProgressArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    toolkit: string;
+    tool: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    namespace?: string;
+    callId?: string;
+    arguments?: JsonMap;
+    argumentBytes?: number;
+};
+export interface AgentToolCallStarted extends AgentToolCallPending {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly namespace: string;
+    readonly callId?: string;
+    readonly toolkit: string;
+    readonly tool: string;
+    readonly arguments?: JsonMap;
+    readonly argumentBytes?: number;
+}
+type AgentToolCallStartedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    toolkit: string;
+    tool: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    namespace?: string;
+    callId?: string;
+    arguments?: JsonMap;
+    argumentBytes?: number;
+};
+export interface AgentToolCallArgumentsDelta extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly namespace: string;
+    readonly callId?: string;
+    readonly delta: string;
+}
+type AgentToolCallArgumentsDeltaArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    delta: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    namespace?: string;
+    callId?: string;
+};
+export interface AgentToolCallLogDelta extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly namespace: string;
+    readonly callId?: string;
+    readonly lines: AgentToolCallLogLine[];
+}
+type AgentToolCallLogDeltaArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    lines: AgentToolCallLogLine[];
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    namespace?: string;
+    callId?: string;
+};
+export interface AgentToolCallEnded extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly namespace: string;
+    readonly callId?: string;
+    readonly toolkit?: string;
+    readonly tool?: string;
+    readonly result?: Content;
+    readonly error?: AgentError;
+}
+type AgentToolCallEndedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    namespace?: string;
+    callId?: string;
+    toolkit?: string;
+    tool?: string;
+    result?: Content;
+    error?: AgentError;
+};
+export interface AgentToolCallApprovalRequested extends AgentToolCallPending {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly namespace: string;
+    readonly callId?: string;
+    readonly toolkit: string;
+    readonly tool: string;
+    readonly arguments?: JsonMap;
+}
+type AgentToolCallApprovalRequestedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    toolkit: string;
+    tool: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    namespace?: string;
+    callId?: string;
+    arguments?: JsonMap;
+};
+export interface AgentSecretRequested extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly requestId: string;
+    readonly secretName: string;
+    readonly prompt?: string;
+    readonly oauth?: JsonMap;
+    readonly challenge?: string;
+}
+type AgentSecretRequestedArguments = {
+    threadId: string;
+    turnId: string;
+    requestId: string;
+    secretName: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    prompt?: string;
+    oauth?: JsonMap;
+    challenge?: string;
+};
+export interface AgentClientToolCallRequested extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly requestId: string;
+    readonly targetParticipantId?: string;
+    readonly toolkit: string;
+    readonly tool: string;
+    readonly arguments: JsonMap;
+}
+type AgentClientToolCallRequestedArguments = {
+    threadId: string;
+    turnId: string;
+    requestId: string;
+    targetParticipantId?: string;
+    toolkit: string;
+    tool: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    arguments?: JsonMap;
+};
+export interface AgentClientToolCallCancelled extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly requestId: string;
+    readonly targetParticipantId?: string;
+    readonly toolkit: string;
+    readonly tool: string;
+    readonly reason?: string;
+}
+type AgentClientToolCallCancelledArguments = {
+    threadId: string;
+    turnId: string;
+    requestId: string;
+    targetParticipantId?: string;
+    toolkit: string;
+    tool: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    reason?: string;
+};
+export interface AgentThreadStatus extends AgentThreadMessage {
+    readonly status?: string;
+    readonly mode?: string;
+    readonly startedAt?: string;
+    readonly turnId?: string;
+    readonly pendingItemId?: string;
+    readonly totalBytes?: number;
+    readonly linesAdded?: number;
+    readonly linesRemoved?: number;
+}
+type AgentThreadStatusArguments = {
+    threadId: string;
+    messageId?: string;
+    senderName?: string;
+    status?: string;
+    mode?: string;
+    startedAt?: string;
+    turnId?: string;
+    pendingItemId?: string;
+    totalBytes?: number;
+    linesAdded?: number;
+    linesRemoved?: number;
+};
+export interface AgentConnectionStatus extends AgentMessage {
+    readonly status: string;
+    readonly message?: string;
+    readonly reason?: string;
+    readonly retryInSeconds?: number;
+    readonly participantId?: string;
+}
+type AgentConnectionStatusArguments = {
+    status: string;
+    messageId?: string;
+    senderName?: string;
+    message?: string;
+    reason?: string;
+    retryInSeconds?: number;
+    participantId?: string;
+};
+export interface AgentThreadEvent extends AgentLLMMessage {
+    readonly event: JsonMap;
+}
+type AgentThreadEventArguments = {
+    threadId: string;
+    event: JsonMap;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+};
+export interface AgentImageGenerationStarted extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly callId?: string;
+    readonly toolkit: string;
+    readonly tool: string;
+    readonly arguments?: JsonMap;
+}
+type AgentImageGenerationStartedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    callId?: string;
+    toolkit?: string;
+    tool?: string;
+    arguments?: JsonMap;
+};
+export interface AgentImageGenerationPartial extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly callId?: string;
+    readonly toolkit: string;
+    readonly tool: string;
+    readonly arguments?: JsonMap;
+    readonly image?: AgentGeneratedImage;
+    readonly partialIndex?: number;
+}
+type AgentImageGenerationPartialArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    callId?: string;
+    toolkit?: string;
+    tool?: string;
+    arguments?: JsonMap;
+    image?: AgentGeneratedImage;
+    partialIndex?: number;
+};
+export interface AgentImageGenerationCompleted extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly callId?: string;
+    readonly toolkit: string;
+    readonly tool: string;
+    readonly arguments?: JsonMap;
+    readonly images: AgentGeneratedImage[];
+}
+type AgentImageGenerationCompletedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    callId?: string;
+    toolkit?: string;
+    tool?: string;
+    arguments?: JsonMap;
+    images?: AgentGeneratedImage[];
+};
+export interface AgentImageGenerationFailed extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly callId?: string;
+    readonly toolkit: string;
+    readonly tool: string;
+    readonly arguments?: JsonMap;
+    readonly error?: AgentError;
+}
+type AgentImageGenerationFailedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    callId?: string;
+    toolkit?: string;
+    tool?: string;
+    arguments?: JsonMap;
+    error?: AgentError;
+};
+export interface AgentAudioGenerationStarted extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly responseId?: string;
+    readonly contentIndex?: number;
+}
+type AgentAudioGenerationStartedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    responseId?: string;
+    contentIndex?: number;
+};
+export interface AgentAudioGenerationDelta extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly responseId?: string;
+    readonly contentIndex?: number;
+    readonly data: Uint8Array;
+    readonly mimeType?: string;
+    readonly outputFormat?: AgentAudioFormat;
+}
+type AgentAudioGenerationDeltaArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    responseId?: string;
+    contentIndex?: number;
+    data?: Uint8Array;
+    mimeType?: string;
+    outputFormat?: AgentAudioFormat;
+};
+export interface AgentAudioGenerationCompleted extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly responseId?: string;
+    readonly contentIndex?: number;
+    readonly audio?: AgentGeneratedAudio;
+    readonly outputFormat?: AgentAudioFormat;
+}
+type AgentAudioGenerationCompletedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    responseId?: string;
+    contentIndex?: number;
+    audio?: AgentGeneratedAudio;
+    outputFormat?: AgentAudioFormat;
+};
+export interface AgentAudioGenerationFailed extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly responseId?: string;
+    readonly contentIndex?: number;
+    readonly error?: AgentError;
+}
+type AgentAudioGenerationFailedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    responseId?: string;
+    contentIndex?: number;
+    error?: AgentError;
+};
+export interface AgentAudioTranscriptionStarted extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly responseId?: string;
+    readonly contentIndex?: number;
+    readonly role?: string;
+}
+type AgentAudioTranscriptionStartedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    responseId?: string;
+    contentIndex?: number;
+    role?: string;
+};
+export interface AgentAudioTranscriptionDelta extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly responseId?: string;
+    readonly contentIndex?: number;
+    readonly role?: string;
+    readonly text: string;
+}
+type AgentAudioTranscriptionDeltaArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    text: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    responseId?: string;
+    contentIndex?: number;
+    role?: string;
+};
+export interface AgentAudioTranscriptionCompleted extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly responseId?: string;
+    readonly contentIndex?: number;
+    readonly role?: string;
+    readonly text?: string;
+}
+type AgentAudioTranscriptionCompletedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    responseId?: string;
+    contentIndex?: number;
+    role?: string;
+    text?: string;
+};
+export interface AgentAudioTranscriptionFailed extends AgentLLMMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+    readonly responseId?: string;
+    readonly contentIndex?: number;
+    readonly role?: string;
+    readonly error?: AgentError;
+}
+type AgentAudioTranscriptionFailedArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+    provider?: string;
+    model?: string;
+    responseId?: string;
+    contentIndex?: number;
+    role?: string;
+    error?: AgentError;
+};
+export interface AgentAudioInputSpeechStarted extends AgentThreadMessage {
+    readonly turnId: string;
+    readonly itemId?: string;
+    readonly audioStartMs?: number;
+}
+type AgentAudioInputSpeechStartedArguments = {
+    threadId: string;
+    turnId: string;
+    messageId?: string;
+    senderName?: string;
+    itemId?: string;
+    audioStartMs?: number;
+};
+export interface AgentAudioInputSpeechEnded extends AgentThreadMessage {
+    readonly turnId: string;
+    readonly itemId?: string;
+    readonly audioEndMs?: number;
+}
+type AgentAudioInputSpeechEndedArguments = {
+    threadId: string;
+    turnId: string;
+    messageId?: string;
+    senderName?: string;
+    itemId?: string;
+    audioEndMs?: number;
+};
+export interface AgentContextCompacted extends AgentThreadMessage {
+    readonly checkpointId: string;
+    readonly path: string;
+    readonly throughSequence: number;
+    readonly createdAt?: string;
+    readonly messages?: JsonMap[];
+}
+type AgentContextCompactedArguments = {
+    threadId: string;
+    checkpointId: string;
+    path: string;
+    throughSequence: number;
+    messageId?: string;
+    senderName?: string;
+    createdAt?: string;
+    messages?: JsonMap[];
+};
+export interface AgentUsageUpdated extends AgentThreadMessage {
+    readonly turnId?: string;
+    readonly usage: Record<string, number>;
+    readonly contextWindow: AgentContextWindowUsage;
+}
+type AgentUsageUpdatedArguments = {
+    threadId: string;
+    contextWindow: AgentContextWindowUsage;
+    messageId?: string;
+    senderName?: string;
+    turnId?: string;
+    usage?: Record<string, number>;
+};
+export interface ApproveAgentToolCall extends AgentThreadMessage {
+    readonly turnId: string;
+    readonly itemId: string;
+}
+type ApproveAgentToolCallArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+};
+export interface RejectAgentToolCall extends ApproveAgentToolCall {
+    readonly turnId: string;
+    readonly itemId: string;
+}
+type RejectAgentToolCallArguments = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    messageId?: string;
+    senderName?: string;
+};
+export interface AgentSecretResponse extends AgentThreadMessage {
+    readonly turnId: string;
+    readonly requestId: string;
+    readonly value?: string;
+    readonly authorizationCode?: string;
+    readonly redirectUri?: string;
+    readonly error?: string;
+}
+type AgentSecretResponseArguments = {
+    threadId: string;
+    turnId: string;
+    requestId: string;
+    messageId?: string;
+    senderName?: string;
+    value?: string;
+    authorizationCode?: string;
+    redirectUri?: string;
+    error?: string;
+};
+export interface AgentClientToolCallResponse extends AgentThreadMessage {
+    readonly turnId: string;
+    readonly requestId: string;
+    readonly response: Content;
+}
+type AgentClientToolCallResponseArguments = {
+    threadId: string;
+    turnId: string;
+    requestId: string;
+    response: Content;
+    messageId?: string;
+    senderName?: string;
+};
+export declare const StartThread: MessageCtor<StartThread, StartThreadArguments, true>;
+export declare const TurnStart: MessageCtor<TurnStart, TurnStartArguments, false>;
+export declare const TurnSteer: MessageCtor<TurnSteer, TurnSteerArguments, false>;
+export declare const TurnInterrupt: MessageCtor<TurnInterrupt, TurnInterruptArguments, false>;
+export declare const AgentRealtimeAudioChunk: MessageCtor<AgentRealtimeAudioChunk, AgentRealtimeAudioChunkArguments, false>;
+export declare const AgentRealtimeAudioCommit: MessageCtor<AgentRealtimeAudioCommit, AgentRealtimeAudioCommitArguments, false>;
+export declare const ClearThread: MessageCtor<ClearThread, ClearThreadArguments, false>;
+export declare const OpenThread: MessageCtor<OpenThread, OpenThreadArguments, false>;
+export declare const CloseThread: MessageCtor<CloseThread, CloseThreadArguments, false>;
+export declare const InjectMessages: MessageCtor<InjectMessages, InjectMessagesArguments, false>;
+export declare const ParticipantConnect: MessageCtor<ParticipantConnect, ParticipantConnectArguments, false>;
+export declare const ParticipantDisconnect: MessageCtor<ParticipantDisconnect, ParticipantDisconnectArguments, false>;
+export declare const DeleteThread: MessageCtor<DeleteThread, DeleteThreadArguments, false>;
+export declare const RenameThread: MessageCtor<RenameThread, RenameThreadArguments, false>;
+export declare const ListThreads: MessageCtor<ListThreads, ListThreadsArguments, true>;
+export declare const WatchThreads: MessageCtor<WatchThreads, WatchThreadsArguments, true>;
+export declare const UnwatchThreads: MessageCtor<UnwatchThreads, UnwatchThreadsArguments, true>;
+export declare const ThreadsListed: MessageCtor<ThreadsListed, ThreadsListedArguments, false>;
+export declare const ThreadCreated: MessageCtor<ThreadCreated, ThreadCreatedArguments, false>;
+export declare const ThreadUpdated: MessageCtor<ThreadUpdated, ThreadUpdatedArguments, false>;
+export declare const ThreadDeleted: MessageCtor<ThreadDeleted, ThreadDeletedArguments, false>;
+export declare const CapabilitiesRequest: MessageCtor<CapabilitiesRequest, CapabilitiesRequestArguments, false>;
+export declare const CapabilitiesResponse: MessageCtor<CapabilitiesResponse, CapabilitiesResponseArguments, false>;
+export declare const ModelsRequest: MessageCtor<ModelsRequest, ModelsRequestArguments, true>;
+export declare const ModelsResponse: MessageCtor<ModelsResponse, ModelsResponseArguments, false>;
+export declare const ChangeModel: MessageCtor<ChangeModel, ChangeModelArguments, false>;
+export declare const AgentModelChanged: MessageCtor<AgentModelChanged, AgentModelChangedArguments, false>;
+export declare const ThreadCleared: MessageCtor<ThreadCleared, ThreadClearedArguments, false>;
+export declare const TurnStartAccepted: MessageCtor<TurnStartAccepted, TurnStartAcceptedArguments, false>;
+export declare const TurnStartRejected: MessageCtor<TurnStartRejected, TurnStartRejectedArguments, false>;
+export declare const TurnInterruptAccepted: MessageCtor<TurnInterruptAccepted, TurnInterruptAcceptedArguments, false>;
+export declare const TurnInterrupted: MessageCtor<TurnInterrupted, TurnInterruptedArguments, false>;
+export declare const TurnSteerAccepted: MessageCtor<TurnSteerAccepted, TurnSteerAcceptedArguments, false>;
+export declare const TurnSteered: MessageCtor<TurnSteered, TurnSteeredArguments, false>;
+export declare const TurnSteerRejected: MessageCtor<TurnSteerRejected, TurnSteerRejectedArguments, false>;
+export declare const TurnStarted: MessageCtor<TurnStarted, TurnStartedArguments, false>;
+export declare const TurnEnded: MessageCtor<TurnEnded, TurnEndedArguments, false>;
+export declare const ThreadStarted: MessageCtor<ThreadStarted, ThreadStartedArguments, false>;
+export declare const ThreadLoaded: MessageCtor<ThreadLoaded, ThreadLoadedArguments, false>;
+export declare const ThreadStartRejected: MessageCtor<ThreadStartRejected, ThreadStartRejectedArguments, false>;
+export declare const AgentReasoningContentStarted: MessageCtor<AgentReasoningContentStarted, AgentReasoningContentStartedArguments, false>;
+export declare const AgentReasoningContentDelta: MessageCtor<AgentReasoningContentDelta, AgentReasoningContentDeltaArguments, false>;
+export declare const AgentReasoningContentEnded: MessageCtor<AgentReasoningContentEnded, AgentReasoningContentEndedArguments, false>;
+export declare const AgentTextContentStarted: MessageCtor<AgentTextContentStarted, AgentTextContentStartedArguments, false>;
+export declare const AgentTextContentDelta: MessageCtor<AgentTextContentDelta, AgentTextContentDeltaArguments, false>;
+export declare const AgentTextContentEnded: MessageCtor<AgentTextContentEnded, AgentTextContentEndedArguments, false>;
+export declare const AgentFileContentStarted: MessageCtor<AgentFileContentStarted, AgentFileContentStartedArguments, false>;
+export declare const AgentFileContentDelta: MessageCtor<AgentFileContentDelta, AgentFileContentDeltaArguments, false>;
+export declare const AgentFileContentEnded: MessageCtor<AgentFileContentEnded, AgentFileContentEndedArguments, false>;
+export declare const AgentToolCallPending: MessageCtor<AgentToolCallPending, AgentToolCallPendingArguments, false>;
+export declare const AgentToolCallInProgress: MessageCtor<AgentToolCallInProgress, AgentToolCallInProgressArguments, false>;
+export declare const AgentToolCallStarted: MessageCtor<AgentToolCallStarted, AgentToolCallStartedArguments, false>;
+export declare const AgentToolCallArgumentsDelta: MessageCtor<AgentToolCallArgumentsDelta, AgentToolCallArgumentsDeltaArguments, false>;
+export declare const AgentToolCallLogDelta: MessageCtor<AgentToolCallLogDelta, AgentToolCallLogDeltaArguments, false>;
+export declare const AgentToolCallEnded: MessageCtor<AgentToolCallEnded, AgentToolCallEndedArguments, false>;
+export declare const AgentToolCallApprovalRequested: MessageCtor<AgentToolCallApprovalRequested, AgentToolCallApprovalRequestedArguments, false>;
+export declare const AgentSecretRequested: MessageCtor<AgentSecretRequested, AgentSecretRequestedArguments, false>;
+export declare const AgentClientToolCallRequested: MessageCtor<AgentClientToolCallRequested, AgentClientToolCallRequestedArguments, false>;
+export declare const AgentClientToolCallCancelled: MessageCtor<AgentClientToolCallCancelled, AgentClientToolCallCancelledArguments, false>;
+export declare const AgentThreadStatus: MessageCtor<AgentThreadStatus, AgentThreadStatusArguments, false>;
+export declare const AgentConnectionStatus: MessageCtor<AgentConnectionStatus, AgentConnectionStatusArguments, false>;
+export declare const AgentThreadEvent: MessageCtor<AgentThreadEvent, AgentThreadEventArguments, false>;
+export declare const AgentImageGenerationStarted: MessageCtor<AgentImageGenerationStarted, AgentImageGenerationStartedArguments, false>;
+export declare const AgentImageGenerationPartial: MessageCtor<AgentImageGenerationPartial, AgentImageGenerationPartialArguments, false>;
+export declare const AgentImageGenerationCompleted: MessageCtor<AgentImageGenerationCompleted, AgentImageGenerationCompletedArguments, false>;
+export declare const AgentImageGenerationFailed: MessageCtor<AgentImageGenerationFailed, AgentImageGenerationFailedArguments, false>;
+export declare const AgentAudioGenerationStarted: MessageCtor<AgentAudioGenerationStarted, AgentAudioGenerationStartedArguments, false>;
+export declare const AgentAudioGenerationDelta: MessageCtor<AgentAudioGenerationDelta, AgentAudioGenerationDeltaArguments, false>;
+export declare const AgentAudioGenerationCompleted: MessageCtor<AgentAudioGenerationCompleted, AgentAudioGenerationCompletedArguments, false>;
+export declare const AgentAudioGenerationFailed: MessageCtor<AgentAudioGenerationFailed, AgentAudioGenerationFailedArguments, false>;
+export declare const AgentAudioTranscriptionStarted: MessageCtor<AgentAudioTranscriptionStarted, AgentAudioTranscriptionStartedArguments, false>;
+export declare const AgentAudioTranscriptionDelta: MessageCtor<AgentAudioTranscriptionDelta, AgentAudioTranscriptionDeltaArguments, false>;
+export declare const AgentAudioTranscriptionCompleted: MessageCtor<AgentAudioTranscriptionCompleted, AgentAudioTranscriptionCompletedArguments, false>;
+export declare const AgentAudioTranscriptionFailed: MessageCtor<AgentAudioTranscriptionFailed, AgentAudioTranscriptionFailedArguments, false>;
+export declare const AgentAudioInputSpeechStarted: MessageCtor<AgentAudioInputSpeechStarted, AgentAudioInputSpeechStartedArguments, false>;
+export declare const AgentAudioInputSpeechEnded: MessageCtor<AgentAudioInputSpeechEnded, AgentAudioInputSpeechEndedArguments, false>;
+export declare const AgentContextCompacted: MessageCtor<AgentContextCompacted, AgentContextCompactedArguments, false>;
+export declare const AgentUsageUpdated: MessageCtor<AgentUsageUpdated, AgentUsageUpdatedArguments, false>;
+export declare const ApproveAgentToolCall: MessageCtor<ApproveAgentToolCall, ApproveAgentToolCallArguments, false>;
+export declare const RejectAgentToolCall: MessageCtor<RejectAgentToolCall, RejectAgentToolCallArguments, false>;
+export declare const AgentSecretResponse: MessageCtor<AgentSecretResponse, AgentSecretResponseArguments, false>;
+export declare const AgentClientToolCallResponse: MessageCtor<AgentClientToolCallResponse, AgentClientToolCallResponseArguments, false>;
+export declare function agentInputContent({ text, attachments, }: {
     text: string;
-    attachments: string[];
+    attachments: AgentFileContent[];
 }): AgentInputContent[];
 export {};