@craftedxp/sdk-node 0.12.0 → 0.15.0

package/README.md

@@ -58,7 +58,7 @@ client.callTokens.revoke(tokenId)
 ```ts
 client.me.get()                                              // the org behind the sk_
 
-client.agents.create({ name, systemPrompt, ... })            // CRUD on agents
+client.agents.create({ type, name, systemPrompt, ... })      // CRUD on agents (type required)
 client.agents.list({ limit, cursor })
 client.agents.get(agentId)
 client.agents.update(agentId, patch)
@@ -88,6 +88,26 @@ client.rooms.transcript(roomId, { cursor, limit })
 client.rooms.end(roomId)
 ```
 
+## Agent types
+
+Every agent has a `type` set at creation and **immutable** thereafter (changing
+what an agent does means creating a new one). It gates which routes accept the
+agent:
+
+| `type`       | Does                                                      | Use with                                          |
+| ------------ | --------------------------------------------------------- | ------------------------------------------------- |
+| `assistant`  | 1:1 voice + text chat + learning mode (LLM + STT + TTS)   | `@craftedxp/voice-js/assistant`, text chat, calls |
+| `room`       | Hosts LiveKit rooms; per-speaker transcription + analysis | `client.rooms.*`, `@craftedxp/voice-js/room`      |
+| `transcribe` | 1:1 dictation, STT-only (agent never speaks)              | `@craftedxp/voice-js/transcribe`                  |
+
+```ts
+await client.agents.create({ type: 'assistant', name: 'Concierge', systemPrompt: '…' })
+```
+
+`type` is omitted from `AgentUpdateInput` — `agents.update` cannot change it.
+The legacy `canHostRooms` / `transcribeOnly` boolean flags are **removed**;
+sending them is a 400. Use `type: 'room'` / `type: 'transcribe'` instead.
+
 ## Multi-party video rooms
 
 Provision a hosted room from your backend; share the single returned link;
@@ -96,14 +116,17 @@ participants join with **video** in the browser via `@craftedxp/voice-js`
 per speaker — the human-to-human video call works regardless.
 
 ```ts
-// Backend — the agent must be allowed to host rooms. Enable it from code
-// (since 0.10.1) instead of the dashboard:
-await client.agents.update(agentId, { canHostRooms: true, roomMode: 'notes-only' })
-// (you can also pass canHostRooms/roomMode to `agents.create`.)
+// Backend — create a room-type agent (immutable; can't be flipped later).
+const agent = await client.agents.create({
+  type: 'room',
+  name: 'Notetaker',
+  systemPrompt: 'take notes',
+  roomMode: 'notes-only',
+})
 
 // Mint a room. Returns ONE shared joinToken + a joinUrl; the raw token is
 // returned once and never stored.
-const room = await client.rooms.create({ agentId, durationMin: 30 })
+const room = await client.rooms.create({ agentId: agent.agentId, durationMin: 30 })
 // → { roomId, status: 'provisioning', joinToken, joinUrl, expiresAt }
 
 // Hand `roomId` + `joinToken` to the browser. There, with @craftedxp/voice-js:
@@ -121,18 +144,82 @@ await client.rooms.end(room.roomId)
 A complete, runnable consumer app (backend + browser video UI) lives in
 [`examples/video-call`](../../examples/video-call).
 
-### Transcribe-only agents
+### Transcribe agents
+
+Create an agent with `type: 'transcribe'` for one that **listens but never
+speaks** — no TTS/LLM, no greeting; user turns stream back as `transcript`
+data-messages over the existing call/WebRTC transport. Useful for note-taking /
+dictation surfaces that reuse the agent + call-mint plumbing but want the agent
+silent. Pair it with `@craftedxp/voice-js/transcribe` on the client.
+
+```ts
+await client.agents.create({ type: 'transcribe', name: 'Scribe', systemPrompt: 'n/a' })
+```
+
+## Spaces (durable multi-party meeting spaces)
+
+A **space** is a stable join code in front of the rooms subsystem: create it once,
+share the code, and N participants each join with their own identity. Use this when
+you want a reusable, schedulable meeting link rather than a one-shot room.
+
+```ts
+import { PlatformClient, buildJoinUrl } from '@craftedxp/sdk-node'
+
+const platform = new PlatformClient({ apiKey: process.env.VOISSIA_SK_KEY! })
+
+// 1. Create a space (the agent must be type 'room').
+const space = await platform.spaces.create({ agentId: 'agt_room' })
+
+// 2. Build the participant link on YOUR domain (white-label — never a voissia
+//    URL). Default 'query' style matches how <VoiceRoom/> reads ?code=.
+const joinUrl = buildJoinUrl(space, { baseUrl: 'https://app.yourdomain.com/room' })
+//   → https://app.yourdomain.com/room?code=abc-defg-hij
+//   path style: buildJoinUrl(space, { baseUrl: '…/room', style: 'path' }) → …/room/abc-defg-hij
+//   (also available as platform.spaces.joinUrl(space, { baseUrl }))
+
+// 3. Manage the space.
+await platform.spaces.get(space.spaceId)
+await platform.spaces.list() // → { data: SpaceView[] }
+await platform.spaces.update(space.spaceId, { notesEnabled: false })
+await platform.spaces.delete(space.spaceId)
+```
+
+The public join exchange (a participant redeeming the code for a token) and host
+controls / recording are client- and host-side — see `@craftedxp/voice-room-react`.
 
-Set `transcribeOnly: true` (on `agents.create` or `agents.update`, since 0.10.1)
-for an agent that **listens but never speaks** — no TTS/LLM, no greeting; user
-turns stream back as `transcript` data-messages over the existing call/WebRTC
-transport. Useful for note-taking / dictation surfaces that reuse the agent +
-call-mint plumbing but want the agent silent.
+## Pre-generated speech
+
+Synthesise agent audio ahead of time — same voice as a live call, stored
+behind a signed URL — for one-way content (briefings, reminders, countdowns).
 
 ```ts
-await client.agents.create({ name: 'Scribe', systemPrompt: 'n/a', transcribeOnly: true })
+// Batch path: enqueue at T-30 min, receive `speech.ready` via webhook.
+const job = await client.speech.enqueue({
+  agentId: 'agt_…',
+  context: { goals: ['run 5k'], weather: 'sunny, 18°C' },
+  instructions: '60–90 seconds, upbeat, finish by handing over to the live conversation',
+  idempotencyKey: `${deviceId}:${alarmId}:${yyyymmdd}`,
+  userTags: ['premium'],
+  ttlSeconds: 6 * 3600,
+  metadata: { deviceId, alarmId },
+})
+// Note: if `idempotencyKey` matches an existing *ready* asset, the server
+// short-circuits the queue hop and `enqueue` resolves with that SpeechAsset
+// (status 200) instead of a SpeechJob (status 202) — check `.status`.
+
+// Sync path for short clips / dev: resolves with the ready asset.
+try {
+  const asset = await client.speech.synthesize({ agentId: 'agt_…', text: 'Good morning!' })
+  console.log(asset.url, asset.durationMs)
+} catch (err) {
+  if (err instanceof PlatformError && err.code === 'accepted') {
+    const job = err.body as SpeechJob // server handed off to the queue
+  }
+}
 ```
 
+Webhooks: `speech.ready` (`data: SpeechAsset`) and `speech.failed` (`data: SpeechJob`). Subscribe them on the agent's webhook like any other event. `format: 'ogg'` is reserved (400 today); `sampleRate` 24k/48k are upsampled from the provider's 16 kHz.
+
 ## Webhook signature verification
 
 ```ts
@@ -194,6 +281,12 @@ for await (const call of client.calls.listAll({ agentId })) {
 - Browser-side use. This SDK assumes a server-side environment with native `fetch`. The `sk_` API key must never reach a browser.
 - Phone numbers, outbound dialling. Telephony is on the platform roadmap; the SDK will surface it when the server endpoints land.
 
+## Changelog
+
+- **Unreleased** _(forward-looking)_ — `isPersonal?: boolean` on `Agent` and `AgentCreateInput` (and so on `AgentUpdateInput`). Assistant-only: when `true`, the learning tools (`remember_fact`, `add_correction`, `add_skill_hint`) are live on every `ct_`-token call rather than only on `mode=learning`. Server-side field — no runtime change in this package.
+- **0.15.0** — `client.speech` namespace (`synthesize` / `enqueue` / `get` / `list` / `delete`) for pre-generated agent audio (`POST /v1/speech`), plus `speech.ready` / `speech.failed` webhook event types and the `accepted` error code (`synthesize` → 202 handoff). Requires server ≥ the 2026-08 speech release.
+- **0.14.0** — `client.spaces` namespace (create / get / list / update / delete) for durable multi-party spaces, plus the standalone `buildJoinUrl(spaceOrCode, { baseUrl, style? })` helper for white-label participant links. No server changes — the `/v1/spaces` endpoints already existed.
+
 ## Migration from `@voxline/node@0.1.0`
 
 `@voxline/node` was a pre-launch internal name. This package replaces it under the `@craftedxp` org. API surface is unchanged except for the Phase 12 additions (`context` / `metadata` / `contactId` on `callTokens.mint`).

package/dist/index.d.mts

@@ -31,6 +31,16 @@ type TtsProvider = 'pockettts' | 'cartesia' | 'fish-audio' | 'gemini' | 'kokoro'
 type SttProvider = 'deepgram';
 type LlmProvider = 'gemini' | 'openai' | 'anthropic';
 type EndpointingMode = 'smart' | 'simple';
+/**
+ * Agent kind. Set at creation and immutable thereafter — changing what an
+ * agent does means creating a new one. Gates which routes accept the agent:
+ *   - `assistant`  — 1:1 voice + text chat + learning mode (LLM + STT + TTS)
+ *   - `room`       — hosts LiveKit rooms; per-speaker transcription + analysis
+ *   - `transcribe` — 1:1 dictation, STT-only (the agent never speaks)
+ *
+ * Replaces the legacy `canHostRooms` / `transcribeOnly` boolean flags.
+ */
+type AgentType = 'assistant' | 'room' | 'transcribe';
 interface AgentVoice {
     provider: TtsProvider;
     voiceId?: string;
@@ -109,6 +119,8 @@ interface AgentRecording {
 interface Agent {
     agentId: string;
     orgId: string;
+    /** Agent kind — see {@link AgentType}. Immutable after creation. */
+    type: AgentType;
     name: string;
     systemPrompt: string;
     /**
@@ -119,6 +131,8 @@ interface Agent {
      * caller speaks first.
      */
     agentSpeaksFirst?: boolean;
+    /** Personal assistant (`assistant` agents only) — the learning tools are live on every `ct_`-token call, not just `mode=learning`. */
+    isPersonal?: boolean;
     voice: AgentVoice;
     transcriber: AgentTranscriber;
     model: AgentModel;
@@ -151,19 +165,22 @@ interface Agent {
      * right gateway.
      */
     transport?: 'ws' | 'webrtc';
-    /** Whether this agent may host multi-party video rooms. */
-    canHostRooms?: boolean;
-    /** Room operating mode (`'notes-only'` today). */
+    /** Room operating mode (`'notes-only'` today). Only set on `type: 'room'` agents. */
     roomMode?: 'notes-only';
-    /** Transcribe-only mode — the agent listens but never speaks. */
-    transcribeOnly?: boolean;
     createdAt: number;
     updatedAt: number;
 }
 interface AgentCreateInput {
+    /**
+     * Agent kind — see {@link AgentType}. Required and immutable: it cannot be
+     * changed via {@link AgentUpdateInput} (it is omitted from that type).
+     */
+    type: AgentType;
     name: string;
     systemPrompt: string;
     agentSpeaksFirst?: boolean;
+    /** Personal assistant (`assistant` agents only) — the learning tools are live on every `ct_`-token call, not just `mode=learning`. */
+    isPersonal?: boolean;
     voice?: AgentVoice;
     transcriber?: AgentTranscriber;
     model?: AgentModel;
@@ -185,26 +202,18 @@ interface AgentCreateInput {
      */
     avatarUrl?: string;
     /**
-     * Let this agent host multi-party video rooms. Off by default. Required
-     * (`true`) before `client.rooms.create({ agentId })` will accept the agent.
-     */
-    canHostRooms?: boolean;
-    /**
-     * Room operating mode. Today only `'notes-only'` exists — the agent listens
-     * and takes structured notes without speaking. A literal union so future
-     * modes can be added without breaking the wire.
+     * Room operating mode. Only valid on `type: 'room'` agents. Today only
+     * `'notes-only'` exists — the agent listens and takes structured notes
+     * without speaking. A literal union so future modes can be added without
+     * breaking the wire.
      */
     roomMode?: 'notes-only';
-    /**
-     * Transcribe-only mode. When `true`, the agent listens but never speaks: no
-     * TTS/LLM, no greeting, idle nudges suppressed, user turns are not routed
-     * through the LLM — an STT-only loop that streams `transcript` data-messages
-     * back to the caller. `voice` stays required by the schema (defaults apply)
-     * but is never read at runtime.
-     */
-    transcribeOnly?: boolean;
 }
-type AgentUpdateInput = Partial<AgentCreateInput>;
+/**
+ * Patch shape for `agents.update`. `type` is immutable, so it is omitted
+ * here — to change an agent's kind, create a new agent.
+ */
+type AgentUpdateInput = Partial<Omit<AgentCreateInput, 'type'>>;
 /**
  * Trimmed agent shape returned by the consumer catalog
  * (`GET /v1/orgs/:orgId/agents`). Operator-only fields like
@@ -390,9 +399,9 @@ interface CallTokenMintInput {
     initiatedBy?: 'user' | 'agent';
     /**
      * Session channel selector. `voice` (default) routes to WS/WebRTC audio;
-     * `text` routes to HTTP+SSE chat via the `chats` resource. Rejected at
-     * mint when the agent has `transcribeOnly: true` or when `mode: 'learning'`
-     * is supplied.
+     * `text` routes to HTTP+SSE chat via the `chats` resource. `text` requires
+     * a `type: 'assistant'` agent; non-assistant agents are rejected at mint
+     * (`wrong_agent_type`), as is `mode: 'learning'` on a non-assistant agent.
      */
     channel?: 'voice' | 'text';
     /**
@@ -437,7 +446,7 @@ interface CallTokenSummary {
     revoked: boolean;
     allowedOrigins?: string[];
 }
-type PlatformEventName = 'call.started' | 'call.ended' | 'transcript.updated' | 'call.summary.ready' | 'tool.call.requested' | 'tool.call.completed' | 'tool.call.failed' | 'credits.low';
+type PlatformEventName = 'call.started' | 'call.ended' | 'transcript.updated' | 'call.summary.ready' | 'tool.call.requested' | 'tool.call.completed' | 'tool.call.failed' | 'credits.low' | 'speech.ready' | 'speech.failed';
 interface WebhookConfig {
     webhookId: string;
     orgId: string;
@@ -491,6 +500,17 @@ interface CreateRoomInput {
     agentId: string;
     /** 1..240 — enforced by the server. */
     durationMin: number;
+    /**
+     * Document references forwarded to the room analyzer. Each `docId` is an
+     * analysis document (`adoc_…`) uploaded via `POST /v1/analysis-docs` (NOT a
+     * knowledge-base file), tagged with an optional semantic role (e.g. `'jd'`,
+     * `'cv'`); the worker loads the full text and injects it into the analyzer.
+     * Omit when the room agent uses its default analysis behaviour.
+     */
+    analysisContext?: Array<{
+        docId: string;
+        role?: string;
+    }>;
 }
 interface CreateRoomResponse {
     roomId: string;
@@ -553,6 +573,24 @@ interface ListUtterancesResponse {
     utterances: UtteranceWire[];
     nextCursor: string | null;
 }
+interface AnalysisWire {
+    analysisId: string;
+    participantId: string;
+    label: string;
+    score?: number;
+    note?: string;
+    createdAt: string;
+    /**
+     * Which producer emitted this result: `'summary'` | `'rated_dimensions'` |
+     * `'suggested_questions'`. Set by the worker on every result it produces;
+     * absent only on legacy analysis entries written before producers existed.
+     */
+    producer?: string;
+}
+interface ListAnalysisResponse {
+    analysis: AnalysisWire[];
+    nextCursor: string | null;
+}
 /** Returned by host-action endpoints (`/end` and friends) — 202 + eventId so
  *  callers can correlate the async system-message broadcast that follows. */
 interface RoomEventAck {
@@ -589,6 +627,105 @@ type ChatEvent = {
     code: string;
     message: string;
 };
+type SpaceKind = 'audio' | 'video';
+type RecordingMode = 'off' | 'host-source' | 'composite';
+interface RecordingConfig {
+    mode: RecordingMode;
+    maxMinutesPerSession?: number;
+    audioOnly?: boolean;
+}
+/** The redacted space shape the server returns (`toSpaceView`). */
+interface SpaceView {
+    spaceId: string;
+    agentId: string;
+    /** Stable human-friendly join code, e.g. `abc-defg-hij`. */
+    code: string;
+    kind: SpaceKind;
+    notesEnabled: boolean;
+    lobbyEnabled: boolean;
+    recording: RecordingConfig;
+    active: boolean;
+    currentSessionId: string | null;
+    sessionCount: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateSpaceInput {
+    agentId: string;
+    /** Defaults to `video` server-side. */
+    kind?: SpaceKind;
+    /** Defaults to `true` server-side. */
+    notesEnabled?: boolean;
+    /** Defaults to `false` server-side. */
+    lobbyEnabled?: boolean;
+    recording?: RecordingConfig;
+}
+/** At least one field is required — the server rejects an empty patch. */
+interface SpacePatch {
+    notesEnabled?: boolean;
+    lobbyEnabled?: boolean;
+    active?: boolean;
+    recording?: RecordingConfig;
+}
+interface ListSpacesResponse {
+    data: SpaceView[];
+}
+interface SpeechSynthesizeInput {
+    agentId: string;
+    text?: string;
+    context?: Record<string, unknown>;
+    instructions?: string;
+    format?: 'mp3' | 'wav' | 'ogg';
+    sampleRate?: 16000 | 24000 | 48000;
+    idempotencyKey?: string;
+    userTags?: string[];
+    ttlSeconds?: number;
+    metadata?: Record<string, string>;
+}
+interface SpeechAsset {
+    id: string;
+    status: 'ready';
+    url: string;
+    expiresAt: string;
+    durationMs: number;
+    bytes: number;
+    format: 'mp3' | 'wav' | 'ogg';
+    sampleRate: number;
+    text: string;
+    agentId: string;
+    idempotencyKey?: string;
+    metadata?: Record<string, string>;
+    createdAt: string;
+}
+interface SpeechJob {
+    id: string;
+    status: 'queued' | 'processing' | 'failed';
+    error?: {
+        code: string;
+        message: string;
+    };
+    idempotencyKey?: string;
+    metadata?: Record<string, string>;
+    createdAt: string;
+}
+interface SpeechListInput {
+    idempotencyKeyPrefix?: string;
+    status?: 'queued' | 'processing' | 'ready' | 'failed';
+    limit?: number;
+    cursor?: string;
+}
+interface SpeechReadyEvent {
+    event: 'speech.ready';
+    timestamp: string;
+    orgId: string;
+    data: SpeechAsset;
+}
+interface SpeechFailedEvent {
+    event: 'speech.failed';
+    timestamp: string;
+    orgId: string;
+    data: SpeechJob;
+}
 
 declare const createMeResource: (http: HttpClient) => {
     get: () => Promise<MeResponse>;
@@ -730,10 +867,38 @@ declare const createRoomsResource: (http: HttpClient) => {
     list: (filters?: RoomListFilters) => Promise<ListRoomsResponse>;
     get: (roomId: string) => Promise<RoomDoc>;
     transcript: (roomId: string, opts?: RoomTranscriptOptions) => Promise<ListUtterancesResponse>;
+    analysis: (roomId: string, opts?: RoomTranscriptOptions) => Promise<ListAnalysisResponse>;
     end: (roomId: string) => Promise<RoomEventAck>;
 };
 type RoomsResource = ReturnType<typeof createRoomsResource>;
 
+type JoinUrlStyle = 'query' | 'path';
+interface BuildJoinUrlOptions {
+    /** Required — the developer's own page that renders <VoiceRoom/>. Absolute URL. */
+    baseUrl: string;
+    /** 'query' (default) → ?code=…  ·  'path' → /…  */
+    style?: JoinUrlStyle;
+}
+/**
+ * Build a participant join URL on the DEVELOPER's domain from a space (or a
+ * raw code). White-label: the returned URL never points at a voissia origin —
+ * `baseUrl` is required and supplied by the caller.
+ *
+ * The default `query` style appends `?code=<code>`, matching how
+ * `<VoiceRoom/>` (and the example app) read the code from the URL.
+ */
+declare const buildJoinUrl: (spaceOrCode: SpaceView | string, opts: BuildJoinUrlOptions) => string;
+
+declare const createSpacesResource: (http: HttpClient) => {
+    create: (input: CreateSpaceInput) => Promise<SpaceView>;
+    get: (spaceId: string) => Promise<SpaceView>;
+    list: () => Promise<ListSpacesResponse>;
+    update: (spaceId: string, patch: SpacePatch) => Promise<SpaceView>;
+    delete: (spaceId: string) => Promise<void>;
+    joinUrl: (spaceOrCode: SpaceView | string, opts: BuildJoinUrlOptions) => string;
+};
+type SpacesResource = ReturnType<typeof createSpacesResource>;
+
 interface StartChatInput {
     agentId: string;
     text?: string;
@@ -759,6 +924,32 @@ declare const createChatsResource: (http: HttpClient, callToken: string) => {
 };
 type ChatsResource = ReturnType<typeof createChatsResource>;
 
+declare const createSpeechResource: (http: HttpClient) => {
+    /**
+     * Synchronous. Resolves with the ready asset. Throws PlatformError
+     * code 'accepted' (status 202, `body` = SpeechJob) when the server hands
+     * the job to the queue instead — poll `get(job.id)` or wait for the
+     * `speech.ready` webhook.
+     */
+    synthesize: (input: SpeechSynthesizeInput) => Promise<SpeechAsset>;
+    /**
+     * Asynchronous. Normally returns a queued/processing SpeechJob —
+     * completion arrives via the `speech.ready` / `speech.failed` webhook or
+     * a later `get(job.id)`. Exception: when `idempotencyKey` matches an
+     * existing *ready* asset, the server short-circuits the queue hop and
+     * responds 200 with that SpeechAsset directly instead of 202.
+     */
+    enqueue: (input: SpeechSynthesizeInput) => Promise<SpeechJob | SpeechAsset>;
+    get: (id: string) => Promise<SpeechAsset | SpeechJob>;
+    list: (input?: SpeechListInput) => Promise<{
+        items: Array<SpeechAsset | SpeechJob>;
+        cursor?: string;
+    }>;
+    /** Idempotent. Deleting a ready asset invalidates its URL immediately. */
+    delete: (id: string) => Promise<void>;
+};
+type SpeechResource = ReturnType<typeof createSpeechResource>;
+
 interface PlatformClientOptions {
     apiKey: string;
     baseUrl?: string;
@@ -777,6 +968,8 @@ declare class PlatformClient {
     readonly webhooks: WebhooksResource;
     readonly orgs: OrgsResource;
     readonly rooms: RoomsResource;
+    readonly spaces: SpacesResource;
+    readonly speech: SpeechResource;
     private readonly _http;
     constructor(options: PlatformClientOptions);
     /**
@@ -791,7 +984,7 @@ declare class PlatformClient {
     chatsFor(callToken: string): ChatsResource;
 }
 
-type ApiErrorCode = 'unauthorized' | 'forbidden' | 'not_found' | 'bad_request' | 'conflict' | 'rate_limited' | 'payment_required' | 'internal_error' | 'unknown';
+type ApiErrorCode = 'unauthorized' | 'forbidden' | 'not_found' | 'bad_request' | 'conflict' | 'rate_limited' | 'payment_required' | 'internal_error' | 'accepted' | 'service_unavailable' | 'unknown';
 declare class PlatformError extends Error {
     readonly code: ApiErrorCode;
     readonly status: number;
@@ -811,4 +1004,4 @@ declare class PlatformError extends Error {
 
 declare const verifyWebhookSignature: (rawBody: Buffer | string, signatureHeader: string, secret: string) => boolean;
 
-export { type Agent, type AgentCreateInput, type AgentEndpointing, type AgentHttpTool, type AgentModel, type AgentRecording, type AgentTool, type AgentTranscriber, type AgentUpdateInput, type AgentVoice, type AgentWebhooksResource, type AgentsResource, type ApiErrorCode, type CallListFilters, type CallRecord, type CallRecordingUrlResponse, type CallStatus, type CallSummary, type CallTokenMintInput, type CallTokenMintResult, type CallTokenSummary, type CallTokensResource, type CallsResource, type CatalogAgent, type CatalogListInput, type Chat, type ChatEvent, type ChatsResource, type CostBreakdown, type CreateRoomInput, type CreateRoomResponse, type CreditsResource, type EndReason, type EndpointingMode, type GuestRole, type KnowledgeBase, type KnowledgeBaseFile, type KnowledgeBasesResource, type LedgerEntry, type ListRoomsResponse, type ListUtterancesResponse, type LlmProvider, type MeResource, type MeResponse, type OrgsResource, PlatformClient, type PlatformClientOptions, PlatformError, type PlatformEventName, type RecordingMeta, type RoomDoc, type RoomEndReason, type RoomEventAck, type RoomListFilters, type RoomMetricsWire, type RoomStatus, type RoomTranscriptOptions, type RoomsResource, type StartChatInput, type SttProvider, type TranscriptTurn, type TtsProvider, type UtteranceWire, type WebhookConfig, type WebhookCreateInput, type WebhookDelivery, type WebhookUpdateInput, type WebhooksResource, type WorkerStatus, verifyWebhookSignature };
+export { type Agent, type AgentCreateInput, type AgentEndpointing, type AgentHttpTool, type AgentModel, type AgentRecording, type AgentTool, type AgentTranscriber, type AgentType, type AgentUpdateInput, type AgentVoice, type AgentWebhooksResource, type AgentsResource, type AnalysisWire, type ApiErrorCode, type BuildJoinUrlOptions, type CallListFilters, type CallRecord, type CallRecordingUrlResponse, type CallStatus, type CallSummary, type CallTokenMintInput, type CallTokenMintResult, type CallTokenSummary, type CallTokensResource, type CallsResource, type CatalogAgent, type CatalogListInput, type Chat, type ChatEvent, type ChatsResource, type CostBreakdown, type CreateRoomInput, type CreateRoomResponse, type CreateSpaceInput, type CreditsResource, type EndReason, type EndpointingMode, type GuestRole, type JoinUrlStyle, type KnowledgeBase, type KnowledgeBaseFile, type KnowledgeBasesResource, type LedgerEntry, type ListAnalysisResponse, type ListRoomsResponse, type ListSpacesResponse, type ListUtterancesResponse, type LlmProvider, type MeResource, type MeResponse, type OrgsResource, PlatformClient, type PlatformClientOptions, PlatformError, type PlatformEventName, type RecordingConfig, type RecordingMeta, type RecordingMode, type RoomDoc, type RoomEndReason, type RoomEventAck, type RoomListFilters, type RoomMetricsWire, type RoomStatus, type RoomTranscriptOptions, type RoomsResource, type SpaceKind, type SpacePatch, type SpaceView, type SpacesResource, type SpeechAsset, type SpeechFailedEvent, type SpeechJob, type SpeechListInput, type SpeechReadyEvent, type SpeechResource, type SpeechSynthesizeInput, type StartChatInput, type SttProvider, type TranscriptTurn, type TtsProvider, type UtteranceWire, type WebhookConfig, type WebhookCreateInput, type WebhookDelivery, type WebhookUpdateInput, type WebhooksResource, type WorkerStatus, buildJoinUrl, verifyWebhookSignature };