@rkat/sdk 0.5.1 → 0.6.0

package/README.md

@@ -2,7 +2,7 @@
 
 TypeScript client for the [Meerkat](https://github.com/lukacf/meerkat) runtime. The SDK is a thin session-first wrapper over the same runtime-backed contracts used by the CLI, REST, JSON-RPC, and MCP surfaces. It communicates with a local `rkat-rpc` subprocess over JSON-RPC 2.0 (newline-delimited JSON on stdin/stdout).
 
-Current contract version: `0.5.0`.
+Current contract version: `0.6.0`.
 
 ## Installation
 
@@ -107,7 +107,7 @@ Creates a new session and immediately runs the first turn with the given prompt.
 |-----------|------|---------|-------------|
 | `prompt` | `string \| ContentBlock[]` | **(required)** | The user prompt for the first turn. |
 | `options.model` | `string` | Server default (typically `claude-sonnet-4-5`) | LLM model name (e.g. `"gpt-5.2"`, `"gemini-3-flash-preview"`, `"claude-opus-4-6"`). |
-| `options.provider` | `string` | Auto-detected from model | Force a specific provider (`"anthropic"`, `"openai"`, `"gemini"`). |
+| `options.provider` | `string` | Resolved from the model registry | Force a specific provider (`"anthropic"`, `"openai"`, `"gemini"`). |
 | `options.systemPrompt` | `string` | `undefined` | Override the default system prompt. |
 | `options.maxTokens` | `number` | `undefined` | Maximum output tokens for the LLM response. |
 | `options.outputSchema` | `Record<string, unknown>` | `undefined` | JSON Schema for structured output extraction. |
@@ -125,6 +125,11 @@ Creates a new session and immediately runs the first turn with the given prompt.
 | `options.preloadSkills` | `string[]` | `undefined` | Skill source UUIDs to load before the run. |
 | `options.skillRefs` | `SkillRef[]` | `undefined` | Canonical structured skill references. |
 | `options.skillReferences` | `string[]` | `undefined` | Legacy string skill references; prefer `skillRefs`. |
+| `options.labels` | `Record<string, string>` | `undefined` | Session labels used for filtering and metadata. |
+| `options.additionalInstructions` | `string[]` | `undefined` | Extra instruction blocks appended to the system prompt. |
+| `options.appContext` | `unknown` | `undefined` | Opaque app context passed to custom builders. |
+| `options.shellEnv` | `Record<string, string>` | `undefined` | Per-session shell environment variables. |
+| `options.externalTools` | `Record<string, unknown>[]` | `undefined` | Inline callback tool definitions for this session. |
 
 ### createDeferredSession(prompt, options?)
 
@@ -140,18 +145,57 @@ Creates a session identity without running the first turn yet. Use `await deferr
 ### listSessions()
 
 ```ts
-async listSessions(): Promise<SessionInfo[]>
+async listSessions(options?: {
+  labels?: Record<string, string>;
+  limit?: number;
+  offset?: number;
+}): Promise<SessionInfo[]>
 ```
 
-Returns an array of `SessionInfo` objects with camelCase fields such as `sessionId`, `sessionRef`, `messageCount`, and `isActive`.
+Returns an array of typed `SessionInfo` objects with camelCase fields such as `sessionId`, `sessionRef`, `messageCount`, `isActive`, and `labels`.
 
 ### readSession(sessionId)
 
 ```ts
-async readSession(sessionId: string): Promise<Record<string, unknown>>
+async readSession(sessionId: string): Promise<SessionInfo>
 ```
 
-Returns the current state payload for a session.
+Returns typed session details including `model`, `provider`, `lastAssistantText`, and `labels`.
+
+### Session ingress helpers
+
+```ts
+async sendExternalEvent(sessionId: string, payload: unknown, options?: { source?: string }): Promise<Record<string, unknown>>
+async injectContext(sessionId: string, text: string, options?: { source?: string; idempotencyKey?: string }): Promise<{ status: string }>
+```
+
+These expose `session/external_event` and `session/inject_context` as first-class public APIs.
+
+### Schedules, Models, and Mob profile APIs
+
+```ts
+async getModelsCatalog(): Promise<ModelsCatalog>
+
+async createSchedule(request: CreateScheduleRequest): Promise<Schedule>
+async getSchedule(scheduleId: string): Promise<Schedule>
+async listSchedules(options?: ScheduleListOptions): Promise<Schedule[]>
+async updateSchedule(request: UpdateScheduleRequest): Promise<Schedule>
+async pauseSchedule(scheduleId: string): Promise<Schedule>
+async resumeSchedule(scheduleId: string): Promise<Schedule>
+async deleteSchedule(scheduleId: string): Promise<Schedule>
+async listScheduleOccurrences(scheduleId: string, options?: ScheduleOccurrencesOptions): Promise<ScheduleOccurrencesResult>
+async listScheduleTools(): Promise<ScheduleToolsResult>
+async callScheduleTool(request: ScheduleToolCallRequest): Promise<Record<string, unknown>>
+
+async readMobEvents(mobId: string, options?: MobEventsOptions): Promise<MobEventsResult>
+async spawnMobMembers(mobId: string, specs: SpawnSpec[]): Promise<MobSpawnManyResultEntry[]>
+
+async createMobProfile(name: string, profile: MobProfile): Promise<MobProfileLookupResult>
+async getMobProfile(name: string): Promise<MobProfileLookupResult>
+async listMobProfiles(): Promise<MobProfileLookupResult[]>
+async updateMobProfile(name: string, profile: MobProfile, expectedRevision: number): Promise<MobProfileLookupResult>
+async deleteMobProfile(name: string, expectedRevision: number): Promise<MobProfileDeleteResult>
+```
 
 ### Session lifecycle on wrappers
 
@@ -204,26 +248,26 @@ Throws `MeerkatError` with code `"CAPABILITY_UNAVAILABLE"` if the capability is
 ### getConfig()
 
 ```ts
-async getConfig(): Promise<Record<string, unknown>>
+async getConfig(): Promise<ConfigEnvelope>
 ```
 
-Returns the current Meerkat configuration as a JSON object.
+Returns a config envelope: `{ config, generation, realmId?, instanceId?, backend?, resolvedPaths? }`.
 
 ### setConfig(config)
 
 ```ts
-async setConfig(config: Record<string, unknown>): Promise<void>
+async setConfig(config: Record<string, unknown>): Promise<ConfigEnvelope>
 ```
 
-Replaces the entire runtime configuration.
+Replaces the entire runtime configuration and returns the updated envelope.
 
 ### patchConfig(patch)
 
 ```ts
-async patchConfig(patch: Record<string, unknown>): Promise<Record<string, unknown>>
+async patchConfig(patch: Record<string, unknown>): Promise<ConfigEnvelope>
 ```
 
-Merge-patches the runtime configuration and returns the resulting config.
+Merge-patches the runtime configuration and returns the updated envelope.
 
 ## Public Types
 
@@ -333,14 +377,14 @@ try {
 
 ## Version Compatibility
 
-The SDK exports `CONTRACT_VERSION` (currently `"0.4.11"`). During `connect()`, the SDK checks that the server's contract version is compatible:
+The SDK exports `CONTRACT_VERSION` (currently `"0.6.0"`). During `connect()`, the SDK checks that the server's contract version is compatible:
 
 - While the major version is `0`, minor versions must match exactly (e.g. SDK `0.1.x` requires server `0.1.x`).
 - Once `1.0.0` is reached, major versions must match (standard semver).
 
 ```ts
 import { CONTRACT_VERSION } from "@rkat/sdk";
-console.log(CONTRACT_VERSION);  // "0.4.11"
+console.log(CONTRACT_VERSION);  // "0.6.0"
 ```
 
 If the versions are incompatible, `connect()` throws a `MeerkatError` with code `"VERSION_MISMATCH"`.
@@ -353,14 +397,14 @@ await client.connect();
 
 // Read the current config.
 const config = await client.getConfig();
-console.log(config);
+console.log(config.generation, config.config);
 
 // Replace the entire config.
-await client.setConfig({ ...config, max_tokens: 4096 });
+await client.setConfig({ ...config.config, max_tokens: 4096 });
 
 // Or merge-patch specific fields.
 const updated = await client.patchConfig({ max_tokens: 8192 });
-console.log(updated.max_tokens);  // 8192
+console.log(updated.config.max_tokens);  // 8192
 
 await client.close();
 ```
@@ -382,16 +426,16 @@ const session = await client.createSession("List three European capitals", {
     },
     required: ["capitals"],
   },
-  structured_output_retries: 3,
+  structuredOutputRetries: 3,
 });
 
 // Parsed structured output (matches the schema).
-console.log(result.structured_output);
+console.log(session.structuredOutput);
 // { capitals: ["Paris", "Berlin", "Madrid"] }
 
 // Schema warnings from provider-specific validation issues.
-if (result.schema_warnings) {
-  for (const w of result.schema_warnings) {
+if (session.lastResult.schemaWarnings) {
+  for (const w of session.lastResult.schemaWarnings) {
     console.warn(`[${w.provider}] ${w.path}: ${w.message}`);
   }
 }

package/dist/client.d.ts

@@ -24,17 +24,17 @@
  * await client.close();
  * ```
  */
-import { type RuntimeAcceptResult, type RuntimeResetResult, type RuntimeRetireResult, type RuntimeStateResult, type WireInputState, type McpAddParams, type McpLiveOpResponse, type McpReloadParams, type McpRemoveParams } from "./generated/types.js";
+import { type RealtimeCapabilitiesResult, type RealtimeOpenInfo, type RealtimeOpenRequest, type RealtimeStatusResult, type MobRotateSupervisorResult, type RuntimeRealtimeAttachmentStatusResult, type McpAddParams, type McpLiveOpResponse, type McpReloadParams, type McpRemoveParams, type MobSpawnManyResultEntry } from "./generated/types.js";
 import { DeferredSession, Session } from "./session.js";
-import { Mob, type MemberDeliveryReceipt, type MemberSendOptions, type MobKickoffMemberSnapshot, type MobKickoffWaitOptions, type MobPeerTarget } from "./mob.js";
+import { Mob, type MemberDeliveryReceipt, type MemberSendOptions, type MobKickoffMemberSnapshot, type MobKickoffWaitOptions, type MobReadyMemberSnapshot, type MobReadyWaitOptions, type MobPeerTarget } from "./mob.js";
 import { EventStream } from "./streaming.js";
 import { EventSubscription } from "./subscription.js";
-import type { AgentEventEnvelope, AttributedMobEvent, BlobPayload, Capability, ContentInput, ContentBlock, MobCreateOptions, MobFlowStatus, MobMember, MobSummary, RunResult, SessionAssistantBlock, SessionHistory, SessionInfo, SessionMessage, SessionOptions, SkillRef, TurnToolOverlay } from "./types.js";
+import type { AgentEventEnvelope, AttributedMobEvent, BlobPayload, Capability, CommsCommand, CommsSendReceipt, ConfigEnvelope, ContentInput, ContentBlock, CreateScheduleRequest, HelpOptions, ModelsCatalog, MobEventsOptions, MobEventsResult, MobCreateOptions, MobFlowStatus, MobLifecycleAction, MobMember, MobMemberRef, MobProfile, MobProfileDeleteResult, MobProfileLookupResult, MobSpawnResult, MobSummary, MobTurnStartOptions, PeerCorrelationId, PeerId, PeerResponseTerminalOptions, RunResult, Schedule, ScheduleListOptions, ScheduleOccurrencesOptions, ScheduleOccurrencesResult, ScheduleToolCallRequest, ScheduleToolsResult, SessionAssistantBlock, SessionHistory, SessionIngressOptions, SessionInfo, SessionListOptions, SessionMessage, SessionOptions, SpawnManySpec, SpawnSpec, UpdateScheduleRequest, TurnOptions } from "./types.js";
 /** Options for connecting to the rkat-rpc runtime. */
 export interface ConnectOptions {
     realmId?: string;
     instanceId?: string;
-    realmBackend?: "jsonl" | "redb";
+    realmBackend?: "jsonl" | "sqlite";
     isolated?: boolean;
     stateRoot?: string;
     contextRoot?: string;
@@ -42,6 +42,7 @@ export interface ConnectOptions {
 }
 export declare class MeerkatClient {
     private process;
+    private processStderr;
     private requestId;
     private _capabilities;
     private _methods;
@@ -71,6 +72,8 @@ export declare class MeerkatClient {
     registerTool(name: string, description: string, inputSchema: Record<string, unknown>, handler: (args: Record<string, unknown>) => Promise<string>): void;
     connect(options?: ConnectOptions): Promise<this>;
     close(): Promise<void>;
+    private rejectPendingRequests;
+    private closeQueues;
     /**
      * Create a new session, run the first turn, and return a {@link Session}.
      *
@@ -96,8 +99,16 @@ export declare class MeerkatClient {
      * turn with optional per-turn overrides.
      */
     createDeferredSession(prompt: string | ContentBlock[], options?: SessionOptions): Promise<DeferredSession>;
-    listSessions(): Promise<SessionInfo[]>;
-    readSession(sessionId: string): Promise<Record<string, unknown>>;
+    askHelp(question: string, options?: HelpOptions): Promise<RunResult>;
+    listSessions(options?: SessionListOptions): Promise<SessionInfo[]>;
+    readSession(sessionId: string): Promise<SessionInfo>;
+    sendExternalEvent(sessionId: string, eventType: string, payload: unknown, options?: {
+        blocks?: ContentBlock[];
+    }): Promise<Record<string, unknown>>;
+    sendPeerResponseTerminal(sessionId: string, peerId: PeerId, requestId: PeerCorrelationId, status: "completed" | "failed" | "cancelled", result: unknown, options?: PeerResponseTerminalOptions): Promise<Record<string, unknown>>;
+    injectContext(sessionId: string, text: string, options?: SessionIngressOptions): Promise<{
+        status: string;
+    }>;
     readSessionHistory(sessionId: string, options?: {
         offset?: number;
         limit?: number;
@@ -105,13 +116,13 @@ export declare class MeerkatClient {
     get capabilities(): readonly Capability[];
     hasCapability(capabilityId: string): boolean;
     requireCapability(capabilityId: string): void;
-    getConfig(): Promise<Record<string, unknown>>;
+    getConfig(): Promise<ConfigEnvelope>;
     setConfig(config: Record<string, unknown>, options?: {
         expectedGeneration?: number;
-    }): Promise<Record<string, unknown>>;
+    }): Promise<ConfigEnvelope>;
     patchConfig(patch: Record<string, unknown>, options?: {
         expectedGeneration?: number;
-    }): Promise<Record<string, unknown>>;
+    }): Promise<ConfigEnvelope>;
     mcpAdd(params: McpAddParams): Promise<McpLiveOpResponse>;
     mcpRemove(params: McpRemoveParams): Promise<McpLiveOpResponse>;
     mcpReload(params: McpReloadParams): Promise<McpLiveOpResponse>;
@@ -119,10 +130,31 @@ export declare class MeerkatClient {
     mcp_remove(params: McpRemoveParams): Promise<McpLiveOpResponse>;
     mcp_reload(params: McpReloadParams): Promise<McpLiveOpResponse>;
     listSkills(): Promise<Array<Record<string, unknown>>>;
-    inspectSkill(id: string, options?: {
-        source?: string;
-    }): Promise<Record<string, unknown>>;
     getBlob(blobId: string): Promise<BlobPayload>;
+    getRuntimeHostInfo(): Promise<Record<string, unknown>>;
+    getRuntimeHostCapabilities(): Promise<Record<string, unknown>>;
+    getRuntimeHostHealth(): Promise<Record<string, unknown>>;
+    requestApproval(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    listApprovals(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    getApproval(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    decideApproval(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    listArtifacts(params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    getArtifact(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    downloadArtifact(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    latestEventCursor(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    listEventsSince(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    eventSnapshot(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    getModelsCatalog(): Promise<ModelsCatalog>;
+    createSchedule(request: CreateScheduleRequest): Promise<Schedule>;
+    getSchedule(scheduleId: string): Promise<Schedule>;
+    listSchedules(_options?: ScheduleListOptions): Promise<Schedule[]>;
+    updateSchedule(request: UpdateScheduleRequest): Promise<Schedule>;
+    pauseSchedule(scheduleId: string): Promise<Schedule>;
+    resumeSchedule(scheduleId: string): Promise<Schedule>;
+    deleteSchedule(scheduleId: string): Promise<Schedule>;
+    listScheduleOccurrences(scheduleId: string, options?: ScheduleOccurrencesOptions): Promise<ScheduleOccurrencesResult>;
+    listScheduleTools(): Promise<ScheduleToolsResult>;
+    callScheduleTool(request: ScheduleToolCallRequest): Promise<Record<string, unknown>>;
     subscribeSessionEvents(sessionId: string): Promise<EventSubscription<AgentEventEnvelope>>;
     createMob(options: MobCreateOptions): Promise<Mob>;
     mob(mobId: string): Mob;
@@ -132,36 +164,27 @@ export declare class MeerkatClient {
         status: string;
     }>;
     listMobMembers(mobId: string): Promise<MobMember[]>;
-    sendMobMemberContent(mobId: string, meerkatId: string, content: string | ContentBlock[], options?: MemberSendOptions): Promise<MemberDeliveryReceipt>;
-    spawnMobMember(mobId: string, options: {
-        profile: string;
-        meerkatId: string;
-        initialMessage?: string | ContentBlock[];
-        runtimeMode?: string;
-        backend?: string;
-        resumeSessionId?: string;
-        labels?: Record<string, string>;
-        context?: Record<string, unknown>;
-        additionalInstructions?: string[];
-    }): Promise<Record<string, unknown>>;
-    retireMobMember(mobId: string, meerkatId: string): Promise<void>;
-    respawnMobMember(mobId: string, meerkatId: string, initialMessage?: string | ContentBlock[]): Promise<{
+    sendMobMemberContent(mobId: string, agentIdentity: string, content: string | ContentBlock[], options?: MemberSendOptions): Promise<MemberDeliveryReceipt>;
+    spawnMobMember(mobId: string, options: SpawnSpec): Promise<MobSpawnResult>;
+    spawnMobMembers(mobId: string, specs: SpawnManySpec[]): Promise<MobSpawnManyResultEntry[]>;
+    retireMobMember(mobId: string, agentIdentity: string): Promise<void>;
+    respawnMobMember(mobId: string, agentIdentity: string, initialMessage?: string | ContentBlock[]): Promise<{
         status: "completed" | "topology_restore_failed";
         receipt: {
-            memberId: string;
-            oldSessionId?: string;
-            newSessionId?: string;
+            agentIdentity: string;
+            memberRef: MobMemberRef;
         };
         failedPeerIds?: string[];
     }>;
-    forceCancelMobMember(mobId: string, meerkatId: string): Promise<void>;
-    mobMemberStatus(mobId: string, meerkatId: string): Promise<{
+    forceCancelMobMember(mobId: string, agentIdentity: string): Promise<void>;
+    mobTurnStart(mobId: string, agentIdentity: string, prompt: ContentInput, options?: MobTurnStartOptions): Promise<Record<string, unknown>>;
+    mobMemberStatus(mobId: string, agentIdentity: string): Promise<{
         status: string;
         outputPreview?: string;
         error?: string;
         tokensUsed: number;
         isFinal: boolean;
-        currentSessionId?: string;
+        liveAttachmentStatus?: "unattached" | "intent_present_unbound" | "binding_not_ready" | "binding_ready" | "replacement_pending" | "reattach_required";
         peerConnectivity?: {
             reachablePeerCount: number;
             unknownPeerCount: number;
@@ -170,21 +193,94 @@ export declare class MeerkatClient {
                 reason?: string;
             }>;
         };
+        /**
+         * Phase 5G/T5i identity-first realtime routing: session id of the
+         * member's current bridge session. Consumers navigate
+         * `mob/member_status.currentSessionId → realtime/open_info
+         * (session_target)`. Absent when the member is not yet bound to a
+         * session.
+         */
+        currentSessionId?: string;
+    }>;
+    /**
+     * Point-in-time aggregate of a mob's status plus its member list.
+     * Wraps the `mob/snapshot` RPC (DELETE_ME C2).
+     */
+    mobSnapshot(mobId: string): Promise<{
+        mobId: string;
+        status: string;
+        members: unknown[];
+    }>;
+    /**
+     * Destroy a mob and surface the structured `MobDestroyReport`.
+     * Wraps the `mob/destroy` RPC (DELETE_ME C3). Unlike `mob/lifecycle`
+     * with `action: "destroy"`, this dedicated endpoint has a predictable
+     * response shape that does not require branching on an action string.
+     */
+    mobDestroy(mobId: string): Promise<{
+        mobId: string;
+        ok: boolean;
+        destroyReport: Record<string, unknown>;
+    }>;
+    /**
+     * Rotate the supervisor bridge for all members of a mob.
+     * Wraps the `mob/rotate_supervisor` RPC (DELETE_ME C10). Returns the
+     * full `SupervisorRotationReport` so operators can inspect per-member
+     * rotation outcomes instead of getting a bare `ok: true`.
+     */
+    mobRotateSupervisor(mobId: string): Promise<MobRotateSupervisorResult>;
+    /**
+     * Submit a unit of work to a mob member through the work lane.
+     * Wraps the `mob/submit_work` RPC (DELETE_ME C4). Work lane was
+     * Rust-only prior to this; `origin` is `"external"` for
+     * user-originated turns and `"internal"` for mob-orchestration work.
+     * When `workRef` is omitted the server generates a fresh UUID.
+     */
+    mobSubmitWork(args: {
+        memberRef: string;
+        content: unknown;
+        workRef?: string;
+        origin?: "external" | "internal";
+    }): Promise<{
+        mobId: string;
+        workRef: string;
+        memberRef: string;
+    }>;
+    /**
+     * Cancel a previously submitted unit of work.
+     * Wraps the `mob/cancel_work` RPC (DELETE_ME C4).
+     */
+    mobCancelWork(mobId: string, workRef: string): Promise<{
+        ok: boolean;
+    }>;
+    /**
+     * Cancel all in-flight work for a specific mob member.
+     * Wraps the `mob/cancel_all_work` RPC (DELETE_ME C4).
+     */
+    mobCancelAllWork(args: {
+        memberRef: string;
+    }): Promise<{
+        ok: boolean;
     }>;
     waitMobKickoff(mobId: string, options?: MobKickoffWaitOptions): Promise<MobKickoffMemberSnapshot[]>;
+    waitMobReady(mobId: string, options?: MobReadyWaitOptions): Promise<MobReadyMemberSnapshot[]>;
     wait_mob_kickoff(mobId: string, options?: MobKickoffWaitOptions): Promise<MobKickoffMemberSnapshot[]>;
+    wait_mob_ready(mobId: string, options?: MobReadyWaitOptions): Promise<MobReadyMemberSnapshot[]>;
     spawnMobHelper(mobId: string, prompt: string, options?: {
-        meerkatId?: string;
+        agentIdentity?: string;
+        roleName?: string;
         profileName?: string;
         runtimeMode?: string;
         backend?: string;
     }): Promise<{
         output?: string;
         tokensUsed: number;
-        sessionId?: string;
+        agentIdentity: string;
+        memberRef: MobMemberRef;
     }>;
     forkMobHelper(mobId: string, sourceMemberId: string, prompt: string, options?: {
-        meerkatId?: string;
+        agentIdentity?: string;
+        roleName?: string;
         profileName?: string;
         forkContext?: Record<string, unknown>;
         runtimeMode?: string;
@@ -192,68 +288,133 @@ export declare class MeerkatClient {
     }): Promise<{
         output?: string;
         tokensUsed: number;
-        sessionId?: string;
+        agentIdentity: string;
+        memberRef: MobMemberRef;
     }>;
     wireMobMembers(mobId: string, member: string, peer: MobPeerTarget): Promise<void>;
     unwireMobMembers(mobId: string, member: string, peer: MobPeerTarget): Promise<void>;
-    mobLifecycle(mobId: string, action: 'stop' | 'resume' | 'complete' | 'reset' | 'destroy'): Promise<void>;
-    appendMobSystemContext(mobId: string, meerkatId: string, text: string, options?: {
+    mobLifecycle(mobId: string, action: MobLifecycleAction): Promise<void>;
+    appendMobSystemContext(mobId: string, agentIdentity: string, text: string, options?: {
         source?: string;
         idempotencyKey?: string;
     }): Promise<Record<string, unknown>>;
+    readMobEvents(mobId: string, options?: MobEventsOptions): Promise<MobEventsResult>;
+    mobIngressInteraction(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    createMobProfile(name: string, profile: MobProfile): Promise<MobProfileLookupResult>;
+    getMobProfile(name: string): Promise<MobProfileLookupResult>;
+    listMobProfiles(): Promise<MobProfileLookupResult[]>;
+    updateMobProfile(name: string, profile: MobProfile, expectedRevision: number): Promise<MobProfileLookupResult>;
+    deleteMobProfile(name: string, expectedRevision: number): Promise<MobProfileDeleteResult>;
     listMobFlows(mobId: string): Promise<string[]>;
     runMobFlow(mobId: string, flowId: string, params?: Record<string, unknown>): Promise<string>;
     getMobFlowStatus(mobId: string, runId: string): Promise<MobFlowStatus | null>;
     cancelMobFlow(mobId: string, runId: string): Promise<void>;
     subscribeMobEvents(mobId: string): Promise<EventSubscription<AttributedMobEvent>>;
-    subscribeMobMemberEvents(mobId: string, meerkatId: string): Promise<EventSubscription<AgentEventEnvelope>>;
+    subscribeMobMemberEvents(mobId: string, agentIdentity: string): Promise<EventSubscription<AgentEventEnvelope>>;
     private openEventSubscription;
     private static parseAgentEventEnvelope;
+    private static parseEventSourceIdentity;
+    private static parseOptionalString;
+    private static parseOptionalNumber;
     private static parseAttributedMobEvent;
     /** @internal */
-    _startTurn(sessionId: string, prompt: string | ContentBlock[], options?: {
-        skillRefs?: SkillRef[];
-        skillReferences?: string[];
-        flowToolOverlay?: TurnToolOverlay;
-        keepAlive?: boolean;
-        model?: string;
-        provider?: string;
-        maxTokens?: number;
-        systemPrompt?: string;
-        outputSchema?: Record<string, unknown>;
-        structuredOutputRetries?: number;
-        providerParams?: Record<string, unknown>;
-    }): Promise<RunResult>;
+    _startTurn(sessionId: string, prompt: string | ContentBlock[], options?: TurnOptions): Promise<RunResult>;
     /** @internal */
-    _startTurnStreaming(sessionId: string, prompt: string | ContentBlock[], options?: {
-        skillRefs?: SkillRef[];
-        skillReferences?: string[];
-        flowToolOverlay?: TurnToolOverlay;
-    }, session?: Session): EventStream;
+    _startTurnStreaming(sessionId: string, prompt: string | ContentBlock[], options?: TurnOptions, session?: Session): EventStream;
     /** @internal */
     _interrupt(sessionId: string): Promise<void>;
     /** @internal */
     _archive(sessionId: string): Promise<void>;
+    private static retiredRuntimeSessionControlError;
+    /**
+     * @internal
+     * @deprecated Retired runtime/session control RPC method; always fails before transport.
+     */
+    _runtimeStatus(_params: Record<string, unknown>): Promise<never>;
+    /**
+     * @internal
+     * @deprecated Retired runtime/session control RPC method; always fails before transport.
+     */
+    _runtimeSubmit(_params: Record<string, unknown>): Promise<never>;
+    /**
+     * @internal
+     * @deprecated Retired runtime/session control RPC method; always fails before transport.
+     */
+    _runtimeSubmission(_params: Record<string, unknown>): Promise<never>;
+    /**
+     * @internal
+     * @deprecated Retired runtime/session control RPC method; always fails before transport.
+     */
+    _runtimeSubmissions(_params: Record<string, unknown>): Promise<never>;
+    /**
+     * @internal
+     * @deprecated Retired runtime/session control RPC method; always fails before transport.
+     */
+    _runtimeRetire(_params: Record<string, unknown>): Promise<never>;
+    /**
+     * @internal
+     * @deprecated Retired runtime/session control RPC method; always fails before transport.
+     */
+    _runtimeReset(_params: Record<string, unknown>): Promise<never>;
     /** @internal */
-    _send(sessionId: string, command: Record<string, unknown>): Promise<Record<string, unknown>>;
+    _send(sessionId: string, command: CommsCommand): Promise<CommsSendReceipt>;
     /** @internal */
     _peers(sessionId: string): Promise<Record<string, unknown>>;
-    send(sessionId: string, command: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Send a typed comms command. Invalid discriminators (`source`, `stream`,
+     * `handling_mode`, `status`) are rejected at the server's typed-serde
+     * boundary.
+     */
+    send(sessionId: string, command: CommsCommand): Promise<CommsSendReceipt>;
     peers(sessionId: string): Promise<Record<string, unknown>>;
-    runtimeState(sessionId: string): Promise<RuntimeStateResult>;
-    runtimeAccept(sessionId: string, input: Record<string, unknown>): Promise<RuntimeAcceptResult>;
-    runtimeRetire(sessionId: string): Promise<RuntimeRetireResult>;
-    runtimeReset(sessionId: string): Promise<RuntimeResetResult>;
-    inputState(sessionId: string, inputId: string): Promise<WireInputState | null>;
-    inputList(sessionId: string): Promise<string[]>;
+    runtimeRealtimeAttachmentStatus(sessionId: string): Promise<RuntimeRealtimeAttachmentStatusResult>;
+    /** Idempotent spawn: spawns or returns the existing member entry. */
+    mobEnsureMember(mobId: string, spec: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Declarative reconcile: converge roster to the desired spec list. */
+    mobReconcile(mobId: string, desired: Record<string, unknown>[], options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Label-filtered member listing. */
+    mobListMembersMatching(mobId: string, filter: Record<string, unknown>): Promise<Record<string, unknown>>;
+    realtimeOpenInfo(request: RealtimeOpenRequest): Promise<RealtimeOpenInfo>;
+    realtimeStatus(params: {
+        target: Record<string, unknown>;
+    }): Promise<RealtimeStatusResult>;
+    realtimeCapabilities(params: {
+        target: Record<string, unknown>;
+    }): Promise<RealtimeCapabilitiesResult>;
+    realmList(): Promise<unknown>;
+    realmGet(realmId: string): Promise<unknown>;
+    authProfileList(realmId: string): Promise<unknown>;
+    authProfileGet(realmId: string, bindingId: string, profileId?: string): Promise<unknown>;
+    authProfileCreate(params: Record<string, unknown>): Promise<unknown>;
+    authProfileDelete(realmId: string, bindingId: string, profileId?: string): Promise<unknown>;
+    authLoginStart(params: Record<string, unknown>): Promise<unknown>;
+    authLoginComplete(params: Record<string, unknown>): Promise<unknown>;
+    authLoginDeviceStart(params: Record<string, unknown>): Promise<unknown>;
+    authLoginDeviceComplete(params: Record<string, unknown>): Promise<unknown>;
+    authLoginProvisionApiKey(params: Record<string, unknown>): Promise<unknown>;
+    authStatusGet(realmId: string, bindingId: string, profileId?: string): Promise<unknown>;
+    authLogout(realmId: string, bindingId: string, profileId?: string): Promise<unknown>;
     private handleLine;
     private static parseRpcErrorPayload;
     private request;
     private registerRequest;
     private static normalizeStatus;
+    private static requireRecord;
+    private static requireStringField;
+    private static requireNumberField;
+    private static requireBooleanField;
     private static parseSkillDiagnostics;
     private static checkVersionCompatible;
     static parseRunResult(data: Record<string, unknown>): RunResult;
+    static parseSessionInfo(data: Record<string, unknown>): SessionInfo;
+    static parseConfigEnvelope(data: Record<string, unknown>): ConfigEnvelope;
+    static parseCommsSendReceipt(data: Record<string, unknown>): CommsSendReceipt;
+    static parseModelsCatalog(data: Record<string, unknown>): ModelsCatalog;
+    static parseSchedule(data: Record<string, unknown>): Schedule;
+    static parseScheduleOccurrence(data: Record<string, unknown>): ScheduleOccurrencesResult["occurrences"][number];
+    static parseMobProfileLookup(data: Record<string, unknown>): MobProfileLookupResult;
+    private static toWireCreateScheduleRequest;
+    private static toWireUpdateSchedulePatch;
     static parseSessionHistory(data: Record<string, unknown>): SessionHistory;
     static parseSessionMessage(data: Record<string, unknown>): SessionMessage;
     static parseContentInput(value: unknown): ContentInput;