@rkat/sdk 0.7.30 → 0.8.0

package/dist/client.js

@@ -32,7 +32,7 @@ import path from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { createInterface } from "node:readline";
 import { Buffer } from "node:buffer";
-import { MeerkatError, CapabilityUnavailableError } from "./generated/errors.js";
+import { MeerkatError, CapabilityUnavailableError, meerkatErrorFromJsonRpcCode, } from "./generated/errors.js";
 import { isCompatibleWith } from "./generated/version_compat.js";
 import { CONTRACT_VERSION, } from "./generated/types.js";
 import { DeferredSession, Session } from "./session.js";
@@ -53,6 +53,7 @@ const MOB_SPAWN_MANY_FAILURE_CAUSES = new Set([
     "wiring_error",
     "bridge_command_rejected",
     "member_restore_failed",
+    "missing_member_capability",
     "kickoff_wait_timed_out",
     "ready_wait_timed_out",
     "definition_error",
@@ -104,6 +105,18 @@ function skillRefsToWire(refs) {
     const keys = skillKeysToWire(refs);
     return keys?.map((key) => ({ kind: "structured", ...key }));
 }
+const MOB_CONTROL_SCOPES = new Set([
+    "list",
+    "read_history",
+    "subscribe_events",
+    "send_command",
+    "cancel",
+    "retire",
+    "wire_topology",
+    "live",
+    "admin_host",
+    "admin_grants",
+]);
 function setIfDefined(payload, key, value) {
     if (value !== undefined) {
         payload[key] = value;
@@ -121,12 +134,12 @@ function mobSpawnPayload(mobId, spec) {
     setIfDefined(payload, "labels", spec.labels);
     setIfDefined(payload, "context", spec.context);
     setIfDefined(payload, "additional_instructions", spec.additionalInstructions);
+    setIfDefined(payload, "placement", spec.placement);
     setIfDefined(payload, "binding", spec.binding);
     setIfDefined(payload, "shell_env", spec.shellEnv);
     setIfDefined(payload, "auto_wire_parent", spec.autoWireParent);
     setIfDefined(payload, "launch_mode", spec.launchMode);
     setIfDefined(payload, "tool_access_policy", spec.toolAccessPolicy);
-    setIfDefined(payload, "budget_split_policy", spec.budgetSplitPolicy);
     setIfDefined(payload, "inherited_tool_filter", spec.inheritedToolFilter);
     setIfDefined(payload, "override_profile", spec.overrideProfile);
     setIfDefined(payload, "model_override", spec.modelOverride);
@@ -144,6 +157,7 @@ function mobSpawnManySpecPayload(spec) {
     setIfDefined(payload, "labels", spec.labels);
     setIfDefined(payload, "context", spec.context);
     setIfDefined(payload, "additional_instructions", spec.additionalInstructions);
+    setIfDefined(payload, "placement", spec.placement);
     setIfDefined(payload, "auth_binding", spec.authBinding);
     setIfDefined(payload, "model_override", spec.modelOverride);
     return payload;
@@ -171,6 +185,7 @@ function mobTurnStartPayload(mobId, agentIdentity, prompt, options) {
     setIfDefined(payload, "keep_alive", options?.keepAlive);
     setIfDefined(payload, "model", options?.model);
     setIfDefined(payload, "provider", options?.provider);
+    setIfDefined(payload, "self_hosted_server_id", options?.selfHostedServerId);
     setIfDefined(payload, "max_tokens", options?.maxTokens);
     setIfDefined(payload, "system_prompt", options?.systemPrompt);
     setIfDefined(payload, "output_schema", options?.outputSchema);
@@ -620,7 +635,8 @@ export class MeerkatClient {
             params.idempotency_key = options.idempotencyKey;
         }
         const result = await this.request("session/inject_context", params);
-        return { status: String(result.status ?? "") };
+        const status = MeerkatClient.requireClosedStringField(result, "status", ["applied", "staged", "duplicate"], "Invalid session/inject_context response");
+        return { status };
     }
     /**
      * Read an input's stored runtime state (terminal outcome, run
@@ -682,6 +698,9 @@ export class MeerkatClient {
         if (options?.runningBehavior !== undefined) {
             params.running_behavior = options.runningBehavior;
         }
+        if (options?.toolAccessPolicy !== undefined) {
+            params.tool_access_policy = options.toolAccessPolicy;
+        }
         const raw = await this.request("session/fork_at", params);
         return MeerkatClient.parseSessionForkResult(raw);
     }
@@ -694,6 +713,9 @@ export class MeerkatClient {
         if (options?.runningBehavior !== undefined) {
             params.running_behavior = options.runningBehavior;
         }
+        if (options?.toolAccessPolicy !== undefined) {
+            params.tool_access_policy = options.toolAccessPolicy;
+        }
         const raw = await this.request("session/fork_replace", params);
         return MeerkatClient.parseSessionForkResult(raw);
     }
@@ -1133,6 +1155,232 @@ export class MeerkatClient {
             agent_identity: agentIdentity,
         });
     }
+    /**
+     * Record (full-replace) a principal's control-scope grant
+     * (`mob/grant_scopes`).
+     */
+    async grantMobScopes(mobId, principal, scopes, expiresAtMs) {
+        const result = await this.request("mob/grant_scopes", {
+            mob_id: mobId,
+            principal,
+            scopes,
+            ...(expiresAtMs !== undefined ? { expires_at_ms: expiresAtMs } : {}),
+        });
+        const context = "Invalid mob/grant_scopes response";
+        const record = MeerkatClient.requireRecord(result.record, "record", context);
+        return MeerkatClient.decodeMobGrantRecord(record, context);
+    }
+    /**
+     * Revoke scopes from a principal's grant (`mob/revoke_scopes`); omit
+     * `scopes` to revoke the entire grant. Returns whether the grant record
+     * was removed entirely — revoking never-granted scopes is an idempotent
+     * no-op (`false`).
+     */
+    async revokeMobScopes(mobId, principal, scopes) {
+        const result = await this.request("mob/revoke_scopes", {
+            mob_id: mobId,
+            principal,
+            ...(scopes !== undefined ? { scopes } : {}),
+        });
+        if (typeof result.removed !== "boolean") {
+            throw new MeerkatError("INVALID_RESPONSE", "Invalid mob/revoke_scopes response: missing removed");
+        }
+        return result.removed;
+    }
+    /**
+     * List raw control-scope grant records (`mob/grants`). Expired rows
+     * preserve the generated `expires_at_ms` wire field verbatim.
+     */
+    async listMobGrants(mobId) {
+        const result = await this.request("mob/grants", { mob_id: mobId });
+        const context = "Invalid mob/grants response";
+        const grants = result.grants;
+        if (!Array.isArray(grants)) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: missing grants`);
+        }
+        return grants.map((entry) => MeerkatClient.decodeMobGrantRecord(MeerkatClient.requireObject(entry, context), context));
+    }
+    static requireObject(value, context) {
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: expected an object entry`);
+        }
+        return value;
+    }
+    static decodeMobGrantRecord(record, context) {
+        const principal = MeerkatClient.requireStringField(record, "principal", context);
+        const scopes = record.scopes;
+        if (!Array.isArray(scopes) ||
+            scopes.some((scope) => typeof scope !== "string" ||
+                !MOB_CONTROL_SCOPES.has(scope))) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: record scopes must use the closed control-scope vocabulary`);
+        }
+        let expiresAtMs;
+        if (Object.prototype.hasOwnProperty.call(record, "expires_at_ms")) {
+            expiresAtMs = MeerkatClient.requireNonNegativeIntegerField(record, "expires_at_ms", context);
+        }
+        return {
+            principal,
+            scopes: scopes,
+            ...(expiresAtMs !== undefined ? { expires_at_ms: expiresAtMs } : {}),
+        };
+    }
+    // ─── Multi-host console verbs (phase 7, DEC-P7A-9) ────────────────────
+    /**
+     * Read a mob member transcript page by identity (`mob/member_history`).
+     * One shape local and remote; the envelope carries typed placement +
+     * provenance facts.
+     */
+    async mobMemberHistory(mobId, agentIdentity, opts) {
+        const result = await this.request("mob/member_history", {
+            mob_id: mobId,
+            agent_identity: agentIdentity,
+            ...(opts?.fromIndex !== undefined ? { from_index: opts.fromIndex } : {}),
+            ...(opts?.limit !== undefined ? { limit: opts.limit } : {}),
+        });
+        const context = "Invalid mob/member_history response";
+        const page = MeerkatClient.requireRecord(result.page, "page", context);
+        const messages = MeerkatClient.requireRecordArray(page.messages, `${context}: page.messages`);
+        messages.forEach((message, index) => MeerkatClient.validateWireHistoryRow(message, `${context}: page.messages[${index}]`));
+        MeerkatClient.requireBooleanField(page, "complete", `${context}: page`);
+        const fromIndex = MeerkatClient.requireNonNegativeIntegerField(page, "from_index", `${context}: page`);
+        const messageCount = MeerkatClient.requireNonNegativeIntegerField(page, "message_count", `${context}: page`);
+        const hasNextIndex = Object.prototype.hasOwnProperty.call(page, "next_index");
+        if (hasNextIndex) {
+            MeerkatClient.requireNonNegativeIntegerField(page, "next_index", `${context}: page`);
+        }
+        const pageEnd = fromIndex + messages.length;
+        if (pageEnd > messageCount) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: page ends beyond message_count`);
+        }
+        const complete = page.complete;
+        if (complete !== (pageEnd === messageCount)) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: complete must match whether the page reaches message_count`);
+        }
+        if (complete && hasNextIndex) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: complete page must not carry next_index`);
+        }
+        if (!complete) {
+            if (messages.length === 0) {
+                throw new MeerkatError("INVALID_RESPONSE", `${context}: incomplete page must make progress`);
+            }
+            if (!hasNextIndex || page.next_index !== pageEnd) {
+                throw new MeerkatError("INVALID_RESPONSE", `${context}: incomplete page next_index must equal served end`);
+            }
+        }
+        MeerkatClient.requireNonNegativeIntegerField(result, "generation", context);
+        const provenance = MeerkatClient.requireStringField(result, "provenance", context);
+        if (provenance !== "host_claimed" && provenance !== "controlling_host_verified") {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: unsupported provenance ${JSON.stringify(provenance)}`);
+        }
+        const placement = MeerkatClient.optionalStringField(result, "placement", context);
+        if (placement === "") {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: placement must be non-empty`);
+        }
+        return result;
+    }
+    /** List tracked member hosts with bind phase and declared capabilities. */
+    async mobHosts(mobId) {
+        const result = await this.request("mob/hosts", { mob_id: mobId });
+        const hosts = result.hosts;
+        if (!Array.isArray(hosts)) {
+            throw new MeerkatError("INVALID_RESPONSE", "Invalid mob/hosts response: missing hosts");
+        }
+        return hosts.map((row, index) => MeerkatClient.parseMobHostStatus(row, `Invalid mob/hosts response: hosts[${index}]`));
+    }
+    /** Outstanding cross-host route-install obligations. */
+    async mobRouteInstalls(mobId) {
+        const result = await this.request("mob/route_installs", { mob_id: mobId });
+        const context = "Invalid mob/route_installs response";
+        const outstanding = MeerkatClient.requireRecordArray(result.outstanding, `${context}: outstanding`);
+        outstanding.forEach((row, index) => MeerkatClient.parseRouteInstallObligation(row, `${context}: outstanding[${index}]`));
+        MeerkatClient.requireBooleanField(result, "complete", context);
+        return result;
+    }
+    /** Bind a member-host daemon from its binding descriptor. */
+    async bindMobHost(mobId, descriptor) {
+        const result = await this.request("mob/bind_host", {
+            mob_id: mobId,
+            descriptor,
+        });
+        const context = "Invalid mob/bind_host response";
+        MeerkatClient.requireStringField(result, "host_id", context);
+        MeerkatClient.requireNonNegativeIntegerField(result, "authority_epoch", context);
+        const capabilities = MeerkatClient.parseMobHostCapabilities(result.capabilities, `${context}: capabilities`);
+        return { ...result, capabilities };
+    }
+    /** Revoke a bound (or bind-requested) member host. */
+    async revokeMobHost(mobId, hostId) {
+        const result = await this.request("mob/revoke_host", {
+            mob_id: mobId,
+            host_id: hostId,
+        });
+        const context = "Invalid mob/revoke_host response";
+        MeerkatClient.requireStringField(result, "host_id", context);
+        MeerkatClient.requireStringArray(result.released_members, `${context}: released_members`);
+        return result;
+    }
+    /** Hard-cancel a mob member; `reason` is required. */
+    async hardCancelMobMember(mobId, agentIdentity, reason) {
+        const result = await this.request("mob/hard_cancel_member", {
+            mob_id: mobId,
+            agent_identity: agentIdentity,
+            reason,
+        });
+        if (typeof result.cancelled !== "boolean") {
+            throw new MeerkatError("INVALID_RESPONSE", "Invalid mob/hard_cancel_member response: missing cancelled");
+        }
+        return result.cancelled;
+    }
+    /** Open a live realtime channel on a mob member. */
+    async openMobMemberLive(mobId, agentIdentity, opts) {
+        const result = await this.request("mob/member_live_open", {
+            mob_id: mobId,
+            agent_identity: agentIdentity,
+            ...(opts?.turningMode !== undefined ? { turning_mode: opts.turningMode } : {}),
+            ...(opts?.transport !== undefined ? { transport: opts.transport } : {}),
+        });
+        return MeerkatClient.parseLiveOpenResult(result, "Invalid mob/member_live_open response");
+    }
+    /** Close one named live channel on a mob member. */
+    async closeMobMemberLive(mobId, agentIdentity, channelId) {
+        const result = await this.request("mob/member_live_close", {
+            mob_id: mobId,
+            agent_identity: agentIdentity,
+            channel_id: channelId,
+        });
+        return MeerkatClient.parseLiveCloseResult(result);
+    }
+    /** Read live channel status for a mob member. */
+    async mobMemberLiveStatus(mobId, agentIdentity, channelId) {
+        const result = await this.request("mob/member_live_status", {
+            mob_id: mobId,
+            agent_identity: agentIdentity,
+            ...(channelId !== undefined ? { channel_id: channelId } : {}),
+        });
+        return MeerkatClient.parseLiveStatusResult(result, "Invalid mob/member_live_status response");
+    }
+    /** Drive one turn-level live control verb on a member channel. */
+    async controlMobMemberLive(mobId, agentIdentity, channelId, verb) {
+        const result = await this.request("mob/member_live_control", {
+            mob_id: mobId,
+            agent_identity: agentIdentity,
+            channel_id: channelId,
+            verb,
+        });
+        const context = "Invalid mob/member_live_control response";
+        const resultVerb = MeerkatClient.requireStringField(result, "verb", context);
+        const status = MeerkatClient.requireStringField(result, "status", context);
+        const expectedStatus = {
+            commit_input: "committed",
+            interrupt: "interrupted",
+            truncate: "truncated",
+            refresh: "queued",
+        };
+        if (expectedStatus[resultVerb] !== status || resultVerb !== verb.verb) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: mismatched verb/status outcome`);
+        }
+        return result;
+    }
     async respawnMobMember(mobId, agentIdentity, initialMessage) {
         const result = await this.request("mob/respawn", {
             mob_id: mobId,
@@ -1206,6 +1454,15 @@ export class MeerkatClient {
         if (result.progress !== undefined && result.progress !== null) {
             snapshot.progress = MeerkatClient.parseMemberProgressSnapshot(result.progress, "Invalid mob/member_status response");
         }
+        snapshot.placement = MeerkatClient.optionalStringField(result, "placement", "Invalid mob/member_status response");
+        snapshot.controlReachability = MeerkatClient.parseWireReachability(result.control_reachability, "control_reachability");
+        snapshot.commsReachability = MeerkatClient.parseWireReachability(result.comms_reachability, "comms_reachability");
+        if (result.last_seen_ms != null) {
+            snapshot.lastSeenMs = MeerkatClient.requireNonNegativeIntegerField(result, "last_seen_ms", "Invalid mob/member_status response");
+        }
+        snapshot.freshnessReason = MeerkatClient.optionalStringField(result, "freshness_reason", "Invalid mob/member_status response");
+        snapshot.lifecycleCapabilities = MeerkatClient.parseMemberLifecycleCapabilities(result.lifecycle_capabilities);
+        snapshot.nonPortableDisabled = MeerkatClient.parseNonPortableDisabled(result.non_portable_disabled);
         return snapshot;
     }
     /**
@@ -1688,7 +1945,7 @@ export class MeerkatClient {
         const source = MeerkatClient.requireRecord(raw.source, "source", context);
         const identity = MeerkatClient.requireStringField(source, "identity", context);
         const generation = MeerkatClient.requireNumberField(source, "generation", context);
-        if (!Number.isInteger(generation) || generation < 0) {
+        if (!Number.isSafeInteger(generation) || generation < 0) {
             throw new MeerkatError("INVALID_RESPONSE", `${context}: source generation must be a non-negative integer`);
         }
         const role = MeerkatClient.requireStringField(raw, "role", context);
@@ -1724,10 +1981,14 @@ export class MeerkatClient {
             params.model = options.model;
         if (options?.provider)
             params.provider = options.provider;
+        if (options?.selfHostedServerId != null) {
+            params.self_hosted_server_id = options.selfHostedServerId;
+        }
         if (options?.maxTokens)
             params.max_tokens = options.maxTokens;
-        if (options?.systemPrompt)
+        if (options?.systemPrompt !== undefined) {
             params.system_prompt = options.systemPrompt;
+        }
         if (options?.outputSchema)
             params.output_schema = options.outputSchema;
         if (options?.structuredOutputRetries != null) {
@@ -1771,10 +2032,14 @@ export class MeerkatClient {
             params.model = options.model;
         if (options?.provider)
             params.provider = options.provider;
+        if (options?.selfHostedServerId != null) {
+            params.self_hosted_server_id = options.selfHostedServerId;
+        }
         if (options?.maxTokens)
             params.max_tokens = options.maxTokens;
-        if (options?.systemPrompt)
+        if (options?.systemPrompt !== undefined) {
             params.system_prompt = options.systemPrompt;
+        }
         if (options?.outputSchema)
             params.output_schema = options.outputSchema;
         if (options?.structuredOutputRetries != null) {
@@ -1865,7 +2130,11 @@ export class MeerkatClient {
         return MeerkatClient.parseCommsSendReceipt(result);
     }
     async peers(sessionId) {
-        return this.request("comms/peers", { session_id: sessionId });
+        const result = await this.request("comms/peers", { session_id: sessionId });
+        if (!Array.isArray(result.peers)) {
+            throw new MeerkatError("INVALID_RESPONSE", "Invalid comms/peers response: missing peers");
+        }
+        return { peers: result.peers };
     }
     /** Idempotent spawn: spawns or returns the existing member entry. */
     async mobEnsureMember(mobId, spec) {
@@ -1895,7 +2164,7 @@ export class MeerkatClient {
     // schemas regenerated into `./generated/types.ts`. See I52/I53.
     async liveOpen(params) {
         const result = await this.request("live/open", params);
-        return result;
+        return MeerkatClient.parseLiveOpenResult(result, "Invalid live/open response");
     }
     async liveWebrtcAnswer(params) {
         const result = await this.request("live/webrtc/answer", params);
@@ -1903,7 +2172,7 @@ export class MeerkatClient {
     }
     async liveStatus(params) {
         const result = await this.request("live/status", params);
-        return result;
+        return MeerkatClient.parseLiveStatusResult(result, "Invalid live/status response");
     }
     async liveClose(params) {
         const result = await this.request("live/close", params);
@@ -2132,7 +2401,18 @@ export class MeerkatClient {
                 const error = data.error;
                 if (error) {
                     const normalized = MeerkatClient.parseRpcErrorPayload(error);
-                    pending.reject(new MeerkatError(normalized.code, normalized.message, normalized.details));
+                    const errorData = typeof error.data === "object" &&
+                        error.data !== null &&
+                        !Array.isArray(error.data)
+                        ? error.data
+                        : undefined;
+                    const semanticCode = typeof errorData?.code === "string" && errorData.code.length > 0
+                        ? errorData.code
+                        : undefined;
+                    const rpcCode = typeof error.code === "number" || typeof error.code === "string"
+                        ? error.code
+                        : "UNKNOWN";
+                    pending.reject(meerkatErrorFromJsonRpcCode(rpcCode, semanticCode, normalized.message, normalized.details));
                 }
                 else {
                     pending.resolve((data.result ?? {}));
@@ -2266,6 +2546,31 @@ export class MeerkatClient {
         }
         return value;
     }
+    static requireOwnField(raw, field, context) {
+        if (!Object.prototype.hasOwnProperty.call(raw, field)) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: missing ${field}`);
+        }
+        return raw[field];
+    }
+    static requireClosedStringField(raw, field, allowed, context) {
+        const value = MeerkatClient.requirePresentStringField(raw, field, context);
+        if (!allowed.includes(value)) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: unsupported ${field} ${JSON.stringify(value)}`);
+        }
+        return value;
+    }
+    static validateOptionalStringField(raw, field, context) {
+        if (Object.prototype.hasOwnProperty.call(raw, field) &&
+            typeof raw[field] !== "string") {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: ${field} must be string`);
+        }
+    }
+    static validateOptionalBooleanField(raw, field, context) {
+        if (Object.prototype.hasOwnProperty.call(raw, field) &&
+            typeof raw[field] !== "boolean") {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: ${field} must be boolean`);
+        }
+    }
     static requireNumberField(raw, field, context, displayField = field) {
         if (!(field in raw)) {
             throw new MeerkatError("INVALID_RESPONSE", `${context}: missing ${displayField}`);
@@ -2278,14 +2583,15 @@ export class MeerkatClient {
     }
     /**
      * Require a wire count/total field (Rust `usize`/`u64`). A present value
-     * that is fractional or negative can never be a valid unsigned integer, so
-     * it is a contract violation and fails closed instead of being accepted as
-     * an any-finite-number. Mirrors the web SDK `requireNonNegativeIntegerField`
-     * and Python `_require_non_negative_integer_field`.
+     * that is fractional, negative, or outside JavaScript's lossless integer
+     * range can never be represented faithfully, so it is a contract violation
+     * and fails closed instead of being accepted as an any-finite-number.
+     * Mirrors the web SDK `requireNonNegativeIntegerField` and Python
+     * `_require_non_negative_integer_field`.
      */
     static requireNonNegativeIntegerField(raw, field, context, displayField = field) {
         const value = MeerkatClient.requireNumberField(raw, field, context, displayField);
-        if (!Number.isInteger(value) || value < 0) {
+        if (!Number.isSafeInteger(value) || value < 0) {
             throw new MeerkatError("INVALID_RESPONSE", `${context}: ${displayField} must be a non-negative integer`);
         }
         return value;
@@ -2307,6 +2613,367 @@ export class MeerkatClient {
         }
         return value;
     }
+    static validateGeneratedContentBlock(raw, context, systemNoticeContent) {
+        const allowed = systemNoticeContent
+            ? ["text", "image", "video", "structured", "skill_context"]
+            : ["text", "image", "video", "structured", "unknown"];
+        const type = MeerkatClient.requireClosedStringField(raw, "type", allowed, context);
+        if (type === "text") {
+            MeerkatClient.requirePresentStringField(raw, "text", context);
+        }
+        else if (type === "image") {
+            MeerkatClient.requirePresentStringField(raw, "media_type", context);
+        }
+        else if (type === "video") {
+            MeerkatClient.requirePresentStringField(raw, "media_type", context);
+            MeerkatClient.requireNonNegativeIntegerField(raw, "duration_ms", context);
+        }
+        else if (type === "structured") {
+            MeerkatClient.requireOwnField(raw, "data", context);
+        }
+        else if (type === "skill_context") {
+            const skillKey = MeerkatClient.requireRecord(raw.skill_key, "skill_key", context);
+            MeerkatClient.requireStringField(skillKey, "source_uuid", `${context}: skill_key`);
+            MeerkatClient.requireStringField(skillKey, "skill_name", `${context}: skill_key`);
+            MeerkatClient.requirePresentStringField(raw, "text", context);
+        }
+    }
+    static validateOptionalMetaRecord(raw, context) {
+        if (Object.prototype.hasOwnProperty.call(raw, "meta")) {
+            MeerkatClient.requireRecord(raw.meta, "meta", context);
+        }
+    }
+    static validateToolConfigStatus(raw, context) {
+        const status = MeerkatClient.requireRecord(raw, "status_info", context);
+        const kind = MeerkatClient.requireClosedStringField(status, "kind", [
+            "boundary_applied",
+            "deferred_catalog_delta",
+            "warning_failed_closed",
+            "external_tool_delta",
+        ], context);
+        if (kind === "boundary_applied") {
+            MeerkatClient.requireBooleanField(status, "base_changed", context);
+            MeerkatClient.requireNonNegativeIntegerField(status, "revision", context);
+            MeerkatClient.requireBooleanField(status, "visible_changed", context);
+        }
+        else if (kind === "deferred_catalog_delta") {
+            MeerkatClient.requireNonNegativeIntegerField(status, "added_hidden_count", context);
+            MeerkatClient.requireNonNegativeIntegerField(status, "pending_source_count", context);
+            MeerkatClient.requireNonNegativeIntegerField(status, "removed_hidden_count", context);
+        }
+        else if (kind === "warning_failed_closed") {
+            MeerkatClient.requirePresentStringField(status, "error", context);
+        }
+        else {
+            MeerkatClient.requireClosedStringField(status, "phase", ["pending", "applied", "draining", "forced", "failed"], context);
+            MeerkatClient.validateOptionalStringField(status, "detail", context);
+        }
+    }
+    static validateToolConfigPayload(raw, context) {
+        const payload = MeerkatClient.requireRecord(raw, "payload", context);
+        MeerkatClient.requireClosedStringField(payload, "operation", ["add", "remove", "reload"], context);
+        MeerkatClient.requireBooleanField(payload, "persisted", context);
+        MeerkatClient.requirePresentStringField(payload, "target", context);
+        MeerkatClient.validateToolConfigStatus(payload.status_info, `${context}: status_info`);
+        if (Object.prototype.hasOwnProperty.call(payload, "applied_at_turn")) {
+            MeerkatClient.requireNonNegativeIntegerField(payload, "applied_at_turn", context);
+        }
+        if (Object.prototype.hasOwnProperty.call(payload, "domain")) {
+            MeerkatClient.requireClosedStringField(payload, "domain", ["tool_scope", "deferred_catalog"], context);
+        }
+        if (Object.prototype.hasOwnProperty.call(payload, "deferred_catalog_delta")) {
+            const delta = MeerkatClient.requireRecord(payload.deferred_catalog_delta, "deferred_catalog_delta", context);
+            for (const field of [
+                "added_hidden_names",
+                "pending_sources",
+                "removed_hidden_names",
+            ]) {
+                if (Object.prototype.hasOwnProperty.call(delta, field)) {
+                    MeerkatClient.requireStringArray(delta[field], `${context}: ${field}`);
+                }
+            }
+        }
+    }
+    static validateSystemNoticeBlock(raw, context) {
+        const type = MeerkatClient.requireClosedStringField(raw, "type", [
+            "comms",
+            "external_event",
+            "tool_config",
+            "mcp",
+            "background_job",
+            "auth",
+            "runtime_notice",
+            "unknown",
+        ], context);
+        const validateContent = () => {
+            if (!Object.prototype.hasOwnProperty.call(raw, "content"))
+                return;
+            MeerkatClient.requireRecordArray(raw.content, `${context}: content`).forEach((block, index) => MeerkatClient.validateGeneratedContentBlock(block, `${context}: content[${index}]`, true));
+        };
+        if (type === "comms") {
+            MeerkatClient.requireClosedStringField(raw, "direction", ["incoming", "outgoing", "internal"], context);
+            MeerkatClient.requirePresentStringField(raw, "kind", context);
+            for (const field of ["intent", "request_id", "status", "summary"]) {
+                MeerkatClient.validateOptionalStringField(raw, field, context);
+            }
+            if (Object.prototype.hasOwnProperty.call(raw, "peer")) {
+                const peer = MeerkatClient.requireRecord(raw.peer, "peer", context);
+                MeerkatClient.requireStringField(peer, "id", `${context}: peer`);
+                MeerkatClient.validateOptionalStringField(peer, "display_name", `${context}: peer`);
+            }
+            if (Object.prototype.hasOwnProperty.call(raw, "sender_taint")) {
+                MeerkatClient.requireClosedStringField(raw, "sender_taint", ["clean", "tainted"], context);
+            }
+            validateContent();
+        }
+        else if (type === "external_event") {
+            MeerkatClient.requirePresentStringField(raw, "event_type", context);
+            MeerkatClient.requirePresentStringField(raw, "source", context);
+            MeerkatClient.validateOptionalStringField(raw, "body", context);
+            MeerkatClient.validateOptionalStringField(raw, "summary", context);
+            validateContent();
+        }
+        else if (type === "tool_config") {
+            MeerkatClient.validateToolConfigPayload(raw.payload, `${context}: payload`);
+        }
+        else if (type === "mcp") {
+            for (const field of ["detail", "server_id"]) {
+                MeerkatClient.validateOptionalStringField(raw, field, context);
+            }
+            if (Object.prototype.hasOwnProperty.call(raw, "operation")) {
+                MeerkatClient.requireClosedStringField(raw, "operation", ["add", "remove", "reload"], context);
+            }
+            if (Object.prototype.hasOwnProperty.call(raw, "pending_sources")) {
+                MeerkatClient.requireStringArray(raw.pending_sources, `${context}: pending_sources`);
+            }
+            MeerkatClient.validateOptionalBooleanField(raw, "persisted", context);
+            if (Object.prototype.hasOwnProperty.call(raw, "phase")) {
+                MeerkatClient.requireClosedStringField(raw, "phase", ["pending", "applied", "draining", "forced", "failed"], context);
+            }
+        }
+        else if (type === "background_job") {
+            MeerkatClient.requireStringField(raw, "job_id", context);
+            MeerkatClient.requireClosedStringField(raw, "status", ["completed", "failed", "aborted", "cancelled", "retired", "terminated"], context);
+            MeerkatClient.validateOptionalStringField(raw, "detail", context);
+            MeerkatClient.validateOptionalStringField(raw, "display_name", context);
+        }
+        else if (type === "auth") {
+            MeerkatClient.requirePresentStringField(raw, "state", context);
+            MeerkatClient.validateOptionalStringField(raw, "binding", context);
+            MeerkatClient.validateOptionalStringField(raw, "detail", context);
+        }
+        else if (type === "runtime_notice") {
+            MeerkatClient.requirePresentStringField(raw, "category", context);
+            MeerkatClient.validateOptionalStringField(raw, "detail", context);
+        }
+        else {
+            MeerkatClient.validateOptionalStringField(raw, "summary", context);
+        }
+    }
+    static validateWireAssistantBlock(raw, context) {
+        const blockType = MeerkatClient.requireClosedStringField(raw, "block_type", [
+            "text",
+            "transcript",
+            "reasoning",
+            "tool_use",
+            "server_tool_content",
+            "image",
+            "unknown",
+        ], context);
+        if (blockType === "unknown")
+            return;
+        const data = MeerkatClient.requireRecord(raw.data, "data", context);
+        MeerkatClient.validateOptionalMetaRecord(data, `${context}: data`);
+        if (blockType === "text") {
+            MeerkatClient.requirePresentStringField(data, "text", `${context}: data`);
+        }
+        else if (blockType === "transcript") {
+            MeerkatClient.requirePresentStringField(data, "text", `${context}: data`);
+            const source = MeerkatClient.requireRecord(data.source, "source", `${context}: data`);
+            const sourceKind = MeerkatClient.requireClosedStringField(source, "kind", ["spoken", "unknown"], `${context}: data.source`);
+            if (sourceKind === "unknown") {
+                MeerkatClient.requirePresentStringField(source, "debug", `${context}: data.source`);
+            }
+        }
+        else if (blockType === "reasoning") {
+            MeerkatClient.validateOptionalStringField(data, "text", `${context}: data`);
+        }
+        else if (blockType === "tool_use") {
+            MeerkatClient.requireOwnField(data, "args", `${context}: data`);
+            MeerkatClient.requireStringField(data, "id", `${context}: data`);
+            MeerkatClient.requireStringField(data, "name", `${context}: data`);
+        }
+        else if (blockType === "server_tool_content") {
+            MeerkatClient.requireOwnField(data, "content", `${context}: data`);
+            MeerkatClient.requireRecord(data.kind, "kind", `${context}: data`);
+            MeerkatClient.validateOptionalStringField(data, "id", `${context}: data`);
+        }
+        else {
+            MeerkatClient.requireRecord(data.blob_ref, "blob_ref", `${context}: data`);
+            MeerkatClient.requireNonNegativeIntegerField(data, "height", `${context}: data`);
+            MeerkatClient.requireStringField(data, "image_id", `${context}: data`);
+            MeerkatClient.requirePresentStringField(data, "media_type", `${context}: data`);
+            MeerkatClient.requireRecord(data.meta, "meta", `${context}: data`);
+            MeerkatClient.requireRecord(data.revised_prompt, "revised_prompt", `${context}: data`);
+            MeerkatClient.requireNonNegativeIntegerField(data, "width", `${context}: data`);
+        }
+    }
+    static validateWireToolResult(raw, context) {
+        MeerkatClient.requireStringField(raw, "tool_use_id", context);
+        const content = MeerkatClient.requireOwnField(raw, "content", context);
+        if (typeof content !== "string" && !Array.isArray(content)) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: invalid content`);
+        }
+        if (Array.isArray(content)) {
+            MeerkatClient.requireRecordArray(content, `${context}: content`).forEach((block, index) => MeerkatClient.validateGeneratedContentBlock(block, `${context}: content[${index}]`, false));
+        }
+        MeerkatClient.validateOptionalBooleanField(raw, "is_error", context);
+    }
+    static validateWireHistoryRow(raw, context) {
+        const role = MeerkatClient.requireStringField(raw, "role", context);
+        MeerkatClient.requireStringField(raw, "created_at", context);
+        for (const field of ["interaction_id", "run_id"]) {
+            if (Object.prototype.hasOwnProperty.call(raw, field) &&
+                (typeof raw[field] !== "string" || raw[field].length === 0)) {
+                throw new MeerkatError("INVALID_RESPONSE", `${context}: ${field} must be non-empty string`);
+            }
+        }
+        if (role === "system") {
+            MeerkatClient.requirePresentStringField(raw, "content", context);
+            return;
+        }
+        if (role === "system_notice") {
+            const kind = MeerkatClient.requireStringField(raw, "kind", context);
+            if (![
+                "generic",
+                "comms",
+                "external_event",
+                "mcp_pending",
+                "mcp",
+                "background_job",
+                "tool_scope",
+                "tool_scope_warning",
+                "auth_reauth_required",
+            ].includes(kind)) {
+                throw new MeerkatError("INVALID_RESPONSE", `${context}: unsupported kind ${JSON.stringify(kind)}`);
+            }
+            MeerkatClient.validateOptionalStringField(raw, "body", context);
+            if (Object.prototype.hasOwnProperty.call(raw, "blocks")) {
+                MeerkatClient.requireRecordArray(raw.blocks, `${context}: blocks`).forEach((block, index) => MeerkatClient.validateSystemNoticeBlock(block, `${context}: blocks[${index}]`));
+            }
+            return;
+        }
+        if (role === "user") {
+            if (raw.content == null || (!Array.isArray(raw.content) && typeof raw.content !== "string")) {
+                throw new MeerkatError("INVALID_RESPONSE", `${context}: missing content`);
+            }
+            if (Array.isArray(raw.content)) {
+                MeerkatClient.requireRecordArray(raw.content, `${context}: content`).forEach((block, index) => MeerkatClient.validateGeneratedContentBlock(block, `${context}: content[${index}]`, false));
+            }
+            if (Object.prototype.hasOwnProperty.call(raw, "transcript_role")) {
+                MeerkatClient.requireClosedStringField(raw, "transcript_role", ["conversational", "compaction_summary", "injected_context"], context);
+            }
+            return;
+        }
+        if (role === "block_assistant") {
+            MeerkatClient.requireRecordArray(raw.blocks, `${context}: blocks`).forEach((block, index) => MeerkatClient.validateWireAssistantBlock(block, `${context}: blocks[${index}]`));
+            const stopReason = MeerkatClient.requireStringField(raw, "stop_reason", context);
+            if (![
+                "end_turn",
+                "tool_use",
+                "max_tokens",
+                "stop_sequence",
+                "content_filter",
+                "cancelled",
+            ].includes(stopReason)) {
+                throw new MeerkatError("INVALID_RESPONSE", `${context}: unsupported stop_reason ${JSON.stringify(stopReason)}`);
+            }
+            return;
+        }
+        if (role === "tool_results") {
+            MeerkatClient.requireRecordArray(raw.results, `${context}: results`).forEach((result, index) => MeerkatClient.validateWireToolResult(result, `${context}: results[${index}]`));
+            return;
+        }
+        throw new MeerkatError("INVALID_RESPONSE", `${context}: unsupported role ${JSON.stringify(role)}`);
+    }
+    static parseMobHostCapabilities(raw, context) {
+        const capabilities = MeerkatClient.requireRecord(raw, "capabilities", context);
+        for (const field of [
+            "approval_forwarding",
+            "autonomous_members",
+            "durable_sessions",
+            "hard_cancel_member",
+            "mcp",
+            "memory_store",
+        ]) {
+            MeerkatClient.requireBooleanField(capabilities, field, context);
+        }
+        const trackedInputCancel = Object.prototype.hasOwnProperty.call(capabilities, "tracked_input_cancel")
+            ? MeerkatClient.requireBooleanField(capabilities, "tracked_input_cancel", context)
+            : false;
+        MeerkatClient.requireStringField(capabilities, "engine_version", context);
+        const protocolMin = MeerkatClient.requireNonNegativeIntegerField(capabilities, "protocol_min", context);
+        const protocolMax = MeerkatClient.requireNonNegativeIntegerField(capabilities, "protocol_max", context);
+        if (protocolMin > protocolMax) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: protocol_min exceeds protocol_max`);
+        }
+        const liveEndpoint = MeerkatClient.optionalStringField(capabilities, "live_endpoint", context);
+        if (liveEndpoint === "") {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: live_endpoint must be non-empty`);
+        }
+        const resolvableProviders = Object.prototype.hasOwnProperty.call(capabilities, "resolvable_providers")
+            ? MeerkatClient.requireStringArray(capabilities.resolvable_providers, `${context}: resolvable_providers`)
+            : undefined;
+        return {
+            ...capabilities,
+            tracked_input_cancel: trackedInputCancel,
+            ...(resolvableProviders !== undefined
+                ? { resolvable_providers: resolvableProviders }
+                : {}),
+        };
+    }
+    static parseMobHostStatus(raw, context) {
+        const host = MeerkatClient.requireRecord(raw, "host", context);
+        const bindPhase = MeerkatClient.requireStringField(host, "bind_phase", context);
+        if (bindPhase !== "requested" && bindPhase !== "bound") {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: unsupported bind_phase ${JSON.stringify(bindPhase)}`);
+        }
+        MeerkatClient.requireStringField(host, "host_id", context);
+        MeerkatClient.requireNonNegativeIntegerField(host, "materialized_member_count", context);
+        const authorityEpoch = host.authority_epoch == null
+            ? undefined
+            : MeerkatClient.requireNonNegativeIntegerField(host, "authority_epoch", context);
+        const endpoint = MeerkatClient.optionalStringField(host, "endpoint", context);
+        const capabilities = host.capabilities == null
+            ? undefined
+            : MeerkatClient.parseMobHostCapabilities(host.capabilities, `${context}: capabilities`);
+        if (bindPhase === "bound" &&
+            (authorityEpoch === undefined || !endpoint || capabilities === undefined)) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: bound host missing committed authority facts`);
+        }
+        if (bindPhase === "requested" &&
+            (authorityEpoch !== undefined || endpoint !== undefined || capabilities !== undefined)) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: requested host must not claim committed authority facts`);
+        }
+        if (host.control_reachability != null &&
+            !["reachable", "stale", "unreachable", "unknown"].includes(String(host.control_reachability))) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: unsupported control_reachability`);
+        }
+        if (host.last_seen_ms != null) {
+            MeerkatClient.requireNonNegativeIntegerField(host, "last_seen_ms", context);
+        }
+        MeerkatClient.optionalStringField(host, "freshness_reason", context);
+        return (capabilities === undefined
+            ? host
+            : { ...host, capabilities });
+    }
+    static parseRouteInstallObligation(raw, context) {
+        const obligation = MeerkatClient.requireRecord(raw, "obligation", context);
+        MeerkatClient.requireStringField(obligation, "edge_a", context);
+        MeerkatClient.requireStringField(obligation, "edge_b", context);
+        MeerkatClient.requireStringField(obligation, "host", context);
+        return obligation;
+    }
     static requireBooleanField(raw, field, context) {
         const value = raw[field];
         if (typeof value !== "boolean") {
@@ -2333,6 +3000,21 @@ export class MeerkatClient {
         }
         throw new MeerkatError("INVALID_RESPONSE", message);
     }
+    static parseWireReachability(raw, field) {
+        if (raw == null) {
+            return undefined;
+        }
+        const values = [
+            "reachable",
+            "stale",
+            "unreachable",
+            "unknown",
+        ];
+        if (typeof raw === "string" && values.includes(raw)) {
+            return raw;
+        }
+        throw new MeerkatError("INVALID_RESPONSE", `Invalid mob/member_status response: ${field} must be a valid reachability`);
+    }
     static parseMobPeerConnectivitySnapshot(raw, context) {
         const record = MeerkatClient.requireRecord(raw, "peer_connectivity.snapshot", context);
         const unreachableRaw = record.unreachable_peers;
@@ -2427,6 +3109,85 @@ export class MeerkatClient {
             status: MeerkatClient.parseWireCapabilityStatus(record.status, context),
         };
     }
+    /**
+     * Validate the generated `LiveOpenResult` contract without projecting or
+     * normalizing its transport bootstrap. In particular, single-use tokens are
+     * returned byte-for-byte as received and are never logged.
+     */
+    static parseLiveOpenResult(raw, context) {
+        const result = MeerkatClient.requireRecord(raw, "result", context);
+        MeerkatClient.requireStringField(result, "channel_id", context);
+        const capabilities = MeerkatClient.requireRecord(result.capabilities, "capabilities", context);
+        for (const field of [
+            "audio_in",
+            "audio_out",
+            "barge_in_supported",
+            "image_in",
+            "provider_native_resume",
+            "text_in",
+            "text_out",
+            "transcript_supported",
+            "video_in",
+        ]) {
+            MeerkatClient.requireBooleanField(capabilities, field, `${context}: capabilities`);
+        }
+        const continuity = MeerkatClient.requireRecord(result.continuity, "continuity", context);
+        const continuityMode = MeerkatClient.requireClosedStringField(continuity, "mode", [
+            "fresh",
+            "transcript_only",
+            "degraded",
+            "provider_native_resume",
+            "unknown",
+        ], `${context}: continuity`);
+        if (continuityMode === "provider_native_resume") {
+            MeerkatClient.requireStringField(continuity, "provider_session_id", `${context}: continuity`);
+        }
+        else if (continuityMode === "unknown") {
+            MeerkatClient.requirePresentStringField(continuity, "debug", `${context}: continuity`);
+        }
+        const transport = MeerkatClient.requireRecord(result.transport, "transport", context);
+        const transportKind = MeerkatClient.requireClosedStringField(transport, "transport", ["websocket", "webrtc", "unknown"], `${context}: transport`);
+        if (transportKind === "websocket") {
+            MeerkatClient.requireStringField(transport, "url", `${context}: transport`);
+            MeerkatClient.requireStringField(transport, "token", `${context}: transport`);
+        }
+        else if (transportKind === "webrtc") {
+            MeerkatClient.requireStringField(transport, "answer_method", `${context}: transport`);
+            MeerkatClient.requireStringField(transport, "token", `${context}: transport`);
+            MeerkatClient.validateOptionalStringField(transport, "http_url", `${context}: transport`);
+        }
+        else {
+            MeerkatClient.requirePresentStringField(transport, "debug", `${context}: transport`);
+        }
+        return result;
+    }
+    /** Validate the generated `LiveStatusResult` closed status vocabulary. */
+    static parseLiveStatusResult(raw, context) {
+        const result = MeerkatClient.requireRecord(raw, "result", context);
+        MeerkatClient.requireStringField(result, "channel_id", context);
+        const status = MeerkatClient.requireRecord(result.status, "status", context);
+        const statusKind = MeerkatClient.requireClosedStringField(status, "status", ["idle", "opening", "ready", "degraded", "closing", "closed", "unknown"], `${context}: status`);
+        if (statusKind === "degraded") {
+            const reason = MeerkatClient.requireRecord(status.reason, "reason", `${context}: status`);
+            const reasonKind = MeerkatClient.requireClosedStringField(reason, "kind", [
+                "rate_limited",
+                "provider_throttled",
+                "network_unstable",
+                "other",
+                "unknown",
+            ], `${context}: status.reason`);
+            if (reasonKind === "other") {
+                MeerkatClient.requirePresentStringField(reason, "detail", `${context}: status.reason`);
+            }
+            else if (reasonKind === "unknown") {
+                MeerkatClient.requirePresentStringField(reason, "debug", `${context}: status.reason`);
+            }
+        }
+        else if (statusKind === "unknown") {
+            MeerkatClient.requirePresentStringField(status, "debug", `${context}: status`);
+        }
+        return result;
+    }
     static parseLiveRefreshResult(raw) {
         const context = "Invalid live/refresh response";
         const record = MeerkatClient.requireRecord(raw, "result", context);
@@ -2700,6 +3461,37 @@ export class MeerkatClient {
         }
         return progress;
     }
+    static parseMemberLifecycleCapabilities(raw) {
+        if (raw == null) {
+            return undefined;
+        }
+        const context = "Invalid mob/member_status response";
+        const record = MeerkatClient.requireRecord(raw, "lifecycle_capabilities", context);
+        return {
+            transcript_edits: MeerkatClient.requireBooleanField(record, "transcript_edits", context),
+            revisions: MeerkatClient.requireBooleanField(record, "revisions", context),
+            resume_after_restart: MeerkatClient.requireBooleanField(record, "resume_after_restart", context),
+        };
+    }
+    static parseNonPortableDisabled(raw) {
+        if (raw == null) {
+            return undefined;
+        }
+        const values = [
+            "rust_bundles",
+            "per_spawn_external_tools",
+            "mob_default_external_tools",
+            "default_llm_client_override",
+            "host_surface_mcp_allowlist",
+            "workgraph_tools",
+        ];
+        if (!Array.isArray(raw) ||
+            raw.some((entry) => typeof entry !== "string" ||
+                !values.includes(entry))) {
+            throw new MeerkatError("INVALID_RESPONSE", "Invalid mob/member_status response: non_portable_disabled must contain valid resource kinds");
+        }
+        return raw;
+    }
     static parseModelsCatalog(data) {
         const context = "Invalid models/catalog response";
         const contractVersion = MeerkatClient.parseContractVersion(data.contract_version, context);
@@ -2773,11 +3565,13 @@ export class MeerkatClient {
     }
     static parseContractVersion(raw, context) {
         const parseComponent = (value, field) => {
-            if (typeof value === "number" && Number.isInteger(value) && value >= 0) {
-                return value;
-            }
-            if (typeof value === "string" && /^\d+$/.test(value)) {
-                return Number(value);
+            const parsed = typeof value === "number"
+                ? value
+                : typeof value === "string" && /^\d+$/.test(value)
+                    ? Number(value)
+                    : undefined;
+            if (typeof parsed === "number" && Number.isSafeInteger(parsed) && parsed >= 0) {
+                return parsed;
             }
             throw new MeerkatError("INVALID_RESPONSE", `${context}: contract_version.${field} must be non-negative integer`);
         };
@@ -3006,10 +3800,8 @@ export class MeerkatClient {
     }
     static parseSessionHistory(data) {
         const context = "Invalid session history response";
-        if (!Array.isArray(data.messages)) {
-            throw new MeerkatError("INVALID_RESPONSE", `${context}: messages must be a list`);
-        }
-        const rawMessages = data.messages;
+        const rawMessages = MeerkatClient.requireRecordArray(data.messages, `${context}: messages`);
+        rawMessages.forEach((message, index) => MeerkatClient.validateWireHistoryRow(message, `${context}: messages[${index}]`));
         return {
             sessionId: MeerkatClient.requireStringField(data, "session_id", context),
             sessionRef: data.session_ref != null ? String(data.session_ref) : undefined,
@@ -3022,10 +3814,8 @@ export class MeerkatClient {
     }
     static parseSessionTranscriptRevision(data) {
         const context = "Invalid session transcript revision response";
-        if (!Array.isArray(data.messages)) {
-            throw new MeerkatError("INVALID_RESPONSE", `${context}: messages must be a list`);
-        }
-        const rawMessages = data.messages;
+        const rawMessages = MeerkatClient.requireRecordArray(data.messages, `${context}: messages`);
+        rawMessages.forEach((message, index) => MeerkatClient.validateWireHistoryRow(message, `${context}: messages[${index}]`));
         return {
             sessionId: MeerkatClient.requireStringField(data, "session_id", context),
             sessionRef: data.session_ref != null ? String(data.session_ref) : undefined,
@@ -3135,7 +3925,12 @@ export class MeerkatClient {
             stopReason: data.stop_reason != null ? String(data.stop_reason) : undefined,
             interactionId: data.interaction_id != null ? String(data.interaction_id) : undefined,
             runId: data.run_id != null ? String(data.run_id) : undefined,
-            blocks: rawBlocks.map((block) => MeerkatClient.parseSessionAssistantBlock(block)),
+            // System-notice blocks have their own generated union and remain
+            // available in `raw`; only block-assistant rows project through the
+            // public assistant-block view.
+            blocks: role === "block_assistant"
+                ? rawBlocks.map((block) => MeerkatClient.parseSessionAssistantBlock(block))
+                : [],
             results: rawResults.map((result) => {
                 if (typeof result !== "object" || result === null) {
                     throw new MeerkatError("INVALID_RESPONSE", `${context}: tool result must be an object`);
@@ -3230,60 +4025,22 @@ export class MeerkatClient {
     }
     static parseContentInput(value) {
         if (Array.isArray(value)) {
-            return value
-                .filter((item) => typeof item === "object" && item !== null)
-                .map((block) => MeerkatClient.parseContentBlock(block));
+            return value.map((item, index) => MeerkatClient.parseContentBlock(MeerkatClient.requireRecord(item, `content[${index}]`, "Invalid session content")));
         }
-        return String(value ?? "");
+        if (typeof value === "string")
+            return value;
+        throw new MeerkatError("INVALID_RESPONSE", "Invalid session content: expected string or content-block array");
     }
     static parseContentBlock(data) {
-        const type = String(data.type ?? "");
-        if (type === "text") {
-            return { type: "text", text: String(data.text ?? "") };
-        }
-        if (type === "image") {
-            const source = String(data.source ?? "inline");
-            if (source === "blob") {
-                return {
-                    type: "image",
-                    media_type: String(data.media_type ?? ""),
-                    source: "blob",
-                    blob_id: String(data.blob_id ?? ""),
-                };
-            }
-            return {
-                type: "image",
-                media_type: String(data.media_type ?? ""),
-                source: "inline",
-                data: String(data.data ?? ""),
-            };
-        }
-        if (type === "video") {
-            const source = String(data.source ?? "inline");
-            if (source === "uri") {
-                return {
-                    type: "video",
-                    media_type: String(data.media_type ?? ""),
-                    duration_ms: Number(data.duration_ms ?? 0),
-                    source: "uri",
-                    uri: String(data.uri ?? ""),
-                };
-            }
-            return {
-                type: "video",
-                media_type: String(data.media_type ?? ""),
-                duration_ms: Number(data.duration_ms ?? 0),
-                source: "inline",
-                data: String(data.data ?? ""),
-            };
-        }
-        return { type: "text", text: "" };
+        MeerkatClient.validateGeneratedContentBlock(data, "Invalid session content block", false);
+        // Preserve the validated wire object exactly. In particular, do not
+        // invent inline bytes for history-only image/video projections or collapse
+        // structured/unknown variants into empty text.
+        return { ...data };
     }
     static parseSessionAssistantBlock(data) {
         const context = "Invalid session assistant block";
-        if (data.data != null && (typeof data.data !== "object" || Array.isArray(data.data))) {
-            throw new MeerkatError("INVALID_RESPONSE", `${context}: data must be an object`);
-        }
+        MeerkatClient.validateWireAssistantBlock(data, context);
         const blockData = data.data ?? {};
         const blobRef = blockData.blob_ref;
         const revisedPrompt = blockData.revised_prompt != null && typeof blockData.revised_prompt === "object"
@@ -3302,9 +4059,9 @@ export class MeerkatClient {
             height: blockData.height != null ? Number(blockData.height) : undefined,
             revisedPrompt,
             meta: blockData.meta,
-            // Lane provenance for transcript blocks (typed enum on the wire,
-            // serialized as a snake_case string — currently only "spoken").
-            source: typeof blockData.source === "string" ? blockData.source : undefined,
+            source: data.block_type === "transcript"
+                ? { ...blockData.source }
+                : undefined,
             raw: { ...data },
         };
     }
@@ -3379,7 +4136,7 @@ export class MeerkatClient {
             params.model = options.model;
         if (options.provider)
             params.provider = options.provider;
-        if (options.systemPrompt)
+        if (options.systemPrompt !== undefined)
             params.system_prompt = options.systemPrompt;
         if (options.maxTokens)
             params.max_tokens = options.maxTokens;