@meshagent/meshagent-agents 0.43.0

package/CHANGELOG.md

@@ -0,0 +1,50 @@
+## [0.43.0]
+- Split LiveKit helpers into `@meshagent/meshagent-livekit-ts` and added `@meshagent/meshagent-node-ts` for room websocket proxying and room-connect helpers.
+- Updated `meshagent-ts` exports for ESM-aware resolution, moved LiveKit out of the core package, and added `RoomClient.withIAP()` and `WebSocketClientProtocol.withIAP()` for the new room-connect flow.
+- Room websocket auth now uses bearer headers on Node and `meshagent-room.` subprotocol tokens in the browser, and the agents/thread APIs now carry backend metadata and attachment-aware prompts.
+- React/auth/dev/tailwind packages now publish CJS main entries alongside ESM builds, and the new LiveKit package depends on `livekit-client@^2.15.5`.
+
+## [0.42.2]
+- Added `ContainerExitStatus`, `RoomContainerStats`, and published build image metadata to the TypeScript container client models.
+- Added `waitForExitStatus` while keeping `waitForExit` as the exit-code convenience wrapper.
+- Container list parsing now preserves image IDs, runtime stats, and exit-status metadata from API responses.
+
+## [0.42.1]
+- Stability
+
+## [0.42.0]
+- Added project lookup by key.
+- Container and room APIs now return structured `containerPort`/`hostPort` entries instead of integer port lists, which is a breaking response-shape change.
+- `ContainerSpec`, `PortSpec`, and `RoutePathSpec` now support `template`, `host_port`, and `stripPrefix`, and room service URL resolution uses `host_port` when available.
+- `createRoom` now serializes typed permissions, and container creation now accepts a `template` option.
+
+## [0.41.10]
+- Stability
+
+## [0.41.9]
+- Stability
+
+## [0.41.8]
+- Stability
+
+## [0.41.7]
+- Stability
+
+## [0.41.6]
+- Added convenience dataset helpers and toolkit-config support to the TypeScript SDK, expanding room- and dataset-aware workflows.
+- Extended the TypeScript storage client download URL API with an optional `download` flag so callers can request attachment-style links.
+- Updated the TypeScript agent/chat packages to support room shell and room storage toolkits with richer threaded chat behavior.
+- Improved Powerboards meetings with meeting previews, camera-grid handling, and video-chat collapse fixes.
+- Added syntax-highlighted file previews to the React UI, including `react-syntax-highlighter@^16.1.1` and `@types/react-syntax-highlighter@^15.5.13`.
+
+# Changelog
+
+## 0.41.0
+
+- Aligned TypeScript agent protocol models with the Dart 0.41.0 package, including thread list/lifecycle, connection status, client tool calls, secret responses, and MCP/client toolkit fields.
+- Added chat-session load state, sender-name propagation, explicit message IDs, omit-content starts, client toolkit forwarding, and agent-backed thread list storage.
+- Added room storage and room shell toolkit helpers.
+
+## 0.40.2
+
+- Initial TypeScript implementation mirroring `meshagent-agents-dart`.

package/LICENSE

@@ -0,0 +1 @@
+Apache-2.0

package/README.md

@@ -0,0 +1,206 @@
+# meshagent-agents-ts
+
+TypeScript agent chat session and transport helpers for Meshagent applications.
+
+It provides:
+
+- Agent message constants and JSON models for the Meshagent agent protocol.
+- Chat clients and thread sessions for sending turns over Meshagent room messaging.
+- Dataset helpers for thread lists and generated images.
+
+## Install
+
+```bash
+npm install @meshagent/meshagent-agents @meshagent/meshagent
+```
+
+In this repository workspace the package is available from `meshagent-agents-ts`.
+
+## Imports
+
+```ts
+import {
+  AgentMessage,
+  MessagingChatClient,
+  ImagesDataset,
+  DatasetThreadStorageRepository,
+  TurnStart,
+  agentInputContent,
+} from "@meshagent/meshagent-agents";
+```
+
+## Agent Messages
+
+Every protocol message is represented by a class with `toJson()` and can be parsed with `AgentMessage.fromJson(...)`.
+
+```ts
+import {
+  AgentMessage,
+  TurnStart,
+  agentInputContent,
+} from "@meshagent/meshagent-agents";
+
+const message = new TurnStart({
+  threadId: "dataset://threads/example",
+  content: agentInputContent({
+    text: "Summarize this file.",
+    attachments: ["dataset://assets/files/report.pdf"],
+  }),
+  provider: "openai",
+  model: "gpt-5.4",
+});
+
+const wirePayload = message.toJson();
+const parsed = AgentMessage.fromJson(wirePayload);
+```
+
+The package exports the message type constants as well, for example `agentTurnStartType`, `agentThreadStartedType`, and `agentToolCallApprovalRequestedType`.
+
+## Chat Client
+
+`MessagingChatClient` sends and receives agent protocol messages through a Meshagent `RoomClient` messaging channel. The target agent participant must advertise `supports_agent_messages: true`; optionally pass `agentName` to select one named agent.
+
+```ts
+import {
+  MessagingChatClient,
+  agentTextContentDeltaType,
+} from "@meshagent/meshagent-agents";
+import type { RoomClient } from "@meshagent/meshagent";
+
+const room: RoomClient = /* create and start your room client */;
+
+const chat = new MessagingChatClient({ room, agentName: "assistant" });
+await chat.start();
+
+const { session, threadPath, realtimeConnection } = await chat.startThread({
+  message: "Create a project plan.",
+  attachments: [],
+  provider: "openai",
+  model: "gpt-5.4",
+});
+
+console.log(threadPath, realtimeConnection);
+
+await session.sendText({
+  text: "Make it shorter and include risks.",
+  attachments: [],
+});
+
+for await (const event of chat.events) {
+  if (event.message.type === agentTextContentDeltaType) {
+    const delta = event.message as typeof event.message & { text: string };
+    process.stdout.write(delta.text);
+  }
+}
+```
+
+You can also open an existing thread directly:
+
+```ts
+const session = chat.openThread("dataset://threads/existing");
+
+await session.sendText({
+  text: "Continue from the last answer.",
+  attachments: [],
+});
+
+await session.interruptTurn("turn-id");
+await session.changeModel({ provider: "openai", model: "gpt-5.4" });
+await session.close();
+```
+
+`ChatThreadSession` tracks local pending inputs in `session.pendingInputs`. Pending input state is updated when accepted, started, steered, rejected, ended, or cleared messages arrive from the agent.
+
+## Custom Transports
+
+Use `BaseChatClient` if you want to send agent messages through another transport. Implement `sendAgentMessage(...)` and feed inbound messages back through `handleAgentMessage(...)`.
+
+```ts
+import {
+  AgentMessage,
+  BaseChatClient,
+} from "@meshagent/meshagent-agents";
+
+class MyChatClient extends BaseChatClient {
+  async sendAgentMessage(
+    message: AgentMessage,
+    options: { attachment?: Uint8Array; ignoreOffline?: boolean } = {},
+  ): Promise<void> {
+    await sendOverMyTransport(message.toJson(), options.attachment);
+  }
+}
+
+const client = new MyChatClient();
+const session = client.openThread("dataset://threads/custom");
+```
+
+## Thread List Storage
+
+`DatasetThreadStorageRepository` stores thread list metadata in a Meshagent dataset table. The URL format is `dataset://[namespace...]/table`.
+
+```ts
+import {
+  DatasetThreadStorageRepository,
+  ThreadListEntry,
+} from "@meshagent/meshagent-agents";
+
+const threads = new DatasetThreadStorageRepository({
+  room,
+  path: "dataset://agents/default/threads",
+});
+
+await threads.open();
+
+await threads.addOrUpdateThread(new ThreadListEntry({
+  path: "dataset://threads/thread-1",
+  name: "Planning",
+  createdAt: new Date().toISOString(),
+  modifiedAt: new Date().toISOString(),
+}));
+
+console.log(threads.entries());
+
+await threads.renameThread("dataset://threads/thread-1", "Launch Planning");
+await threads.deleteThread("dataset://threads/thread-1");
+await threads.close();
+```
+
+## Image Dataset
+
+`ImagesDataset` creates and writes to an `images` table with binary image data and metadata. `ImageDatasetClient` can read image records by ID or by `dataset://.../images?id=...` URI.
+
+```ts
+import {
+  ImagesDataset,
+  ImageDatasetClient,
+} from "@meshagent/meshagent-agents";
+
+const images = new ImagesDataset({
+  room,
+  namespace: ["agents", "default"],
+});
+
+const saved = await images.save({
+  data: pngBytes,
+  mimeType: "image/png",
+  createdBy: "assistant",
+  annotations: { prompt: "blue product sketch" },
+});
+
+const record = await images.readRecord(saved.id);
+console.log(record?.mimeType, record?.data.byteLength);
+
+const ref = ImageDatasetClient.datasetUriReference(
+  `dataset://agents/default/images?id=${saved.id}`,
+);
+console.log(ref.namespace, ref.table, ref.id);
+```
+
+## Development
+
+```bash
+npm run build
+npm test
+```
+
+The build emits ESM, Node CommonJS, and browser CommonJS outputs under `dist/`.

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

@@ -0,0 +1,343 @@
+import { type AgentInputContent } from "@meshagent/meshagent";
+export type AgentPayload = Record<string, unknown>;
+export 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";
+export declare const agentTurnInterruptType = "meshagent.agent.turn.interrupt";
+export declare const agentThreadClearType = "meshagent.agent.thread.clear";
+export declare const agentRealtimeAudioChunkType = "meshagent.agent.realtime_audio.chunk";
+export declare const agentRealtimeAudioCommitType = "meshagent.agent.realtime_audio.commit";
+export declare const agentThreadStartType = "meshagent.agent.thread.start";
+export declare const agentThreadStartedType = "meshagent.agent.thread.started";
+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 agentParticipantConnectType = "meshagent.agent.participant.connect";
+export declare const agentParticipantDisconnectType = "meshagent.agent.participant.disconnect";
+export declare const agentThreadDeleteType = "meshagent.agent.thread.delete";
+export declare const agentThreadRenameType = "meshagent.agent.thread.rename";
+export declare const agentThreadListType = "meshagent.agent.thread.list";
+export declare const agentThreadListedType = "meshagent.agent.thread.listed";
+export declare const agentThreadCreatedType = "meshagent.agent.thread.created";
+export declare const agentThreadUpdatedType = "meshagent.agent.thread.updated";
+export declare const agentThreadDeletedType = "meshagent.agent.thread.deleted";
+export declare const agentCapabilitiesRequestType = "meshagent.agent.capabilities_request";
+export declare const agentCapabilitiesResponseType = "meshagent.agent.capabilities_response";
+export declare const agentModelsRequestType = "meshagent.agent.models.request";
+export declare const agentModelsResponseType = "meshagent.agent.models.response";
+export declare const agentModelChangeType = "meshagent.agent.model.change";
+export declare const agentModelChangedType = "meshagent.agent.model.changed";
+export declare const agentThreadClearedType = "meshagent.agent.thread.cleared";
+export declare const agentTurnStartAcceptedType = "meshagent.agent.turn.start.accepted";
+export declare const agentTurnStartRejectedType = "meshagent.agent.turn.start.rejected";
+export declare const agentTurnInterruptAcceptedType = "meshagent.agent.turn.interrupt.accepted";
+export declare const agentTurnInterruptedType = "meshagent.agent.turn.interrupted";
+export declare const agentTurnSteerAcceptedType = "meshagent.agent.turn.steer.accepted";
+export declare const agentTurnSteeredType = "meshagent.agent.turn.steered";
+export declare const agentTurnSteerRejectedType = "meshagent.agent.turn.steer.rejected";
+export declare const agentTurnStartedType = "meshagent.agent.turn.started";
+export declare const agentTurnEndedType = "meshagent.agent.turn.ended";
+export declare const agentReasoningContentStartedType = "meshagent.agent.reasoning_content.started";
+export declare const agentReasoningContentDeltaType = "meshagent.agent.reasoning_content.delta";
+export declare const agentReasoningContentEndedType = "meshagent.agent.reasoning_content.ended";
+export declare const agentTextContentStartedType = "meshagent.agent.text_content.started";
+export declare const agentTextContentDeltaType = "meshagent.agent.text_content.delta";
+export declare const agentTextContentEndedType = "meshagent.agent.text_content.ended";
+export declare const agentFileContentStartedType = "meshagent.agent.file_content.started";
+export declare const agentFileContentDeltaType = "meshagent.agent.file_content.delta";
+export declare const agentFileContentEndedType = "meshagent.agent.file_content.ended";
+export declare const agentToolCallPendingType = "meshagent.agent.tool_call.pending";
+export declare const agentToolCallInProgressType = "meshagent.agent.tool_call.in_progress";
+export declare const agentToolCallStartedType = "meshagent.agent.tool_call.started";
+export declare const agentToolCallArgumentsDeltaType = "meshagent.agent.tool_call.arguments_delta";
+export declare const agentToolCallLogDeltaType = "meshagent.agent.tool_call.log_delta";
+export declare const agentToolCallEndedType = "meshagent.agent.tool_call.ended";
+export declare const agentToolCallApprovalRequestedType = "meshagent.agent.tool_call.approval_requested";
+export declare const agentClientToolCallRequestedType = "meshagent.agent.client_tool_call.requested";
+export declare const agentClientToolCallCancelledType = "meshagent.agent.client_tool_call.cancelled";
+export declare const agentSecretRequestedType = "meshagent.agent.secret.requested";
+export declare const agentThreadStatusType = "meshagent.agent.thread.status";
+export declare const agentConnectionStatusType = "meshagent.agent.connection.status";
+export declare const agentThreadEventType = "meshagent.agent.thread.event";
+export declare const agentImageGenerationStartedType = "meshagent.agent.image_generation.started";
+export declare const agentImageGenerationPartialType = "meshagent.agent.image_generation.partial";
+export declare const agentImageGenerationCompletedType = "meshagent.agent.image_generation.completed";
+export declare const agentImageGenerationFailedType = "meshagent.agent.image_generation.failed";
+export declare const agentAudioGenerationStartedType = "meshagent.agent.audio_generation.started";
+export declare const agentAudioGenerationDeltaType = "meshagent.agent.audio_generation.delta";
+export declare const agentAudioGenerationCompletedType = "meshagent.agent.audio_generation.completed";
+export declare const agentAudioGenerationFailedType = "meshagent.agent.audio_generation.failed";
+export declare const agentAudioTranscriptionStartedType = "meshagent.agent.audio_transcription.started";
+export declare const agentAudioTranscriptionDeltaType = "meshagent.agent.audio_transcription.delta";
+export declare const agentAudioTranscriptionCompletedType = "meshagent.agent.audio_transcription.completed";
+export declare const agentAudioTranscriptionFailedType = "meshagent.agent.audio_transcription.failed";
+export declare const agentAudioInputSpeechStartedType = "meshagent.agent.audio_input.speech_started";
+export declare const agentAudioInputSpeechEndedType = "meshagent.agent.audio_input.speech_ended";
+export declare const agentContextCompactedType = "meshagent.agent.context.compacted";
+export declare const agentUsageUpdatedType = "meshagent.agent.usage.updated";
+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";
+export declare class ToolChoice {
+    readonly toolkitName: string;
+    readonly toolName: string;
+    constructor({ toolkitName, toolName, toolkit_name, tool_name }: JsonMap);
+    static fromJson(json: JsonMap): ToolChoice;
+    toJson(): JsonMap;
+}
+export declare class TurnMcpConfig {
+    readonly servers: JsonMap[];
+    constructor({ servers }?: JsonMap);
+    static fromJson(json: JsonMap): TurnMcpConfig;
+    toJson(): JsonMap;
+}
+export declare class ClientToolkitDescription {
+    readonly name: string;
+    readonly title?: string;
+    readonly description?: string;
+    readonly inputSchema: JsonMap;
+    constructor({ name, title, description, inputSchema, input_schema }: JsonMap);
+    static fromJson(json: JsonMap): ClientToolkitDescription;
+    toJson(): JsonMap;
+}
+export declare class TurnToolkitConfig {
+    readonly clientOptions?: JsonMap;
+    constructor({ clientOptions, client_options }?: JsonMap);
+    static fromJson(json: JsonMap): TurnToolkitConfig;
+    toJson(): JsonMap;
+}
+export declare class AgentAudioFormat {
+    readonly type: string;
+    readonly sampleRate?: number;
+    readonly bitrate?: number;
+    constructor({ type, sampleRate, sample_rate, bitrate }?: JsonMap);
+    static fromJson(json: JsonMap): AgentAudioFormat;
+    toJson(): JsonMap;
+}
+export declare class AgentError {
+    readonly message: string;
+    readonly code?: string;
+    constructor({ message, code }: {
+        message: string;
+        code?: string;
+    });
+    static fromJson(json: JsonMap): AgentError;
+    toJson(): JsonMap;
+}
+export declare class ToolkitToolCapabilities {
+    readonly name: string;
+    readonly title?: string;
+    readonly description?: string;
+    constructor({ name, title, description }: JsonMap);
+    static fromJson(json: JsonMap): ToolkitToolCapabilities;
+    toJson(): JsonMap;
+}
+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);
+    static fromJson(json: JsonMap): ToolkitCapabilities;
+    toJson(): JsonMap;
+}
+export declare class AgentModelInfo {
+    readonly name: string;
+    readonly friendlyName?: string;
+    readonly description?: string;
+    readonly contextWindow?: number;
+    readonly pricing?: Record<string, number>;
+    readonly modalities: string[];
+    readonly availableVoices: string[];
+    readonly defaultOutputVoice?: string;
+    readonly inputFormat?: AgentAudioFormat;
+    readonly outputFormat?: AgentAudioFormat;
+    readonly turnDetection?: string;
+    readonly realtimeProtocols: string[];
+    readonly active: boolean;
+    constructor(params: JsonMap);
+    static fromJson(json: JsonMap): AgentModelInfo;
+    toJson(): JsonMap;
+}
+export declare class AgentProviderInfo {
+    readonly name: string;
+    readonly friendlyName: string;
+    readonly description?: string;
+    readonly defaultModel: string;
+    readonly models: AgentModelInfo[];
+    constructor(params: JsonMap);
+    static fromJson(json: JsonMap): AgentProviderInfo;
+    toJson(): JsonMap;
+}
+export declare class AgentThreadListEntry {
+    readonly path: string;
+    readonly name: string;
+    readonly createdAt: string;
+    readonly modifiedAt: string;
+    constructor(params: JsonMap);
+    static fromJson(json: JsonMap): AgentThreadListEntry;
+    toJson(): JsonMap;
+}
+export declare class AgentRealtimeConnectionInfo {
+    readonly protocol: string;
+    readonly url: string;
+    readonly headers: Record<string, string>;
+    readonly webOnlyProtocol?: string;
+    constructor(params: JsonMap);
+    static fromJson(json: JsonMap): AgentRealtimeConnectionInfo;
+    toJson(): JsonMap;
+}
+export declare class AgentToolCallLogLine {
+    readonly source: string;
+    readonly text: string;
+    constructor({ source, text }: JsonMap);
+    static fromJson(json: JsonMap): AgentToolCallLogLine;
+    toJson(): JsonMap;
+}
+export declare class AgentGeneratedImage {
+    readonly uri?: string;
+    readonly mimeType?: string;
+    readonly createdAt?: string;
+    readonly createdBy?: string;
+    readonly width?: number;
+    readonly height?: number;
+    readonly status?: string;
+    constructor(params?: JsonMap);
+    static fromJson(json: JsonMap): AgentGeneratedImage;
+    toJson(): JsonMap;
+}
+export declare class AgentGeneratedAudio {
+    readonly uri?: string;
+    readonly mimeType?: string;
+    readonly createdAt?: string;
+    readonly createdBy?: string;
+    readonly status?: string;
+    readonly transcript?: string;
+    constructor(params?: JsonMap);
+    static fromJson(json: JsonMap): AgentGeneratedAudio;
+    toJson(): JsonMap;
+}
+export declare class AgentContextWindowUsage {
+    readonly usedTokens: number;
+    readonly totalTokens?: number;
+    readonly compactionMode?: string;
+    readonly compactionThreshold?: number;
+    constructor(params: JsonMap);
+    static fromJson(json: JsonMap): AgentContextWindowUsage;
+    toJson(): JsonMap;
+}
+export declare abstract class AgentMessage {
+    [key: string]: any;
+    readonly type: string;
+    readonly messageId: string;
+    readonly senderName?: string;
+    protected constructor({ type, messageId, message_id, senderName, sender_name }: JsonMap);
+    toJson(): JsonMap;
+    static fromJson(json: JsonMap): AgentMessage;
+}
+export declare abstract class AgentThreadMessage extends AgentMessage {
+    readonly threadId: string;
+    protected constructor(params: JsonMap);
+    toJson(): JsonMap;
+}
+export declare abstract class AgentLLMMessage extends AgentThreadMessage {
+    readonly provider?: string;
+    readonly model?: string;
+    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 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 }: {
+    text: string;
+    attachments: string[];
+}): AgentInputContent[];
+export {};