@meshagent/meshagent-agents 0.43.0

package/dist/esm/agent-messages.js

@@ -0,0 +1,989 @@
+import { BinaryContent, ControlContent, EmptyContent, ErrorContent, FileContent, JsonContent, LinkContent, TextContent, packMessage, unpackContent, unpackMessage, } from "@meshagent/meshagent";
+import { v4 as uuidv4 } from "uuid";
+export const agentRoomMessageType = "agent-message";
+export const agentTurnStartType = "meshagent.agent.turn.start";
+export const agentTurnSteerType = "meshagent.agent.turn.steer";
+export const agentTurnInterruptType = "meshagent.agent.turn.interrupt";
+export const agentThreadClearType = "meshagent.agent.thread.clear";
+export const agentRealtimeAudioChunkType = "meshagent.agent.realtime_audio.chunk";
+export const agentRealtimeAudioCommitType = "meshagent.agent.realtime_audio.commit";
+export const agentThreadStartType = "meshagent.agent.thread.start";
+export const agentThreadStartedType = "meshagent.agent.thread.started";
+export const agentThreadLoadedType = "meshagent.agent.thread.loaded";
+export const agentThreadStartRejectedType = "meshagent.agent.thread.start.rejected";
+export const agentThreadOpenType = "meshagent.agent.thread.open";
+export const agentThreadCloseType = "meshagent.agent.thread.close";
+export const agentParticipantConnectType = "meshagent.agent.participant.connect";
+export const agentParticipantDisconnectType = "meshagent.agent.participant.disconnect";
+export const agentThreadDeleteType = "meshagent.agent.thread.delete";
+export const agentThreadRenameType = "meshagent.agent.thread.rename";
+export const agentThreadListType = "meshagent.agent.thread.list";
+export const agentThreadListedType = "meshagent.agent.thread.listed";
+export const agentThreadCreatedType = "meshagent.agent.thread.created";
+export const agentThreadUpdatedType = "meshagent.agent.thread.updated";
+export const agentThreadDeletedType = "meshagent.agent.thread.deleted";
+export const agentCapabilitiesRequestType = "meshagent.agent.capabilities_request";
+export const agentCapabilitiesResponseType = "meshagent.agent.capabilities_response";
+export const agentModelsRequestType = "meshagent.agent.models.request";
+export const agentModelsResponseType = "meshagent.agent.models.response";
+export const agentModelChangeType = "meshagent.agent.model.change";
+export const agentModelChangedType = "meshagent.agent.model.changed";
+export const agentThreadClearedType = "meshagent.agent.thread.cleared";
+export const agentTurnStartAcceptedType = "meshagent.agent.turn.start.accepted";
+export const agentTurnStartRejectedType = "meshagent.agent.turn.start.rejected";
+export const agentTurnInterruptAcceptedType = "meshagent.agent.turn.interrupt.accepted";
+export const agentTurnInterruptedType = "meshagent.agent.turn.interrupted";
+export const agentTurnSteerAcceptedType = "meshagent.agent.turn.steer.accepted";
+export const agentTurnSteeredType = "meshagent.agent.turn.steered";
+export const agentTurnSteerRejectedType = "meshagent.agent.turn.steer.rejected";
+export const agentTurnStartedType = "meshagent.agent.turn.started";
+export const agentTurnEndedType = "meshagent.agent.turn.ended";
+export const agentReasoningContentStartedType = "meshagent.agent.reasoning_content.started";
+export const agentReasoningContentDeltaType = "meshagent.agent.reasoning_content.delta";
+export const agentReasoningContentEndedType = "meshagent.agent.reasoning_content.ended";
+export const agentTextContentStartedType = "meshagent.agent.text_content.started";
+export const agentTextContentDeltaType = "meshagent.agent.text_content.delta";
+export const agentTextContentEndedType = "meshagent.agent.text_content.ended";
+export const agentFileContentStartedType = "meshagent.agent.file_content.started";
+export const agentFileContentDeltaType = "meshagent.agent.file_content.delta";
+export const agentFileContentEndedType = "meshagent.agent.file_content.ended";
+export const agentToolCallPendingType = "meshagent.agent.tool_call.pending";
+export const agentToolCallInProgressType = "meshagent.agent.tool_call.in_progress";
+export const agentToolCallStartedType = "meshagent.agent.tool_call.started";
+export const agentToolCallArgumentsDeltaType = "meshagent.agent.tool_call.arguments_delta";
+export const agentToolCallLogDeltaType = "meshagent.agent.tool_call.log_delta";
+export const agentToolCallEndedType = "meshagent.agent.tool_call.ended";
+export const agentToolCallApprovalRequestedType = "meshagent.agent.tool_call.approval_requested";
+export const agentClientToolCallRequestedType = "meshagent.agent.client_tool_call.requested";
+export const agentClientToolCallCancelledType = "meshagent.agent.client_tool_call.cancelled";
+export const agentSecretRequestedType = "meshagent.agent.secret.requested";
+export const agentThreadStatusType = "meshagent.agent.thread.status";
+export const agentConnectionStatusType = "meshagent.agent.connection.status";
+export const agentThreadEventType = "meshagent.agent.thread.event";
+export const agentImageGenerationStartedType = "meshagent.agent.image_generation.started";
+export const agentImageGenerationPartialType = "meshagent.agent.image_generation.partial";
+export const agentImageGenerationCompletedType = "meshagent.agent.image_generation.completed";
+export const agentImageGenerationFailedType = "meshagent.agent.image_generation.failed";
+export const agentAudioGenerationStartedType = "meshagent.agent.audio_generation.started";
+export const agentAudioGenerationDeltaType = "meshagent.agent.audio_generation.delta";
+export const agentAudioGenerationCompletedType = "meshagent.agent.audio_generation.completed";
+export const agentAudioGenerationFailedType = "meshagent.agent.audio_generation.failed";
+export const agentAudioTranscriptionStartedType = "meshagent.agent.audio_transcription.started";
+export const agentAudioTranscriptionDeltaType = "meshagent.agent.audio_transcription.delta";
+export const agentAudioTranscriptionCompletedType = "meshagent.agent.audio_transcription.completed";
+export const agentAudioTranscriptionFailedType = "meshagent.agent.audio_transcription.failed";
+export const agentAudioInputSpeechStartedType = "meshagent.agent.audio_input.speech_started";
+export const agentAudioInputSpeechEndedType = "meshagent.agent.audio_input.speech_ended";
+export const agentContextCompactedType = "meshagent.agent.context.compacted";
+export const agentUsageUpdatedType = "meshagent.agent.usage.updated";
+export const agentToolApproveType = "meshagent.agent.tool_call.approve";
+export const agentToolRejectType = "meshagent.agent.tool_call.reject";
+export const agentSecretResponseType = "meshagent.agent.secret.response";
+export const agentClientToolCallResponseType = "meshagent.agent.client_tool_call.response";
+const globalScope = globalThis;
+function hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+function paramValue(params, prop, jsonKey = prop) {
+    if (hasOwn(params, prop)) {
+        return params[prop];
+    }
+    return params[jsonKey];
+}
+function bytesToBase64(bytes) {
+    if (globalScope.Buffer != null) {
+        return globalScope.Buffer.from(bytes).toString("base64");
+    }
+    if (globalScope.btoa == null) {
+        throw new Error("base64 encoding is not available in this runtime");
+    }
+    let binary = "";
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return globalScope.btoa(binary);
+}
+function base64ToBytes(value) {
+    if (globalScope.Buffer != null) {
+        return Uint8Array.from(globalScope.Buffer.from(value, "base64"));
+    }
+    if (globalScope.atob == null) {
+        throw new Error("base64 decoding is not available in this runtime");
+    }
+    const binary = globalScope.atob(value);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requiredString(json, key) {
+    const value = json[key];
+    if (typeof value === "string") {
+        return value;
+    }
+    throw new TypeError(`missing string field '${key}'`);
+}
+function requiredInt(json, key) {
+    const value = intOrNull(json[key]);
+    if (value !== undefined) {
+        return value;
+    }
+    throw new TypeError(`missing integer field '${key}'`);
+}
+function requiredMap(json, key) {
+    const value = dynamicMapOrNull(json[key]);
+    if (value != null) {
+        return value;
+    }
+    throw new TypeError(`missing object field '${key}'`);
+}
+function stringOrNull(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function intOrNull(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return Math.trunc(value);
+    }
+    if (typeof value === "string" && value.trim() !== "") {
+        const parsed = Number.parseInt(value, 10);
+        return Number.isNaN(parsed) ? undefined : parsed;
+    }
+    return undefined;
+}
+function numOrNull(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim() !== "") {
+        const parsed = Number(value);
+        return Number.isNaN(parsed) ? undefined : parsed;
+    }
+    return undefined;
+}
+function bytesOrEmpty(value) {
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    if (Array.isArray(value) && value.every((entry) => typeof entry === "number")) {
+        return Uint8Array.from(value);
+    }
+    if (typeof value === "string" && value.length > 0) {
+        return base64ToBytes(value);
+    }
+    return new Uint8Array();
+}
+function dynamicMapOrNull(value) {
+    return isRecord(value) ? { ...value } : undefined;
+}
+function stringMap(value) {
+    const map = dynamicMapOrNull(value);
+    if (map == null) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(map).map(([key, entry]) => [key, String(entry)]));
+}
+function doubleMap(value) {
+    return doubleMapOrNull(value) ?? {};
+}
+function doubleMapOrNull(value) {
+    const map = dynamicMapOrNull(value);
+    if (map == null) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(map).map(([key, entry]) => [key, Number(entry)]));
+}
+function stringList(value, fallback = []) {
+    return stringListOrNull(value) ?? [...fallback];
+}
+function stringListOrNull(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    return value.map((entry) => String(entry));
+}
+function inputContentFromJson(value) {
+    const json = dynamicMapOrNull(value);
+    if (json == null) {
+        throw new TypeError("agent input content must be an object");
+    }
+    if (json.type === "text") {
+        return { type: "text", text: requiredString(json, "text") };
+    }
+    if (json.type === "file") {
+        return { type: "file", url: requiredString(json, "url") };
+    }
+    throw new TypeError("unsupported agent input content type");
+}
+function inputContentList(value) {
+    return inputContentListOrNull(value) ?? [];
+}
+function inputContentListOrNull(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    return value.map(inputContentFromJson);
+}
+function objectList(value, fromJson) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map((entry) => fromJson(requiredObjectValue(entry)));
+}
+function mapListOrNull(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    return value.map(requiredObjectValue);
+}
+function requiredObjectValue(value) {
+    const map = dynamicMapOrNull(value);
+    if (map == null) {
+        throw new TypeError("expected object");
+    }
+    return map;
+}
+function contentOrNull(value) {
+    if (isContent(value)) {
+        return value;
+    }
+    const map = dynamicMapOrNull(value);
+    return map == null ? undefined : unpackContent(packMessage(map));
+}
+function isContent(value) {
+    return value instanceof BinaryContent ||
+        value instanceof ControlContent ||
+        value instanceof EmptyContent ||
+        value instanceof ErrorContent ||
+        value instanceof FileContent ||
+        value instanceof JsonContent ||
+        value instanceof LinkContent ||
+        value instanceof TextContent;
+}
+function contentHeader(content) {
+    return unpackMessage(content.pack())[0];
+}
+function maybeToJson(value) {
+    return value != null && typeof value.toJson === "function" ? value.toJson() : value;
+}
+function contentToJson(value) {
+    return { ...value };
+}
+function objectOrNull(value, fromJson) {
+    const map = dynamicMapOrNull(value);
+    return map == null ? undefined : fromJson(map);
+}
+export class ToolChoice {
+    constructor({ toolkitName, toolName, toolkit_name, tool_name }) {
+        this.toolkitName = String(toolkitName ?? toolkit_name);
+        this.toolName = String(toolName ?? tool_name);
+    }
+    static fromJson(json) {
+        return new ToolChoice({ toolkitName: requiredString(json, "toolkit_name"), toolName: requiredString(json, "tool_name") });
+    }
+    toJson() {
+        return { toolkit_name: this.toolkitName, tool_name: this.toolName };
+    }
+}
+export class TurnMcpConfig {
+    constructor({ servers = [] } = {}) {
+        this.servers = mapListOrNull(servers) ?? [];
+    }
+    static fromJson(json) {
+        return new TurnMcpConfig({ servers: mapListOrNull(json.servers) ?? [] });
+    }
+    toJson() {
+        return { servers: this.servers };
+    }
+}
+export class ClientToolkitDescription {
+    constructor({ name, title, description, inputSchema, input_schema }) {
+        this.name = String(name);
+        this.title = stringOrNull(title);
+        this.description = stringOrNull(description);
+        this.inputSchema = dynamicMapOrNull(inputSchema ?? input_schema) ?? {};
+    }
+    static fromJson(json) {
+        return new ClientToolkitDescription({
+            name: requiredString(json, "name"),
+            title: stringOrNull(json.title),
+            description: stringOrNull(json.description),
+            inputSchema: dynamicMapOrNull(json.input_schema ?? json.inputSchema) ?? requiredMap(json, "input_schema"),
+        });
+    }
+    toJson() {
+        return {
+            name: this.name,
+            ...(this.title != null ? { title: this.title } : {}),
+            ...(this.description != null ? { description: this.description } : {}),
+            input_schema: this.inputSchema,
+        };
+    }
+}
+export class TurnToolkitConfig {
+    constructor({ clientOptions, client_options } = {}) {
+        this.clientOptions = dynamicMapOrNull(clientOptions ?? client_options);
+    }
+    static fromJson(json) {
+        return new TurnToolkitConfig({ clientOptions: dynamicMapOrNull(json.client_options) });
+    }
+    toJson() {
+        return this.clientOptions == null ? {} : { client_options: this.clientOptions };
+    }
+}
+function toolkitsOrNull(value) {
+    const map = dynamicMapOrNull(value);
+    if (map == null) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(map).map(([key, entry]) => [key, TurnToolkitConfig.fromJson(requiredObjectValue(entry))]));
+}
+function toolkitsToJson(value) {
+    return value == null ? undefined : Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, entry.toJson()]));
+}
+function turnMcpConfigOrNull(value) {
+    return objectOrNull(value, TurnMcpConfig.fromJson);
+}
+export class AgentAudioFormat {
+    constructor({ type = "audio/pcm", sampleRate, sample_rate, bitrate } = {}) {
+        this.type = String(type);
+        this.sampleRate = intOrNull(sampleRate ?? sample_rate);
+        this.bitrate = intOrNull(bitrate);
+    }
+    static fromJson(json) {
+        return new AgentAudioFormat({
+            type: stringOrNull(json.type) ?? "audio/pcm",
+            sampleRate: intOrNull(json.sample_rate),
+            bitrate: intOrNull(json.bitrate),
+        });
+    }
+    toJson() {
+        return {
+            type: this.type,
+            ...(this.sampleRate !== undefined ? { sample_rate: this.sampleRate } : {}),
+            ...(this.bitrate !== undefined ? { bitrate: this.bitrate } : {}),
+        };
+    }
+}
+function audioFormatOrNull(value) {
+    return objectOrNull(value, AgentAudioFormat.fromJson);
+}
+function audioFormatOrDefault(value) {
+    return audioFormatOrNull(value) ?? new AgentAudioFormat();
+}
+export class AgentError {
+    constructor({ message, code }) {
+        this.message = message;
+        this.code = code;
+    }
+    static fromJson(json) {
+        return new AgentError({ message: requiredString(json, "message"), code: stringOrNull(json.code) });
+    }
+    toJson() {
+        return { message: this.message, ...(this.code != null ? { code: this.code } : {}) };
+    }
+}
+export class ToolkitToolCapabilities {
+    constructor({ name, title, description }) {
+        this.name = String(name);
+        this.title = stringOrNull(title);
+        this.description = stringOrNull(description);
+    }
+    static fromJson(json) {
+        return new ToolkitToolCapabilities({
+            name: requiredString(json, "name"),
+            title: stringOrNull(json.title),
+            description: stringOrNull(json.description),
+        });
+    }
+    toJson() {
+        return {
+            name: this.name,
+            ...(this.title != null ? { title: this.title } : {}),
+            ...(this.description != null ? { description: this.description } : {}),
+        };
+    }
+}
+export class ToolkitCapabilities {
+    constructor(params) {
+        this.name = String(params.name);
+        this.title = stringOrNull(params.title);
+        this.description = stringOrNull(params.description);
+        this.thumbnailUrl = stringOrNull(params.thumbnailUrl ?? params.thumbnail_url);
+        this.rules = stringList(params.rules);
+        this.clientOptions = dynamicMapOrNull(params.clientOptions ?? params.client_options);
+        this.hidden = params.hidden === true;
+        this.tools = Array.isArray(params.tools) ? params.tools.map((entry) => entry instanceof ToolkitToolCapabilities ? entry : ToolkitToolCapabilities.fromJson(requiredObjectValue(entry))) : [];
+    }
+    static fromJson(json) {
+        return new ToolkitCapabilities(json);
+    }
+    toJson() {
+        return {
+            name: this.name,
+            ...(this.title != null ? { title: this.title } : {}),
+            ...(this.description != null ? { description: this.description } : {}),
+            ...(this.thumbnailUrl != null ? { thumbnail_url: this.thumbnailUrl } : {}),
+            rules: this.rules,
+            ...(this.clientOptions != null ? { client_options: this.clientOptions } : {}),
+            hidden: this.hidden,
+            tools: this.tools.map((entry) => entry.toJson()),
+        };
+    }
+}
+export class AgentModelInfo {
+    constructor(params) {
+        this.name = String(params.name);
+        this.friendlyName = stringOrNull(params.friendlyName ?? params.friendly_name);
+        this.description = stringOrNull(params.description);
+        this.contextWindow = intOrNull(params.contextWindow ?? params.context_window);
+        this.pricing = doubleMapOrNull(params.pricing);
+        this.modalities = stringList(params.modalities, ["text"]);
+        this.availableVoices = stringList(params.availableVoices ?? params.available_voices);
+        this.defaultOutputVoice = stringOrNull(params.defaultOutputVoice ?? params.default_output_voice);
+        this.inputFormat = params.inputFormat instanceof AgentAudioFormat ? params.inputFormat : audioFormatOrNull(params.inputFormat ?? params.input_format);
+        this.outputFormat = params.outputFormat instanceof AgentAudioFormat ? params.outputFormat : audioFormatOrNull(params.outputFormat ?? params.output_format);
+        this.turnDetection = stringOrNull(params.turnDetection ?? params.turn_detection);
+        this.realtimeProtocols = stringList(params.realtimeProtocols ?? params.realtime_protocols);
+        this.active = params.active === true;
+    }
+    static fromJson(json) {
+        return new AgentModelInfo(json);
+    }
+    toJson() {
+        return {
+            name: this.name,
+            ...(this.friendlyName != null ? { friendly_name: this.friendlyName } : {}),
+            ...(this.description != null ? { description: this.description } : {}),
+            ...(this.contextWindow != null ? { context_window: this.contextWindow } : {}),
+            ...(this.pricing != null ? { pricing: this.pricing } : {}),
+            modalities: this.modalities,
+            available_voices: this.availableVoices,
+            ...(this.defaultOutputVoice != null ? { default_output_voice: this.defaultOutputVoice } : {}),
+            ...(this.inputFormat != null ? { input_format: this.inputFormat.toJson() } : {}),
+            ...(this.outputFormat != null ? { output_format: this.outputFormat.toJson() } : {}),
+            ...(this.turnDetection != null ? { turn_detection: this.turnDetection } : {}),
+            realtime_protocols: this.realtimeProtocols,
+            active: this.active,
+        };
+    }
+}
+export class AgentProviderInfo {
+    constructor(params) {
+        this.name = String(params.name);
+        this.friendlyName = String(params.friendlyName ?? params.friendly_name);
+        this.description = stringOrNull(params.description);
+        this.defaultModel = String(params.defaultModel ?? params.default_model);
+        this.models = Array.isArray(params.models) ? params.models.map((entry) => entry instanceof AgentModelInfo ? entry : AgentModelInfo.fromJson(requiredObjectValue(entry))) : [];
+    }
+    static fromJson(json) {
+        return new AgentProviderInfo(json);
+    }
+    toJson() {
+        return {
+            name: this.name,
+            friendly_name: this.friendlyName,
+            ...(this.description != null ? { description: this.description } : {}),
+            default_model: this.defaultModel,
+            models: this.models.map((entry) => entry.toJson()),
+        };
+    }
+}
+export class AgentThreadListEntry {
+    constructor(params) {
+        this.path = String(params.path);
+        this.name = String(params.name ?? "");
+        this.createdAt = String(params.createdAt ?? params.created_at ?? "");
+        this.modifiedAt = String(params.modifiedAt ?? params.modified_at ?? "");
+    }
+    static fromJson(json) {
+        return new AgentThreadListEntry({
+            path: requiredString(json, "path"),
+            name: stringOrNull(json.name) ?? "",
+            createdAt: stringOrNull(json.created_at) ?? "",
+            modifiedAt: stringOrNull(json.modified_at) ?? "",
+        });
+    }
+    toJson() {
+        return {
+            path: this.path,
+            name: this.name,
+            created_at: this.createdAt,
+            modified_at: this.modifiedAt,
+        };
+    }
+}
+export class AgentRealtimeConnectionInfo {
+    constructor(params) {
+        this.protocol = String(params.protocol);
+        this.url = String(params.url);
+        this.headers = stringMap(params.headers);
+        this.webOnlyProtocol = stringOrNull(params.webOnlyProtocol ?? params.web_only_protocol);
+    }
+    static fromJson(json) {
+        return new AgentRealtimeConnectionInfo({
+            protocol: requiredString(json, "protocol"),
+            url: requiredString(json, "url"),
+            headers: stringMap(json.headers),
+            webOnlyProtocol: stringOrNull(json.web_only_protocol),
+        });
+    }
+    toJson() {
+        return {
+            protocol: this.protocol,
+            url: this.url,
+            headers: this.headers,
+            ...(this.webOnlyProtocol != null ? { web_only_protocol: this.webOnlyProtocol } : {}),
+        };
+    }
+}
+export class AgentToolCallLogLine {
+    constructor({ source, text }) {
+        this.source = String(source);
+        this.text = String(text);
+    }
+    static fromJson(json) {
+        return new AgentToolCallLogLine({ source: requiredString(json, "source"), text: requiredString(json, "text") });
+    }
+    toJson() {
+        return { source: this.source, text: this.text };
+    }
+}
+export class AgentGeneratedImage {
+    constructor(params = {}) {
+        this.uri = stringOrNull(params.uri);
+        this.mimeType = stringOrNull(params.mimeType ?? params.mime_type);
+        this.createdAt = stringOrNull(params.createdAt ?? params.created_at);
+        this.createdBy = stringOrNull(params.createdBy ?? params.created_by);
+        this.width = numOrNull(params.width);
+        this.height = numOrNull(params.height);
+        this.status = stringOrNull(params.status);
+    }
+    static fromJson(json) {
+        return new AgentGeneratedImage(json);
+    }
+    toJson() {
+        return omitUndefined({
+            uri: this.uri,
+            mime_type: this.mimeType,
+            created_at: this.createdAt,
+            created_by: this.createdBy,
+            width: this.width,
+            height: this.height,
+            status: this.status,
+        });
+    }
+}
+export class AgentGeneratedAudio {
+    constructor(params = {}) {
+        this.uri = stringOrNull(params.uri);
+        this.mimeType = stringOrNull(params.mimeType ?? params.mime_type);
+        this.createdAt = stringOrNull(params.createdAt ?? params.created_at);
+        this.createdBy = stringOrNull(params.createdBy ?? params.created_by);
+        this.status = stringOrNull(params.status);
+        this.transcript = stringOrNull(params.transcript);
+    }
+    static fromJson(json) {
+        return new AgentGeneratedAudio(json);
+    }
+    toJson() {
+        return omitUndefined({
+            uri: this.uri,
+            mime_type: this.mimeType,
+            created_at: this.createdAt,
+            created_by: this.createdBy,
+            status: this.status,
+            transcript: this.transcript,
+        });
+    }
+}
+export class AgentContextWindowUsage {
+    constructor(params) {
+        this.usedTokens = Number(params.usedTokens ?? params.used_tokens);
+        this.totalTokens = intOrNull(params.totalTokens ?? params.total_tokens);
+        this.compactionMode = stringOrNull(params.compactionMode ?? params.compaction_mode);
+        this.compactionThreshold = intOrNull(params.compactionThreshold ?? params.compaction_threshold);
+    }
+    static fromJson(json) {
+        return new AgentContextWindowUsage({
+            usedTokens: requiredInt(json, "used_tokens"),
+            totalTokens: intOrNull(json.total_tokens),
+            compactionMode: stringOrNull(json.compaction_mode),
+            compactionThreshold: intOrNull(json.compaction_threshold),
+        });
+    }
+    toJson() {
+        return omitUndefined({
+            used_tokens: this.usedTokens,
+            total_tokens: this.totalTokens,
+            compaction_mode: this.compactionMode,
+            compaction_threshold: this.compactionThreshold,
+        });
+    }
+}
+function omitUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+export class AgentMessage {
+    constructor({ type, messageId, message_id, senderName, sender_name }) {
+        this.type = String(type);
+        const resolvedMessageId = stringOrNull(messageId ?? message_id)?.trim();
+        this.messageId = resolvedMessageId == null || resolvedMessageId.length === 0 ? uuidv4() : resolvedMessageId;
+        this.senderName = stringOrNull(senderName ?? sender_name);
+    }
+    toJson() {
+        return {
+            type: this.type,
+            message_id: this.messageId,
+            ...(this.senderName != null ? { sender_name: this.senderName } : {}),
+        };
+    }
+    static fromJson(json) {
+        const type = json.type;
+        if (typeof type !== "string" || type.trim() === "") {
+            throw new TypeError("missing string field 'type'");
+        }
+        const ctor = messageConstructors[type];
+        if (ctor == null) {
+            throw new TypeError(`unsupported agent message type '${type}'`);
+        }
+        return ctor.fromJson(json);
+    }
+}
+export class AgentThreadMessage extends AgentMessage {
+    constructor(params) {
+        super(params);
+        this.threadId = String(paramValue(params, "threadId", "thread_id"));
+    }
+    toJson() {
+        return { ...super.toJson(), thread_id: this.threadId };
+    }
+}
+export class AgentLLMMessage extends AgentThreadMessage {
+    constructor(params) {
+        super(params);
+        this.provider = stringOrNull(params.provider);
+        this.model = stringOrNull(params.model);
+    }
+    toJson() {
+        return {
+            ...super.toJson(),
+            ...(this.provider != null ? { provider: this.provider } : {}),
+            ...(this.model != null ? { model: this.model } : {}),
+        };
+    }
+}
+const messageConstructors = {};
+function register(type, ctor) {
+    messageConstructors[type] = ctor;
+    return ctor;
+}
+function makeMessageClass({ type, base = "message", fields = [], }) {
+    const Parent = base === "llm" ? AgentLLMMessage : base === "thread" ? AgentThreadMessage : AgentMessage;
+    return register(type, class extends Parent {
+        constructor(params = {}) {
+            super({ ...params, type });
+            for (const field of fields) {
+                let value = paramValue(params, field.prop, field.json);
+                if (value === undefined && field.default != null) {
+                    value = field.default(params);
+                }
+                if (value !== undefined && field.from != null) {
+                    value = field.from(value, params);
+                }
+                this[field.prop] = value;
+            }
+        }
+        static fromJson(json) {
+            const params = {
+                messageId: stringOrNull(json.message_id),
+                senderName: stringOrNull(json.sender_name),
+            };
+            if (base !== "message") {
+                params.threadId = requiredString(json, "thread_id");
+            }
+            if (base === "llm") {
+                params.provider = stringOrNull(json.provider);
+                params.model = stringOrNull(json.model);
+            }
+            for (const field of fields) {
+                if (field.required) {
+                    if (field.from != null) {
+                        params[field.prop] = field.from(json[field.json], json);
+                    }
+                    else if (typeof json[field.json] === "string") {
+                        params[field.prop] = requiredString(json, field.json);
+                    }
+                    else if (typeof json[field.json] === "number") {
+                        params[field.prop] = json[field.json];
+                    }
+                    else {
+                        params[field.prop] = requiredMap(json, field.json);
+                    }
+                }
+                else if (hasOwn(json, field.json)) {
+                    params[field.prop] = field.from != null ? field.from(json[field.json], json) : json[field.json];
+                }
+                else if (field.default != null) {
+                    params[field.prop] = field.default(json);
+                }
+            }
+            return new this(params);
+        }
+        toJson() {
+            const json = super.toJson();
+            for (const field of fields) {
+                const value = this[field.prop];
+                if (value === undefined && !field.always) {
+                    continue;
+                }
+                if (value === undefined) {
+                    json[field.json] = value;
+                }
+                else if (field.to != null) {
+                    const encoded = field.to(value);
+                    if (encoded !== undefined || field.always) {
+                        json[field.json] = encoded;
+                    }
+                }
+                else {
+                    json[field.json] = maybeToJson(value);
+                }
+            }
+            return json;
+        }
+    });
+}
+const s = (prop, json = snake(prop), required = false) => ({
+    prop,
+    json,
+    required,
+    from: (value) => {
+        const parsed = stringOrNull(value);
+        if (required && parsed == null) {
+            throw new TypeError(`missing string field '${json}'`);
+        }
+        return parsed;
+    },
+});
+const i = (prop, json = snake(prop), required = false) => ({
+    prop,
+    json,
+    required,
+    from: (value) => {
+        const parsed = intOrNull(value);
+        if (required && parsed == null) {
+            throw new TypeError(`missing integer field '${json}'`);
+        }
+        return parsed;
+    },
+});
+const n = (prop, json = snake(prop)) => ({ prop, json, from: numOrNull });
+const m = (prop, json = snake(prop), required = false) => ({
+    prop,
+    json,
+    required,
+    from: (value) => {
+        const parsed = dynamicMapOrNull(value);
+        if (required && parsed == null) {
+            throw new TypeError(`missing object field '${json}'`);
+        }
+        return parsed;
+    },
+});
+const sl = (prop, json = snake(prop), fallback, always = false) => ({
+    prop,
+    json,
+    from: (value) => fallback == null ? stringListOrNull(value) : stringList(value, fallback),
+    default: fallback == null ? undefined : () => [...fallback],
+    always,
+});
+const obj = (prop, json, fromJson, required = false) => ({
+    prop,
+    json,
+    required,
+    from: (value) => {
+        const parsed = objectOrNull(value, fromJson);
+        if (required && parsed == null) {
+            throw new TypeError(`missing object field '${json}'`);
+        }
+        return parsed;
+    },
+    to: maybeToJson,
+});
+const objList = (prop, json, fromJson, always = false) => ({
+    prop,
+    json,
+    from: (value) => objectList(value, fromJson),
+    default: always ? () => [] : undefined,
+    always,
+    to: (value) => value.map(maybeToJson),
+});
+const contentList = (prop = "content", optional = false) => ({
+    prop,
+    json: "content",
+    from: optional ? inputContentListOrNull : inputContentList,
+    default: optional ? undefined : () => [],
+    always: !optional,
+    to: (value) => value.map(contentToJson),
+});
+const bytesField = (prop = "data") => ({
+    prop,
+    json: prop,
+    from: bytesOrEmpty,
+    default: () => new Uint8Array(),
+    to: (value) => value.length > 0 ? bytesToBase64(value) : undefined,
+});
+const audioFormat = (prop, json = snake(prop), requiredDefault = false) => ({
+    prop,
+    json,
+    from: requiredDefault ? audioFormatOrDefault : audioFormatOrNull,
+    default: requiredDefault ? () => new AgentAudioFormat() : undefined,
+    always: requiredDefault,
+    to: maybeToJson,
+});
+function snake(value) {
+    return value.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`);
+}
+const turnOptions = [
+    s("turnId"),
+    contentList("content"),
+    s("provider"),
+    s("model"),
+    s("voice"),
+    sl("outputModalities"),
+    s("instructions"),
+    { prop: "mcp", json: "mcp", from: turnMcpConfigOrNull, to: maybeToJson },
+    objList("clientToolkits", "client_toolkits", ClientToolkitDescription.fromJson),
+    { prop: "toolkits", json: "toolkits", from: toolkitsOrNull, to: toolkitsToJson },
+    obj("toolChoice", "tool_choice", ToolChoice.fromJson),
+];
+const contentPart = [s("turnId", "turn_id", true), s("itemId", "item_id", true)];
+const responsePart = [...contentPart, s("responseId"), i("contentIndex")];
+const toolState = [
+    ...contentPart,
+    { prop: "namespace", json: "namespace", from: (value) => stringOrNull(value) ?? "meshagent", default: () => "meshagent", always: true },
+    s("callId"),
+    s("toolkit", "toolkit", true),
+    s("tool", "tool", true),
+    m("arguments"),
+    i("argumentBytes"),
+];
+const imageGeneration = [
+    ...contentPart,
+    s("callId"),
+    { prop: "toolkit", json: "toolkit", from: (value) => stringOrNull(value) ?? "image_generation", default: () => "image_generation", always: true },
+    { prop: "tool", json: "tool", from: (value) => stringOrNull(value) ?? "image_generation", default: () => "image_generation", always: true },
+    m("arguments"),
+];
+export const StartThread = makeMessageClass({
+    type: agentThreadStartType,
+    fields: [
+        contentList("content", true),
+        s("name"),
+        s("realtimeProtocol"),
+        s("provider"),
+        s("model"),
+        s("voice"),
+        sl("outputModalities"),
+        s("instructions"),
+        { prop: "mcp", json: "mcp", from: turnMcpConfigOrNull, to: maybeToJson },
+        objList("clientToolkits", "client_toolkits", ClientToolkitDescription.fromJson),
+        { prop: "toolkits", json: "toolkits", from: toolkitsOrNull, to: toolkitsToJson },
+        obj("toolChoice", "tool_choice", ToolChoice.fromJson),
+    ],
+});
+export const TurnStart = makeMessageClass({ type: agentTurnStartType, base: "thread", fields: turnOptions });
+export const TurnSteer = makeMessageClass({ type: agentTurnSteerType, base: "thread", fields: [s("turnId", "turn_id", true), contentList("content")] });
+export const TurnInterrupt = makeMessageClass({ type: agentTurnInterruptType, base: "thread", fields: [s("turnId", "turn_id", true)] });
+export const AgentRealtimeAudioChunk = makeMessageClass({ type: agentRealtimeAudioChunkType, base: "thread", fields: [bytesField("data"), audioFormat("format", "format", true)] });
+export const AgentRealtimeAudioCommit = makeMessageClass({ type: agentRealtimeAudioCommitType, base: "thread", fields: [s("turnId"), s("text"), s("status"), s("transcriptionItemId")] });
+export const ClearThread = makeMessageClass({ type: agentThreadClearType, base: "thread" });
+export const OpenThread = makeMessageClass({ type: agentThreadOpenType, base: "thread", fields: [{ prop: "load", json: "load", from: (value) => typeof value === "boolean" ? value : undefined }, s("sinceTurn")] });
+export const CloseThread = makeMessageClass({ type: agentThreadCloseType, base: "thread" });
+export const ParticipantConnect = makeMessageClass({ type: agentParticipantConnectType, fields: [s("participantId"), s("participantName"), m("attributes")] });
+export const ParticipantDisconnect = makeMessageClass({ type: agentParticipantDisconnectType, fields: [s("participantId"), s("participantName"), s("reason")] });
+export const DeleteThread = makeMessageClass({ type: agentThreadDeleteType, base: "thread" });
+export const RenameThread = makeMessageClass({ type: agentThreadRenameType, base: "thread", fields: [s("name", "name", true)] });
+export const ListThreads = makeMessageClass({ type: agentThreadListType, fields: [{ prop: "limit", json: "limit", from: (value) => intOrNull(value) ?? 200, default: () => 200, always: true }, { prop: "offset", json: "offset", from: (value) => intOrNull(value) ?? 0, default: () => 0, always: true }] });
+export const ThreadsListed = makeMessageClass({ type: agentThreadListedType, fields: [s("sourceMessageId", "source_message_id", true), objList("threads", "threads", AgentThreadListEntry.fromJson, true), i("total"), i("offset"), i("limit")] });
+export const ThreadCreated = makeMessageClass({ type: agentThreadCreatedType, fields: [obj("thread", "thread", AgentThreadListEntry.fromJson, true)] });
+export const ThreadUpdated = makeMessageClass({ type: agentThreadUpdatedType, fields: [obj("thread", "thread", AgentThreadListEntry.fromJson, true)] });
+export const ThreadDeleted = makeMessageClass({ type: agentThreadDeletedType, fields: [s("path", "path", true)] });
+export const CapabilitiesRequest = makeMessageClass({ type: agentCapabilitiesRequestType, base: "thread" });
+export const CapabilitiesResponse = makeMessageClass({ type: agentCapabilitiesResponseType, base: "thread", fields: [s("sourceMessageId", "source_message_id", true), s("version", "version", true), objList("toolkits", "toolkits", ToolkitCapabilities.fromJson, true)] });
+export const ModelsRequest = makeMessageClass({ type: agentModelsRequestType });
+export const ModelsResponse = makeMessageClass({ type: agentModelsResponseType, fields: [s("sourceMessageId", "source_message_id", true), objList("providers", "providers", AgentProviderInfo.fromJson, true)] });
+export const ChangeModel = makeMessageClass({ type: agentModelChangeType, base: "thread", fields: [s("provider"), s("model"), s("voice")] });
+export const AgentModelChanged = makeMessageClass({ type: agentModelChangedType, base: "thread", fields: [s("sourceMessageId"), s("provider", "provider", true), s("model", "model", true), s("voice"), audioFormat("inputFormat"), audioFormat("outputFormat"), s("turnDetection"), sl("outputModalities", "output_modalities", ["text"], true), sl("realtimeProtocols", "realtime_protocols", [], true)] });
+export const ThreadCleared = makeMessageClass({ type: agentThreadClearedType, base: "thread", fields: [s("sourceMessageId", "source_message_id", true)] });
+export const TurnStartAccepted = makeMessageClass({ type: agentTurnStartAcceptedType, base: "thread", fields: [s("turnId"), s("sourceMessageId", "source_message_id", true), contentList("content")] });
+export const TurnStartRejected = makeMessageClass({ type: agentTurnStartRejectedType, base: "thread", fields: [s("sourceMessageId", "source_message_id", true), obj("error", "error", AgentError.fromJson, true)] });
+export const TurnInterruptAccepted = makeMessageClass({ type: agentTurnInterruptAcceptedType, base: "thread", fields: [s("turnId", "turn_id", true), s("sourceMessageId", "source_message_id", true)] });
+export const TurnInterrupted = makeMessageClass({ type: agentTurnInterruptedType, base: "thread", fields: [s("turnId", "turn_id", true), s("sourceMessageId", "source_message_id", true)] });
+export const TurnSteerAccepted = makeMessageClass({ type: agentTurnSteerAcceptedType, base: "thread", fields: [s("turnId", "turn_id", true), s("sourceMessageId", "source_message_id", true), contentList("content")] });
+export const TurnSteered = makeMessageClass({ type: agentTurnSteeredType, base: "thread", fields: [s("turnId", "turn_id", true), s("sourceMessageId", "source_message_id", true)] });
+export const TurnSteerRejected = makeMessageClass({ type: agentTurnSteerRejectedType, base: "thread", fields: [s("turnId", "turn_id", true), s("sourceMessageId", "source_message_id", true), obj("error", "error", AgentError.fromJson, true)] });
+export const TurnStarted = makeMessageClass({ type: agentTurnStartedType, base: "thread", fields: [s("turnId", "turn_id", true), s("sourceMessageId", "source_message_id", true)] });
+export const TurnEnded = makeMessageClass({ type: agentTurnEndedType, base: "thread", fields: [s("turnId", "turn_id", true), obj("error", "error", AgentError.fromJson)] });
+export const ThreadStarted = makeMessageClass({ type: agentThreadStartedType, fields: [s("sourceMessageId", "source_message_id", true), s("threadId", "thread_id", true), obj("realtimeConnection", "realtime_connection", AgentRealtimeConnectionInfo.fromJson)] });
+export const ThreadLoaded = makeMessageClass({ type: agentThreadLoadedType, base: "thread", fields: [s("sourceMessageId"), s("sinceTurn")] });
+export const ThreadStartRejected = makeMessageClass({ type: agentThreadStartRejectedType, fields: [s("sourceMessageId", "source_message_id", true), obj("error", "error", AgentError.fromJson, true)] });
+export const AgentReasoningContentStarted = makeMessageClass({ type: agentReasoningContentStartedType, base: "llm", fields: contentPart });
+export const AgentReasoningContentDelta = makeMessageClass({ type: agentReasoningContentDeltaType, base: "llm", fields: [...contentPart, s("text", "text", true)] });
+export const AgentReasoningContentEnded = makeMessageClass({ type: agentReasoningContentEndedType, base: "llm", fields: contentPart });
+export const AgentTextContentStarted = makeMessageClass({ type: agentTextContentStartedType, base: "llm", fields: [...contentPart, s("phase")] });
+export const AgentTextContentDelta = makeMessageClass({ type: agentTextContentDeltaType, base: "llm", fields: [...contentPart, s("phase"), s("text", "text", true)] });
+export const AgentTextContentEnded = makeMessageClass({ type: agentTextContentEndedType, base: "llm", fields: [...contentPart, s("phase")] });
+export const AgentFileContentStarted = makeMessageClass({ type: agentFileContentStartedType, base: "llm", fields: contentPart });
+export const AgentFileContentDelta = makeMessageClass({ type: agentFileContentDeltaType, base: "llm", fields: [...contentPart, s("url", "url", true)] });
+export const AgentFileContentEnded = makeMessageClass({ type: agentFileContentEndedType, base: "llm", fields: contentPart });
+export const AgentToolCallPending = makeMessageClass({ type: agentToolCallPendingType, base: "llm", fields: toolState });
+export const AgentToolCallInProgress = makeMessageClass({ type: agentToolCallInProgressType, base: "llm", fields: toolState });
+export const AgentToolCallStarted = makeMessageClass({ type: agentToolCallStartedType, base: "llm", fields: toolState });
+export const AgentToolCallArgumentsDelta = makeMessageClass({ type: agentToolCallArgumentsDeltaType, base: "llm", fields: [...contentPart, { prop: "namespace", json: "namespace", from: (value) => stringOrNull(value) ?? "meshagent", default: () => "meshagent", always: true }, s("callId"), s("delta", "delta", true)] });
+export const AgentToolCallLogDelta = makeMessageClass({ type: agentToolCallLogDeltaType, base: "llm", fields: [...contentPart, { prop: "namespace", json: "namespace", from: (value) => stringOrNull(value) ?? "meshagent", default: () => "meshagent", always: true }, s("callId"), objList("lines", "lines", AgentToolCallLogLine.fromJson, true)] });
+export const AgentToolCallEnded = makeMessageClass({ type: agentToolCallEndedType, base: "llm", fields: [...contentPart, { prop: "namespace", json: "namespace", from: (value) => stringOrNull(value) ?? "meshagent", default: () => "meshagent", always: true }, s("callId"), s("toolkit"), s("tool"), { prop: "result", json: "result", from: contentOrNull, to: contentHeader }, obj("error", "error", AgentError.fromJson)] });
+export const AgentToolCallApprovalRequested = makeMessageClass({ type: agentToolCallApprovalRequestedType, base: "llm", fields: toolState.filter((field) => field.prop !== "argumentBytes") });
+export const AgentSecretRequested = makeMessageClass({ type: agentSecretRequestedType, base: "llm", fields: [...contentPart, s("requestId", "request_id", true), s("name", "name", true), s("scope")] });
+export const AgentClientToolCallRequested = makeMessageClass({ type: agentClientToolCallRequestedType, base: "llm", fields: [...contentPart, s("requestId", "request_id", true), s("toolkit", "toolkit", true), s("tool", "tool", true), m("arguments", "arguments", true)] });
+export const AgentClientToolCallCancelled = makeMessageClass({ type: agentClientToolCallCancelledType, base: "llm", fields: [...contentPart, s("requestId", "request_id", true), s("reason")] });
+export const AgentThreadStatus = makeMessageClass({ type: agentThreadStatusType, base: "thread", fields: [s("status"), s("mode"), s("startedAt"), s("turnId"), s("pendingItemId"), i("totalBytes"), i("linesAdded"), i("linesRemoved")] });
+export const AgentConnectionStatus = makeMessageClass({ type: agentConnectionStatusType, fields: [s("status", "status", true), s("message"), s("reason"), n("retryInSeconds")] });
+export const AgentThreadEvent = makeMessageClass({ type: agentThreadEventType, base: "llm", fields: [m("event", "event", true)] });
+export const AgentImageGenerationStarted = makeMessageClass({ type: agentImageGenerationStartedType, base: "llm", fields: imageGeneration });
+export const AgentImageGenerationPartial = makeMessageClass({ type: agentImageGenerationPartialType, base: "llm", fields: [...imageGeneration, obj("image", "image", AgentGeneratedImage.fromJson), i("partialIndex")] });
+export const AgentImageGenerationCompleted = makeMessageClass({ type: agentImageGenerationCompletedType, base: "llm", fields: [...imageGeneration, objList("images", "images", AgentGeneratedImage.fromJson, true)] });
+export const AgentImageGenerationFailed = makeMessageClass({ type: agentImageGenerationFailedType, base: "llm", fields: [...imageGeneration, obj("error", "error", AgentError.fromJson)] });
+export const AgentAudioGenerationStarted = makeMessageClass({ type: agentAudioGenerationStartedType, base: "llm", fields: responsePart });
+export const AgentAudioGenerationDelta = makeMessageClass({ type: agentAudioGenerationDeltaType, base: "llm", fields: [...responsePart, bytesField("data"), s("mimeType"), audioFormat("outputFormat")] });
+export const AgentAudioGenerationCompleted = makeMessageClass({ type: agentAudioGenerationCompletedType, base: "llm", fields: [...responsePart, obj("audio", "audio", AgentGeneratedAudio.fromJson), audioFormat("outputFormat")] });
+export const AgentAudioGenerationFailed = makeMessageClass({ type: agentAudioGenerationFailedType, base: "llm", fields: [...responsePart, obj("error", "error", AgentError.fromJson)] });
+export const AgentAudioTranscriptionStarted = makeMessageClass({ type: agentAudioTranscriptionStartedType, base: "llm", fields: [...responsePart, s("role")] });
+export const AgentAudioTranscriptionDelta = makeMessageClass({ type: agentAudioTranscriptionDeltaType, base: "llm", fields: [...responsePart, s("role"), s("text", "text", true)] });
+export const AgentAudioTranscriptionCompleted = makeMessageClass({ type: agentAudioTranscriptionCompletedType, base: "llm", fields: [...responsePart, s("role"), s("text")] });
+export const AgentAudioTranscriptionFailed = makeMessageClass({ type: agentAudioTranscriptionFailedType, base: "llm", fields: [...responsePart, s("role"), obj("error", "error", AgentError.fromJson)] });
+export const AgentAudioInputSpeechStarted = makeMessageClass({ type: agentAudioInputSpeechStartedType, base: "thread", fields: [s("turnId", "turn_id", true), s("itemId"), i("audioStartMs")] });
+export const AgentAudioInputSpeechEnded = makeMessageClass({ type: agentAudioInputSpeechEndedType, base: "thread", fields: [s("turnId", "turn_id", true), s("itemId"), i("audioEndMs")] });
+export const AgentContextCompacted = makeMessageClass({ type: agentContextCompactedType, base: "thread", fields: [s("checkpointId", "checkpoint_id", true), s("path", "path", true), i("throughSequence", "through_sequence", true), s("createdAt"), { prop: "messages", json: "messages", from: mapListOrNull }] });
+export const AgentUsageUpdated = makeMessageClass({ type: agentUsageUpdatedType, base: "thread", fields: [s("turnId"), { prop: "usage", json: "usage", from: doubleMap, default: () => ({}), always: true }, obj("contextWindow", "context_window", AgentContextWindowUsage.fromJson, true)] });
+export const ApproveAgentToolCall = makeMessageClass({ type: agentToolApproveType, base: "thread", fields: [s("turnId", "turn_id", true), s("itemId", "item_id", true)] });
+export const RejectAgentToolCall = makeMessageClass({ type: agentToolRejectType, base: "thread", fields: [s("turnId", "turn_id", true), s("itemId", "item_id", true)] });
+export const AgentSecretResponse = makeMessageClass({ type: agentSecretResponseType, base: "thread", fields: [s("turnId", "turn_id", true), s("requestId", "request_id", true), s("value"), obj("error", "error", AgentError.fromJson)] });
+export const AgentClientToolCallResponse = makeMessageClass({ type: agentClientToolCallResponseType, base: "thread", fields: [s("turnId", "turn_id", true), s("requestId", "request_id", true), { prop: "response", json: "response", from: contentOrNull, to: contentHeader }] });
+export function agentInputContent({ text, attachments }) {
+    const content = [];
+    if (text.trim() !== "") {
+        content.push({ type: "text", text });
+    }
+    for (const attachment of attachments) {
+        const normalized = attachment.trim();
+        if (normalized !== "") {
+            content.push({ type: "file", url: normalized });
+        }
+    }
+    return content;
+}