@rkat/sdk 0.6.34 → 0.7.1

package/dist/client.js

@@ -33,12 +33,14 @@ 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 { isCompatibleWith } from "./generated/version_compat.js";
 import { CONTRACT_VERSION, } from "./generated/types.js";
 import { DeferredSession, Session } from "./session.js";
 import { Mob, } from "./mob.js";
 import { parseCoreEvent } from "./events.js";
 import { EventStream, AsyncQueue } from "./streaming.js";
 import { EventSubscription } from "./subscription.js";
+import { parseAttentionListResult, parseGoalStatusResult, parseWorkGraphEvent, parseWorkGraphSnapshot, parseWorkItem, } from "./generated/types.js";
 const MEERKAT_REPO = "lukacf/meerkat";
 const MEERKAT_RELEASE_BINARY = "rkat-rpc";
 const MEERKAT_BINARY_CACHE_ROOT = path.join(os.homedir(), ".cache", "meerkat", "bin", MEERKAT_RELEASE_BINARY);
@@ -78,26 +80,6 @@ const MOB_SPAWN_MANY_FAILURE_CAUSES = new Set([
     "work_not_found",
     "internal",
 ]);
-const WORK_ATTENTION_DELEGATED_AUTHORITIES = new Set([
-    "add_evidence",
-    "close_own_review_item",
-    "request_closure",
-    "close_if_policy_allows",
-]);
-const WORK_ATTENTION_MODES = new Set([
-    "pursue",
-    "coordinate",
-    "review",
-    "falsify",
-    "judge",
-    "observe",
-]);
-const WORK_ATTENTION_STATES = new Set([
-    "active",
-    "paused",
-    "superseded",
-    "stopped",
-]);
 function isMobSpawnManyFailureCause(value) {
     return typeof value === "string" && MOB_SPAWN_MANY_FAILURE_CAUSES.has(value);
 }
@@ -191,9 +173,7 @@ function mobTurnStartPayload(mobId, agentIdentity, prompt, options) {
     setIfDefined(payload, "output_schema", options?.outputSchema);
     setIfDefined(payload, "structured_output_retries", options?.structuredOutputRetries);
     setIfDefined(payload, "provider_params", options?.providerParams);
-    setIfDefined(payload, "clear_provider_params", options?.clearProviderParams);
     setIfDefined(payload, "auth_binding", options?.authBinding);
-    setIfDefined(payload, "clear_auth_binding", options?.clearAuthBinding);
     return payload;
 }
 function normalizeMobWireMembersBatchEdge(edge) {
@@ -206,6 +186,11 @@ function normalizeMobWireMembersBatchEdge(edge) {
 }
 export class MeerkatClient {
     process = null;
+    // Permanent transport-failed state: once the JSONL framing is untrustworthy
+    // (corrupted frame), every subsequent call must reject with this recorded
+    // typed fault instead of writing into the condemned stream. Cleared only by
+    // a fresh connect() (new process, new stream).
+    transportFault = null;
     processStderr = "";
     requestId = 0;
     _capabilities = [];
@@ -214,14 +199,28 @@ export class MeerkatClient {
     pendingRequests = new Map();
     eventQueues = new Map();
     streamQueues = new Map();
-    pendingStreamQueue = null;
-    pendingStreamRequestId = null;
+    // Per-request_id stream subscriptions for createSessionStreaming calls whose
+    // session_id is not yet bound. Keyed by the JSON-RPC request id so concurrent
+    // creates are admitted and correlated independently instead of colliding on a
+    // single client-local slot (which previously threw INVALID_STATE before the
+    // server had any chance to admit or reject the second create).
+    pendingStreamQueues = new Map();
+    // Pre-binding events keyed by session_id. session_id is globally unique per
+    // session, so buffering by session_id correlates correctly even when several
+    // streams are pending: each event lands under the session it names, and the
+    // response that binds that session_id drains exactly its own buffer.
     unmatchedStreamBuffer = new Map();
     unmatchedStandaloneStreamBuffer = new Map();
     unmatchedStandaloneStreamEnd = new Map();
     streamTerminalOutcomes = new Map();
     rl = null;
     toolHandlers = new Map();
+    // Typed faults from post-connect tool registration. `registerTool` is sync and
+    // the server round-trip is detached, so a genuine server rejection cannot be
+    // surfaced to the synchronous caller. Recording it here makes the
+    // silent-never-registers failure programmatically distinguishable instead of
+    // being swallowed by a best-effort `.catch(() => {})`.
+    toolRegistrationErrors = new Map();
     constructor(rkatPath = "rkat-rpc") {
         this.rkatPath = rkatPath;
     }
@@ -234,17 +233,77 @@ export class MeerkatClient {
      *   return `Results for ${args.q}`;
      * });
      * ```
+     *
+     * Handlers may return a plain string or a `ContentBlock[]` for multimodal
+     * tool results. Block arrays are forwarded faithfully to the runtime as
+     * `WireToolResultContent` (no string coercion).
      */
     registerTool(name, description, inputSchema, handler) {
         this.toolHandlers.set(name, { description, inputSchema, handler });
+        // A fresh declaration supersedes any stale fault from a prior failed attempt.
+        this.toolRegistrationErrors.delete(name);
         // If already connected, register the new tool with the server immediately.
         if (this.process?.stdin) {
-            this.request("tools/register", {
+            void this.registerToolWithServer(name, description, inputSchema);
+        }
+    }
+    /**
+     * Send a single post-connect tool registration and resolve its outcome
+     * without swallowing genuine faults.
+     *
+     * Benign disconnect/shutdown faults are tolerated: the local
+     * `toolHandlers` registry still holds the definition and the next
+     * `connect()` re-sends it, so the tool is not lost. A genuine server
+     * rejection or protocol fault is a real failure that cannot reach the
+     * synchronous `registerTool` caller, so we record it as an inspectable
+     * typed fault (queryable via {@link toolRegistrationError}), marking the
+     * tool unconfirmed. This replaces the previous `.catch(() => {})` that
+     * laundered every failure into silence. The recorded fault is the
+     * propagation channel: re-throwing on this detached promise would surface
+     * only as an unhandled rejection (the caller is sync), so the typed record
+     * is the observable signal instead.
+     */
+    async registerToolWithServer(name, description, inputSchema) {
+        try {
+            await this.request("tools/register", {
                 tools: [{ name, description, input_schema: inputSchema }],
-            }).catch(() => {
-                // Best-effort: tool registration may fail if connection is closing.
             });
         }
+        catch (error) {
+            const fault = error instanceof MeerkatError
+                ? error
+                : new MeerkatError("TOOL_REGISTRATION_FAILED", `Tool ${name} registration failed: ${String(error)}`);
+            // Clean shutdown / disconnect is genuinely benign — the registry already
+            // holds the definition and a future connect() will re-send it.
+            const BENIGN_CODES = new Set([
+                "CLIENT_CLOSED",
+                "CONNECTION_CLOSED",
+                "NOT_CONNECTED",
+                "PROCESS_EXITED",
+                "PROCESS_ERROR",
+            ]);
+            if (BENIGN_CODES.has(fault.code)) {
+                return;
+            }
+            // Genuine server rejection / protocol fault: record the typed fault as
+            // caller-inspectable state so the tool is programmatically known to be
+            // unconfirmed. The synchronous `registerTool` caller cannot observe a
+            // rejection on this detached promise, so the recorded fault — not a
+            // re-throw — is the surfaced signal.
+            this.toolRegistrationErrors.set(name, fault);
+            return;
+        }
+        // Success: a prior failed attempt's fault no longer applies.
+        this.toolRegistrationErrors.delete(name);
+    }
+    /**
+     * Return the typed fault recorded for a tool whose post-connect registration
+     * was rejected by the server, or `undefined` if the tool's most recent
+     * registration attempt succeeded (or has not completed yet). Lets callers
+     * distinguish a tool that silently never registered from one that is live.
+     */
+    toolRegistrationError(name) {
+        return this.toolRegistrationErrors.get(name);
     }
     // -- Connection ---------------------------------------------------------
     async connect(options) {
@@ -269,6 +328,8 @@ export class MeerkatClient {
         this.process = spawn(this.rkatPath, args, {
             stdio: ["pipe", "pipe", "pipe"],
         });
+        // Fresh process, fresh stream: clear any recorded transport fault.
+        this.transportFault = null;
         const child = this.process;
         this.processStderr = "";
         child.stderr?.on("data", (chunk) => {
@@ -296,8 +357,9 @@ export class MeerkatClient {
         });
         this.rl = createInterface({ input: this.process.stdout });
         this.rl.on("line", (line) => this.handleLine(line));
-        // Handshake
-        const initResult = await this.request("initialize", {});
+        // Handshake — `initialize` returns the generated `ServerCapabilities`
+        // contract; fields are validated below.
+        const initResult = (await this.request("initialize", {}));
         const serverVersion = String(initResult.contract_version ?? "");
         if (!MeerkatClient.checkVersionCompatible(serverVersion, CONTRACT_VERSION)) {
             throw new MeerkatError("VERSION_MISMATCH", `Server version ${serverVersion} incompatible with SDK ${CONTRACT_VERSION}`);
@@ -305,14 +367,12 @@ export class MeerkatClient {
         this._methods = new Set(Array.isArray(initResult.methods)
             ? initResult.methods.map((method) => String(method))
             : []);
-        // Fetch capabilities
-        const capsResult = await this.request("capabilities/get", {});
-        const rawCaps = capsResult.capabilities ?? [];
-        this._capabilities = rawCaps.map((cap) => ({
-            id: String(cap.id ?? ""),
-            description: String(cap.description ?? ""),
-            status: MeerkatClient.normalizeStatus(cap.status),
-        }));
+        // Fetch capabilities — generated `CapabilitiesResponse` contract.
+        const capsResult = (await this.request("capabilities/get", {}));
+        if (!Array.isArray(capsResult.capabilities)) {
+            throw new MeerkatError("INVALID_RESPONSE", "Invalid capabilities/get response: capabilities must be a list");
+        }
+        this._capabilities = capsResult.capabilities.map((cap) => MeerkatClient.parseWireCapabilityEntry(cap));
         // Register callback tools if any were declared.
         if (this.toolHandlers.size > 0) {
             const tools = Array.from(this.toolHandlers.entries()).map(([name, { description, inputSchema }]) => ({
@@ -321,6 +381,8 @@ export class MeerkatClient {
                 input_schema: inputSchema,
             }));
             await this.request("tools/register", { tools });
+            // The bulk re-send confirmed every declared tool; drop stale per-tool faults.
+            this.toolRegistrationErrors.clear();
         }
         return this;
     }
@@ -354,6 +416,35 @@ export class MeerkatClient {
         }
         this.pendingRequests.clear();
     }
+    /**
+     * Surface a typed transport/protocol fault to every pending caller and
+     * stream consumer. Used when the read loop encounters a corrupted frame and
+     * the stream can no longer be trusted, so callers fail closed instead of
+     * hanging on a dropped response.
+     */
+    failTransport(reason) {
+        if (!this.transportFault) {
+            this.transportFault =
+                reason instanceof MeerkatError
+                    ? reason
+                    : new MeerkatError("PROTOCOL_ERROR", String(reason));
+        }
+        this.rejectPendingRequests(reason);
+        this.closeQueues();
+        // Fail closed: the stream is condemned, so the process goes with it —
+        // leaving it alive would let later calls write into framing we just
+        // classified as untrustworthy.
+        if (this.rl) {
+            this.rl.close();
+            this.rl = null;
+        }
+        const process = this.process;
+        this.process = null;
+        if (process) {
+            process.stdin?.destroy();
+            process.kill();
+        }
+    }
     closeQueues() {
         for (const [, queue] of this.eventQueues) {
             queue.put(null);
@@ -364,12 +455,11 @@ export class MeerkatClient {
         }
         this.streamQueues.clear();
         this.streamTerminalOutcomes.clear();
-        if (this.pendingStreamQueue) {
-            this.pendingStreamQueue.put(null);
-            this.pendingStreamQueue = null;
-            this.pendingStreamRequestId = null;
-            this.unmatchedStreamBuffer.clear();
+        for (const [, queue] of this.pendingStreamQueues) {
+            queue.put(null);
         }
+        this.pendingStreamQueues.clear();
+        this.unmatchedStreamBuffer.clear();
     }
     // -- Session lifecycle --------------------------------------------------
     /**
@@ -401,17 +491,19 @@ export class MeerkatClient {
         const params = MeerkatClient.buildCreateParams(prompt, options);
         this.requestId++;
         const requestId = this.requestId;
-        if (this.pendingStreamQueue) {
-            throw new MeerkatError("INVALID_STATE", "Only one createSessionStreaming request can be pending at a time");
-        }
+        // Per-request_id subscription: concurrent createSessionStreaming calls each
+        // get their own pending queue keyed by request id, so a second create is no
+        // longer rejected by a client-local singleton invariant. Admission/rejection
+        // is left to the server.
         const queue = new AsyncQueue();
-        this.pendingStreamQueue = queue;
-        this.pendingStreamRequestId = requestId;
+        this.pendingStreamQueues.set(requestId, queue);
         const responsePromise = this.registerRequest(requestId);
-        // When response arrives, bind the queue to the session_id
+        // When response arrives, bind this request's queue to its session_id.
         const wrappedPromise = responsePromise.then((result) => {
             const sid = String(result.session_id ?? "");
             if (sid) {
+                // Drain only this session's pre-binding buffer — events are buffered by
+                // session_id, so concurrent pending streams do not cross-deliver.
                 const buffered = this.unmatchedStreamBuffer.get(sid) ?? [];
                 for (const evt of buffered) {
                     queue.put(evt);
@@ -419,10 +511,15 @@ export class MeerkatClient {
                 this.unmatchedStreamBuffer.delete(sid);
                 this.eventQueues.set(sid, queue);
             }
-            this.pendingStreamQueue = null;
-            this.pendingStreamRequestId = null;
-            this.unmatchedStreamBuffer.clear();
+            this.pendingStreamQueues.delete(requestId);
             return result;
+        }, (error) => {
+            // The server rejected this create: tear down only this request's pending
+            // subscription so its consumer fails closed, and leave any concurrent
+            // pending streams untouched.
+            this.pendingStreamQueues.delete(requestId);
+            queue.put(null);
+            throw error;
         });
         const rpcRequest = { jsonrpc: "2.0", id: requestId, method: "session/create", params };
         this.process.stdin.write(JSON.stringify(rpcRequest) + "\n");
@@ -504,7 +601,10 @@ export class MeerkatClient {
         return this.request("session/peer_response_terminal", params);
     }
     async injectContext(sessionId, text, options) {
-        const params = { session_id: sessionId, text };
+        const params = {
+            session_id: sessionId,
+            content: { type: "text", text },
+        };
         if (options?.source !== undefined) {
             params.source = options.source;
         }
@@ -615,24 +715,24 @@ export class MeerkatClient {
     }
     // -- Config -------------------------------------------------------------
     async getConfig() {
-        const raw = await this.request("config/get", {});
-        return MeerkatClient.parseConfigEnvelope(raw);
+        // The wire body IS the generated `ConfigEnvelope` contract.
+        return (await this.request("config/get", {}));
     }
     async setConfig(config, options) {
         const params = { config };
         if (options?.expectedGeneration !== undefined) {
             params.expected_generation = options.expectedGeneration;
         }
-        const raw = await this.request("config/set", params);
-        return MeerkatClient.parseConfigEnvelope(raw);
+        // The wire body IS the generated `ConfigWriteResult` contract (envelope
+        // plus the live-propagation report).
+        return (await this.request("config/set", params));
     }
     async patchConfig(patch, options) {
         const params = { patch };
         if (options?.expectedGeneration !== undefined) {
             params.expected_generation = options.expectedGeneration;
         }
-        const raw = await this.request("config/patch", params);
-        return MeerkatClient.parseConfigEnvelope(raw);
+        return (await this.request("config/patch", params));
     }
     async mcpAdd(params) {
         const raw = await this.request("mcp/add", params);
@@ -659,7 +759,9 @@ export class MeerkatClient {
     // -- Skills ---------------------------------------------------------------
     async listSkills() {
         const result = await this.request("skills/list", {});
-        return result.skills ?? [];
+        MeerkatClient.requireRecordArray(result.skills, "Invalid skills/list response");
+        const envelope = result;
+        return envelope.skills;
     }
     async getBlob(blobId) {
         const result = await this.request("blob/get", { blob_id: blobId });
@@ -779,43 +881,42 @@ export class MeerkatClient {
         });
     }
     async getWorkGraphItem(itemId, options) {
-        const result = await this.request("workgraph/get", {
-            id: itemId,
-            ...MeerkatClient.toWireWorkGraphScope(options),
-        });
-        return MeerkatClient.parseWorkItem(result);
+        const params = { id: itemId };
+        if (options?.realmId !== undefined) {
+            params.realm_id = options.realmId;
+        }
+        if (options?.namespace !== undefined) {
+            params.namespace = options.namespace;
+        }
+        const result = await this.request("workgraph/get", params);
+        return parseWorkItem(result);
     }
     async listWorkGraphItems(filter = {}) {
-        const result = await this.request("workgraph/list", MeerkatClient.toWireWorkGraphItemFilter(filter));
-        return {
-            items: MeerkatClient.parseWorkItemArray(result.items),
-        };
+        const result = await this.request("workgraph/list", filter);
+        const items = MeerkatClient.requireRecordArray(result.items, "Invalid workgraph item list").map((entry) => parseWorkItem(entry));
+        return { items };
     }
     async listReadyWorkGraphItems(filter = {}) {
-        const result = await this.request("workgraph/ready", MeerkatClient.toWireWorkGraphReadyFilter(filter));
-        return {
-            items: MeerkatClient.parseWorkItemArray(result.items),
-        };
+        const result = await this.request("workgraph/ready", filter);
+        const items = MeerkatClient.requireRecordArray(result.items, "Invalid workgraph item list").map((entry) => parseWorkItem(entry));
+        return { items };
     }
     async getWorkGraphSnapshot(filter = {}) {
-        const result = await this.request("workgraph/snapshot", MeerkatClient.toWireWorkGraphItemFilter(filter));
-        return MeerkatClient.parseWorkGraphSnapshot(result);
+        const result = await this.request("workgraph/snapshot", filter);
+        return parseWorkGraphSnapshot(result);
     }
     async listWorkGraphEvents(filter = {}) {
-        const result = await this.request("workgraph/events", MeerkatClient.toWireWorkGraphEventFilter(filter));
-        return {
-            events: MeerkatClient.parseWorkGraphEventArray(result.events),
-        };
+        const result = await this.request("workgraph/events", filter);
+        const events = MeerkatClient.requireRecordArray(result.events, "Invalid workgraph event list").map((entry) => parseWorkGraphEvent(entry));
+        return { events };
     }
     async getWorkGraphGoalStatus(params) {
-        const result = await this.request("workgraph/goal/status", MeerkatClient.toWireWorkGraphGoalStatusRequest(params));
-        return MeerkatClient.parseWorkGraphGoalResult(result);
+        const result = await this.request("workgraph/goal/status", params);
+        return parseGoalStatusResult(result);
     }
     async listWorkGraphAttention(params = {}) {
-        const result = await this.request("workgraph/attention/list", MeerkatClient.toWireWorkGraphAttentionListRequest(params));
-        return {
-            attention: MeerkatClient.parseWorkAttentionBindingArray(result.attention),
-        };
+        const result = await this.request("workgraph/attention/list", params);
+        return parseAttentionListResult(result);
     }
     async subscribeSessionEvents(sessionId) {
         return this.openEventSubscription("session/stream_open", { session_id: sessionId }, "session/stream_close", MeerkatClient.parseAgentEventEnvelope);
@@ -831,28 +932,23 @@ export class MeerkatClient {
     async listMobs() {
         this.requireCapability("mob");
         const result = await this.request("mob/list", {});
-        const mobs = result.mobs ?? [];
+        const mobs = MeerkatClient.requireRecordArray(result.mobs, "Invalid mob/list response");
         return mobs.map((mob) => ({
             mobId: String(mob.mob_id ?? mob.mobId ?? ""),
-            status: String(mob.status ?? ""),
+            status: MeerkatClient.requireStringField(mob, "status", "Invalid mob/list response entry: missing status"),
         }));
     }
     async mobStatus(mobId) {
         const result = await this.request("mob/status", { mob_id: mobId });
-        const rawStatus = result.status;
-        const status = typeof rawStatus === "string"
-            ? rawStatus
-            : (typeof rawStatus === "object" && rawStatus !== null
-                ? Object.keys(rawStatus)[0]
-                : undefined);
-        if (!status) {
-            throw new MeerkatError("INVALID_RESPONSE", "Invalid mob/status response: missing status");
-        }
-        return { mobId: String(result.mob_id ?? mobId), status };
+        const context = "Invalid mob/status response";
+        const record = MeerkatClient.requireRecord(result, "result", context);
+        const status = MeerkatClient.requireStringField(record, "status", context);
+        const responseMobId = MeerkatClient.requireStringField(record, "mob_id", context);
+        return { mobId: responseMobId, status };
     }
     async listMobMembers(mobId) {
         const result = await this.request("mob/members", { mob_id: mobId });
-        const members = result.members ?? [];
+        const members = MeerkatClient.requireRecordArray(result.members, "Invalid mob/members response");
         return members.map((member) => {
             const agentIdentity = String(member.agent_identity ?? "");
             const memberRef = typeof member.member_ref === "string" && member.member_ref.length > 0
@@ -864,20 +960,21 @@ export class MeerkatClient {
             return {
                 agentIdentity,
                 memberRef,
-                profile: String(member.profile_name ?? member.profile ?? member.role ?? ""),
+                profile: MeerkatClient.requireStringField(member, "role", "Invalid mob/members response: missing role"),
                 peerId: member.peer_id != null ? String(member.peer_id) : undefined,
                 externalPeerSpecs: member.external_peer_specs && typeof member.external_peer_specs === "object"
                     ? Object.fromEntries(Object.entries(member.external_peer_specs).map(([key, value]) => [key, (value ?? {})]))
                     : undefined,
                 runtimeMode: member.runtime_mode != null ? String(member.runtime_mode) : undefined,
-                state: member.state != null ? String(member.state) : undefined,
                 wiredTo: Array.isArray(member.wired_to)
                     ? member.wired_to.map((peer) => String(peer))
                     : undefined,
                 labels: member.labels && typeof member.labels === "object"
                     ? Object.fromEntries(Object.entries(member.labels).map(([key, value]) => [key, String(value)]))
                     : undefined,
-                status: member.status != null ? String(member.status) : undefined,
+                status: member.status != null
+                    ? MeerkatClient.parseWireMobMemberStatus(member.status, "Invalid mob/members response: invalid member status")
+                    : undefined,
                 error: member.error != null ? String(member.error) : undefined,
                 isFinal: member.is_final != null ? Boolean(member.is_final) : undefined,
             };
@@ -902,9 +999,7 @@ export class MeerkatClient {
                 ? result.agent_identity
                 : agentIdentity,
             memberRef,
-            handlingMode: result.handling_mode === "steer" || result.handling_mode === "queue"
-                ? result.handling_mode
-                : (options?.handlingMode ?? "queue"),
+            handlingMode: MeerkatClient.parseWireHandlingMode(result.handling_mode, "Invalid mob/member_send response: missing or unknown handling_mode"),
         };
     }
     async spawnMobMember(mobId, options) {
@@ -1006,7 +1101,12 @@ export class MeerkatClient {
             agent_identity: agentIdentity,
             initial_message: initialMessage,
         });
-        const status = String(result.status ?? "completed");
+        const respawnContext = "Invalid mob/respawn response";
+        const respawnRecord = MeerkatClient.requireRecord(result, "result", respawnContext);
+        const status = MeerkatClient.requireStringField(respawnRecord, "status", respawnContext);
+        if (status !== "completed" && status !== "topology_restore_failed") {
+            throw new MeerkatError("INVALID_RESPONSE", "Invalid mob/respawn response: invalid status");
+        }
         const rawFailed = Array.isArray(result.failed_peer_ids)
             ? result.failed_peer_ids
             : [];
@@ -1021,7 +1121,7 @@ export class MeerkatClient {
             throw new MeerkatError("INVALID_RESPONSE", "Invalid mob/respawn response: receipt missing member_ref");
         }
         return {
-            status: status === "topology_restore_failed" ? "topology_restore_failed" : "completed",
+            status,
             receipt: {
                 agentIdentity: receipt.identity != null ? String(receipt.identity) : agentIdentity,
                 memberRef,
@@ -1047,7 +1147,7 @@ export class MeerkatClient {
             ? result.peer_connectivity
             : undefined;
         return {
-            status: String(result.status ?? "unknown"),
+            status: MeerkatClient.parseWireMobMemberStatus(result.status, "Invalid mob/member_status response: missing or invalid status"),
             outputPreview: result.output_preview != null ? String(result.output_preview) : undefined,
             error: result.error != null ? String(result.error) : undefined,
             tokensUsed: Number(result.tokens_used ?? 0),
@@ -1079,9 +1179,10 @@ export class MeerkatClient {
      */
     async mobSnapshot(mobId) {
         const result = await this.request("mob/snapshot", { mob_id: mobId });
+        const snapshotRecord = MeerkatClient.requireRecord(result, "result", "Invalid mob/snapshot response");
         return {
             mobId: String(result.mob_id ?? mobId),
-            status: String(result.status ?? "unknown"),
+            status: MeerkatClient.requireStringField(snapshotRecord, "status", "Invalid mob/snapshot response: missing status"),
             members: Array.isArray(result.members) ? result.members : [],
         };
     }
@@ -1165,9 +1266,8 @@ export class MeerkatClient {
             params.timeout_ms = options.timeoutMs;
         }
         const result = await this.request("mob/wait_kickoff", params);
-        const members = Array.isArray(result.members) ? result.members : [];
-        return members.map((entry) => {
-            const member = entry && typeof entry === "object" ? entry : {};
+        const members = MeerkatClient.requireRecordArray(result.members, "Invalid mob/wait_kickoff response");
+        return members.map((member) => {
             const agentIdentity = String(member.agent_identity ?? "");
             if (!agentIdentity) {
                 throw new MeerkatError("INVALID_RESPONSE", "Invalid mob/wait_kickoff response: member missing agent_identity");
@@ -1212,9 +1312,8 @@ export class MeerkatClient {
             params.timeout_ms = options.timeoutMs;
         }
         const result = await this.request("mob/wait_ready", params);
-        const members = Array.isArray(result.members) ? result.members : [];
-        return members.map((entry) => {
-            const member = entry && typeof entry === "object" ? entry : {};
+        const members = MeerkatClient.requireRecordArray(result.members, "Invalid mob/wait_ready response");
+        return members.map((member) => {
             const agentIdentity = String(member.agent_identity ?? "");
             if (!agentIdentity) {
                 throw new MeerkatError("INVALID_RESPONSE", "Invalid mob/wait_ready response: member missing agent_identity");
@@ -1408,10 +1507,24 @@ export class MeerkatClient {
         const result = await this.request("mob/flow_run", { mob_id: mobId, flow_id: flowId, params });
         return String(result.run_id ?? "");
     }
+    async runMob(mobId, params = {}, options = {}) {
+        const payload = { mob_id: mobId, params };
+        if (options.prompt !== undefined)
+            payload.prompt = options.prompt;
+        if (options.flowId !== undefined)
+            payload.flow_id = options.flowId;
+        const result = (await this.request("mob/run", payload));
+        return String(result.run_id ?? "");
+    }
     async getMobFlowStatus(mobId, runId) {
         const result = await this.request("mob/flow_status", { mob_id: mobId, run_id: runId });
         return result.run == null ? null : { run: result.run };
     }
+    async getMobRunResult(mobId, runId) {
+        const params = { mob_id: mobId, run_id: runId };
+        const result = (await this.request("mob/run_result", params));
+        return result.run == null ? null : { run: result.run };
+    }
     async cancelMobFlow(mobId, runId) {
         await this.request("mob/flow_cancel", { mob_id: mobId, run_id: runId });
     }
@@ -1450,8 +1563,10 @@ export class MeerkatClient {
             streamId,
             queue,
             closeRemote: async (id) => {
-                this.streamQueues.delete(id);
+                // Await stream-close authority before tearing down local dispatch:
+                // a rejected close must leave the subscription delivering events.
                 await this.request(closeMethod, { stream_id: id });
+                this.streamQueues.delete(id);
             },
             parseEvent: parse,
             getTerminalOutcome: () => this.streamTerminalOutcomes.get(streamId),
@@ -1460,7 +1575,6 @@ export class MeerkatClient {
     static parseAgentEventEnvelope(raw) {
         const eventId = MeerkatClient.parseOptionalString(raw.event_id ?? raw.eventId);
         const source = MeerkatClient.parseEventSourceIdentity(raw.source);
-        const sourceId = MeerkatClient.parseOptionalString(raw.source_id ?? raw.sourceId);
         const seq = MeerkatClient.parseOptionalNumber(raw.seq);
         const timestampMs = MeerkatClient.parseOptionalNumber(raw.timestamp_ms ?? raw.timestampMs);
         const payloadRaw = raw.payload;
@@ -1470,7 +1584,6 @@ export class MeerkatClient {
         return {
             ...(eventId != null ? { eventId } : {}),
             ...(source != null ? { source } : {}),
-            ...(sourceId != null ? { sourceId } : {}),
             ...(seq != null ? { seq } : {}),
             ...(timestampMs != null ? { timestampMs } : {}),
             ...(payload ? { payload } : {}),
@@ -1512,10 +1625,28 @@ export class MeerkatClient {
         return typeof raw === "number" && Number.isFinite(raw) ? raw : undefined;
     }
     static parseAttributedMobEvent(raw) {
+        const context = "Invalid attributed mob event";
+        // The runtime wire shape (meerkat-mob AttributedEvent) carries a typed
+        // source `{ identity, generation }` (AgentRuntimeId) and a `role`
+        // (ProfileName) string — NOT free-form `source`/`profile` strings. Mirror
+        // the web SDK `parseAttributedEventItem`/`parseAttributedSource`: validate
+        // the source record (require non-empty `identity` + non-negative integer
+        // `generation`) and the `role` field, throwing on absence/malformation.
+        // The public `AttributedMobEvent` TS type exposes `source: string` /
+        // `profile: string`, so the validated `identity` is projected into
+        // `source` and the validated `role` into `profile`. Nothing is coalesced
+        // to "" — absent/unknown fields fail closed.
+        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) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: source generation must be a non-negative integer`);
+        }
+        const role = MeerkatClient.requireStringField(raw, "role", context);
         return {
-            source: String(raw.source ?? ""),
-            profile: String(raw.profile ?? ""),
-            envelope: MeerkatClient.parseAgentEventEnvelope((raw.envelope ?? {})),
+            source: identity,
+            profile: role,
+            envelope: MeerkatClient.parseAgentEventEnvelope(MeerkatClient.requireRecord(raw.envelope, "envelope", context)),
         };
     }
     // -- Internal methods used by Session -----------------------------------
@@ -1608,7 +1739,9 @@ export class MeerkatClient {
     }
     /** @internal */
     async _interrupt(sessionId) {
-        await this.request("turn/interrupt", { session_id: sessionId });
+        return (await this.request("turn/interrupt", {
+            session_id: sessionId,
+        }));
     }
     /** @internal */
     async _archive(sessionId) {
@@ -1718,7 +1851,8 @@ export class MeerkatClient {
         return result;
     }
     async liveClose(params) {
-        await this.request("live/close", params);
+        const result = await this.request("live/close", params);
+        return MeerkatClient.parseLiveCloseResult(result);
     }
     async liveSendInput(params) {
         await this.request("live/send_input", params);
@@ -1782,19 +1916,18 @@ export class MeerkatClient {
      * `model_id` and `provider_id` match the channel's currently-open
      * identity and rejects swaps with a typed adapter-level error.
      *
-     * R4-5 (P3): the result is a typed `LiveRefreshResult` carrying both the
-     * typed `status` discriminator (today: always `"queued"`; the wire enum
-     * is open so future variants like `applied_sync` can land without breaking
-     * the shape) and the legacy `refresh_enqueued: true` back-compat boolean.
-     * The host's `send_command` returns when the command has been queued on
-     * the adapter's mpsc channel; the adapter pump applies the
-     * `session.update` asynchronously, and the realtime stream is the source
-     * of truth for the actual outcome (failures surface as
-     * `WireLiveAdapterObservation::Error`).
+     * R4-5 (P3): the result is a typed `LiveRefreshResult` carrying the
+     * generated-authority `status` discriminator (today: `"queued"`). This SDK
+     * build accepts the generated status set it was built with and rejects
+     * missing or unknown status values until regenerated for a newer contract.
+     * The host queue acceptance happens before this result is projected; the
+     * adapter pump applies the `session.update` asynchronously, and the
+     * realtime stream is the source of truth for the actual outcome (failures
+     * surface as `WireLiveAdapterObservation::Error`).
      */
     async liveRefresh(params) {
         const result = await this.request("live/refresh", params);
-        return result;
+        return MeerkatClient.parseLiveRefreshResult(result);
     }
     /**
      * Type-narrow an inbound live-adapter observation against
@@ -1912,6 +2045,11 @@ export class MeerkatClient {
             data = JSON.parse(line);
         }
         catch {
+            // A corrupted (non-JSON) frame means the JSONL stream framing can no
+            // longer be trusted. Surface a typed protocol fault to every pending
+            // caller and stream consumer rather than silently dropping the line,
+            // which would launder a corrupted stream into a hang / missing response.
+            this.failTransport(new MeerkatError("PROTOCOL_ERROR", "Corrupted JSON-RPC frame: stream framing is no longer trustworthy"));
             return;
         }
         // Server→client callback request (has both id and method).
@@ -1977,7 +2115,10 @@ export class MeerkatClient {
                 if (queue) {
                     queue.put(event);
                 }
-                else if (this.pendingStreamQueue) {
+                else if (this.pendingStreamQueues.size > 0) {
+                    // A stream is pending but its session_id is not yet bound. Buffer by
+                    // session_id; the create response that binds this session_id drains
+                    // exactly this buffer into the matching request's queue.
                     const buffered = this.unmatchedStreamBuffer.get(sessionId) ?? [];
                     buffered.push(event);
                     this.unmatchedStreamBuffer.set(sessionId, buffered);
@@ -1995,29 +2136,20 @@ export class MeerkatClient {
                 details: parsed.details ?? parsed.reason ?? rawData,
             };
         }
-        const rawMessage = error.message;
-        if (typeof rawMessage === "string") {
-            try {
-                const parsed = JSON.parse(rawMessage);
-                if (parsed && typeof parsed === "object") {
-                    return {
-                        code: String(parsed.code ?? error.code ?? "UNKNOWN"),
-                        message: String(parsed.message ?? rawMessage),
-                        details: parsed.details ?? parsed.reason ?? error.data,
-                    };
-                }
-            }
-            catch {
-                // Fall back to the outer JSON-RPC error payload.
-            }
-        }
+        // The server's typed error projection is `error.data` ({code, message,
+        // details}). `error.message` is presentation text only — it is never
+        // parsed as JSON to recover typed fields, so SDK error semantics cannot
+        // depend on message-string folklore.
         return {
             code: String(error.code ?? "UNKNOWN"),
-            message: String(rawMessage ?? "Unknown error"),
+            message: String(error.message ?? "Unknown error"),
             details: error.data,
         };
     }
     request(method, params) {
+        if (this.transportFault) {
+            throw this.transportFault;
+        }
         if (!this.process?.stdin) {
             throw new MeerkatError("NOT_CONNECTED", "Client not connected");
         }
@@ -2037,16 +2169,6 @@ export class MeerkatClient {
         });
     }
     // -- Static helpers -----------------------------------------------------
-    static normalizeStatus(raw) {
-        if (typeof raw === "string")
-            return raw;
-        if (typeof raw === "object" && raw !== null) {
-            // Rust can emit externally-tagged enums for status:
-            // { DisabledByPolicy: { description: "..." } }
-            return Object.keys(raw)[0] ?? "Unknown";
-        }
-        return String(raw);
-    }
     static requireRecord(raw, field, context) {
         if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
             throw new MeerkatError("INVALID_RESPONSE", `${context}: missing ${field}`);
@@ -2083,6 +2205,81 @@ export class MeerkatClient {
         }
         return value;
     }
+    static parseWireMobMemberStatus(raw, message) {
+        if (typeof raw === "string" &&
+            ["active", "retiring", "broken", "completed", "unknown"].includes(raw)) {
+            return raw;
+        }
+        throw new MeerkatError("INVALID_RESPONSE", message);
+    }
+    /**
+     * Parse a runtime-emitted handling mode against the closed WireHandlingMode
+     * union. Fails closed on an absent or unrecognized variant — the SDK never
+     * substitutes the client-requested mode for the runtime receipt. Mirrors the
+     * web SDK `parseWireHandlingMode` and Python `_parse_wire_handling_mode`.
+     */
+    static parseWireHandlingMode(raw, message) {
+        if (raw === "queue" || raw === "steer") {
+            return raw;
+        }
+        throw new MeerkatError("INVALID_RESPONSE", message);
+    }
+    /**
+     * Parse a capability status against the externally-tagged Rust
+     * `CapabilityStatus` enum: either the bare string variant (e.g. "Available")
+     * or a single-key object like `{ DisabledByPolicy: {...} }`. The capability
+     * vocabulary evolves, so we do not whitelist variants, but we fail closed on
+     * an absent or otherwise unparseable status rather than fabricating a
+     * permissive default. Mirrors Python `_parse_wire_capability_status`.
+     */
+    static parseWireCapabilityStatus(raw, context) {
+        if (typeof raw === "string" && raw.length > 0) {
+            return raw;
+        }
+        if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
+            const firstKey = Object.keys(raw)[0];
+            if (typeof firstKey === "string" && firstKey.length > 0) {
+                return firstKey;
+            }
+        }
+        throw new MeerkatError("INVALID_RESPONSE", `${context}: missing or invalid capability status`);
+    }
+    /**
+     * Parse a single capabilities/get entry, failing closed on absent/malformed
+     * required fields rather than coercing to empty strings or a permissive
+     * status default. Mirrors the Python capability parser.
+     */
+    static parseWireCapabilityEntry(raw) {
+        const context = "Invalid capabilities/get response";
+        const record = MeerkatClient.requireRecord(raw, "capability", context);
+        return {
+            id: MeerkatClient.requireStringField(record, "id", context),
+            description: MeerkatClient.requireStringField(record, "description", context),
+            status: MeerkatClient.parseWireCapabilityStatus(record.status, context),
+        };
+    }
+    static parseLiveRefreshResult(raw) {
+        const context = "Invalid live/refresh response";
+        const record = MeerkatClient.requireRecord(raw, "result", context);
+        const status = MeerkatClient.requireStringField(record, "status", context);
+        if (status !== "queued") {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: unsupported status ${JSON.stringify(status)}`);
+        }
+        return {
+            status,
+        };
+    }
+    static parseLiveCloseResult(raw) {
+        const context = "Invalid live/close response";
+        const record = MeerkatClient.requireRecord(raw, "result", context);
+        const status = MeerkatClient.requireStringField(record, "status", context);
+        if (status !== "closed") {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: unsupported status ${JSON.stringify(status)}`);
+        }
+        return {
+            status,
+        };
+    }
     static parseSkillDiagnostics(raw) {
         if (!raw || typeof raw !== "object")
             return undefined;
@@ -2116,16 +2313,10 @@ export class MeerkatClient {
         };
     }
     static checkVersionCompatible(server, client) {
-        try {
-            const s = server.split(".").map(Number);
-            const c = client.split(".").map(Number);
-            if (s[0] === 0 && c[0] === 0)
-                return s[1] === c[1];
-            return s[0] === c[0];
-        }
-        catch {
-            return false;
-        }
+        // Drive contract-version compatibility off the generated helper
+        // (mirrors `ContractVersion::is_compatible_with`) instead of a hand-rolled
+        // copy of the rule (dogma row #193).
+        return isCompatibleWith(server, client);
     }
     static parseRunResult(data) {
         const context = "Invalid run result";
@@ -2195,33 +2386,30 @@ export class MeerkatClient {
             return undefined;
         }
         const raw = data;
+        const vision = raw.vision;
+        const imageInput = raw.image_input;
+        const imageToolResults = raw.image_tool_results;
+        const inlineVideo = raw.inline_video;
+        const realtime = raw.realtime;
+        const webSearch = raw.web_search;
+        const imageGeneration = raw.image_generation;
+        if (typeof vision !== "boolean" ||
+            typeof imageInput !== "boolean" ||
+            typeof imageToolResults !== "boolean" ||
+            typeof inlineVideo !== "boolean" ||
+            typeof realtime !== "boolean" ||
+            typeof webSearch !== "boolean" ||
+            typeof imageGeneration !== "boolean") {
+            return undefined;
+        }
         return {
-            vision: Boolean(raw.vision),
-            imageInput: Boolean(raw.image_input),
-            imageToolResults: Boolean(raw.image_tool_results),
-            inlineVideo: Boolean(raw.inline_video),
-            realtime: Boolean(raw.realtime),
-            webSearch: Boolean(raw.web_search),
-            imageGeneration: Boolean(raw.image_generation),
-        };
-    }
-    static parseConfigEnvelope(data) {
-        const rawConfig = data.config && typeof data.config === "object"
-            ? data.config
-            : {};
-        const rawResolvedPaths = data.resolved_paths && typeof data.resolved_paths === "object"
-            ? data.resolved_paths
-            : undefined;
-        const resolvedPaths = rawResolvedPaths
-            ? Object.fromEntries(Object.entries(rawResolvedPaths).map(([key, value]) => [key, String(value)]))
-            : undefined;
-        return {
-            config: rawConfig,
-            generation: Number(data.generation ?? 0),
-            realmId: data.realm_id != null ? String(data.realm_id) : undefined,
-            instanceId: data.instance_id != null ? String(data.instance_id) : undefined,
-            backend: data.backend != null ? String(data.backend) : undefined,
-            resolvedPaths,
+            vision,
+            imageInput,
+            imageToolResults,
+            inlineVideo,
+            realtime,
+            webSearch,
+            imageGeneration,
         };
     }
     static parseCommsSendReceipt(data) {
@@ -2236,25 +2424,7 @@ export class MeerkatClient {
         const providersRaw = Array.isArray(data.providers)
             ? data.providers
             : [];
-        let contractVersion = { major: 0, minor: 0, patch: 0 };
-        if (data.contract_version && typeof data.contract_version === "object") {
-            const contractVersionRaw = data.contract_version;
-            contractVersion = {
-                major: Number(contractVersionRaw.major ?? 0),
-                minor: Number(contractVersionRaw.minor ?? 0),
-                patch: Number(contractVersionRaw.patch ?? 0),
-            };
-        }
-        else if (typeof data.contract_version === "string") {
-            const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(data.contract_version);
-            if (match) {
-                contractVersion = {
-                    major: Number(match[1]),
-                    minor: Number(match[2]),
-                    patch: Number(match[3]),
-                };
-            }
-        }
+        const contractVersion = MeerkatClient.parseContractVersion(data.contract_version, "Invalid models/catalog response");
         return {
             contractVersion,
             providers: providersRaw.map((provider) => ({
@@ -2291,6 +2461,36 @@ 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);
+            }
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: contract_version.${field} must be non-negative integer`);
+        };
+        if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+            const record = raw;
+            return {
+                major: parseComponent(record.major, "major"),
+                minor: parseComponent(record.minor, "minor"),
+                patch: parseComponent(record.patch, "patch"),
+            };
+        }
+        if (typeof raw === "string") {
+            const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(raw);
+            if (match) {
+                return {
+                    major: parseComponent(match[1], "major"),
+                    minor: parseComponent(match[2], "minor"),
+                    patch: parseComponent(match[3], "patch"),
+                };
+            }
+        }
+        throw new MeerkatError("INVALID_RESPONSE", `${context}: missing contract_version`);
+    }
     static parseSchedule(data) {
         const labelsRaw = data.labels && typeof data.labels === "object"
             ? data.labels
@@ -2373,53 +2573,6 @@ export class MeerkatClient {
                     : undefined,
         };
     }
-    static toWireWorkGraphScope(options) {
-        const params = {};
-        setIfDefined(params, "realm_id", options?.realmId);
-        setIfDefined(params, "namespace", options?.namespace);
-        return params;
-    }
-    static toWireWorkGraphItemFilter(filter) {
-        const params = MeerkatClient.toWireWorkGraphScope(filter);
-        setIfDefined(params, "all_namespaces", filter.allNamespaces);
-        setIfDefined(params, "statuses", filter.statuses);
-        setIfDefined(params, "labels", filter.labels);
-        setIfDefined(params, "include_terminal", filter.includeTerminal);
-        setIfDefined(params, "limit", filter.limit);
-        return params;
-    }
-    static toWireWorkGraphReadyFilter(filter) {
-        const params = MeerkatClient.toWireWorkGraphScope(filter);
-        setIfDefined(params, "labels", filter.labels);
-        setIfDefined(params, "limit", filter.limit);
-        return params;
-    }
-    static toWireWorkGraphEventFilter(filter) {
-        const params = MeerkatClient.toWireWorkGraphScope(filter);
-        setIfDefined(params, "all_namespaces", filter.allNamespaces);
-        setIfDefined(params, "after_seq", filter.afterSeq);
-        setIfDefined(params, "limit", filter.limit);
-        return params;
-    }
-    static toWireWorkGraphGoalStatusRequest(request) {
-        const params = MeerkatClient.toWireWorkGraphScope(request);
-        params.binding_id = request.bindingId;
-        return params;
-    }
-    static toWireWorkGraphAttentionTarget(target) {
-        if (target.kind === "session") {
-            return { kind: "session", session_id: target.sessionId };
-        }
-        return { kind: "lowered_owner", owner_key: target.ownerKey };
-    }
-    static toWireWorkGraphAttentionListRequest(request) {
-        const params = MeerkatClient.toWireWorkGraphScope(request);
-        setIfDefined(params, "status", request.status);
-        if (request.target !== undefined) {
-            params.target = MeerkatClient.toWireWorkGraphAttentionTarget(request.target);
-        }
-        return params;
-    }
     static parseStringArray(value, context) {
         if (value == null) {
             return [];
@@ -2449,35 +2602,6 @@ export class MeerkatClient {
         }
         return value.map((item, index) => MeerkatClient.requireRecord(item, `entry ${index}`, context));
     }
-    static parseWorkGraphOwner(raw, context) {
-        if (raw == null) {
-            return undefined;
-        }
-        const data = MeerkatClient.requireRecord(raw, "owner", context);
-        const key = MeerkatClient.requireRecord(data.key, "key", context);
-        const kind = MeerkatClient.requireStringField(key, "kind", context);
-        if (!["principal", "agent", "session", "mob", "label"].includes(kind)) {
-            throw new MeerkatError("INVALID_RESPONSE", `${context}: invalid owner key kind`);
-        }
-        return {
-            key: {
-                kind: kind,
-                id: MeerkatClient.requireStringField(key, "id", context),
-            },
-            displayName: MeerkatClient.parseOptionalString(data.display_name),
-        };
-    }
-    static parseWorkOwnerKey(raw, context) {
-        const key = MeerkatClient.requireRecord(raw, "owner_key", context);
-        const kind = MeerkatClient.requireStringField(key, "kind", context);
-        if (!["principal", "agent", "session", "mob", "label"].includes(kind)) {
-            throw new MeerkatError("INVALID_RESPONSE", `${context}: invalid owner key kind`);
-        }
-        return {
-            kind: kind,
-            id: MeerkatClient.requireStringField(key, "id", context),
-        };
-    }
     static parseMobWireMembersBatchEdge(raw, context) {
         const data = MeerkatClient.requireRecord(raw, "edge", context);
         return {
@@ -2496,214 +2620,6 @@ export class MeerkatClient {
             alreadyWired: MeerkatClient.parseMobWireMembersBatchEdges(data.already_wired, `${context} already_wired`),
         };
     }
-    static parseWorkGraphClaim(raw) {
-        if (raw == null) {
-            return undefined;
-        }
-        const data = MeerkatClient.requireRecord(raw, "claim", "Invalid workgraph item");
-        const owner = MeerkatClient.parseWorkGraphOwner(data.owner, "Invalid workgraph item claim");
-        if (!owner) {
-            throw new MeerkatError("INVALID_RESPONSE", "Invalid workgraph item claim: missing owner");
-        }
-        return {
-            owner,
-            claimedAt: MeerkatClient.requireStringField(data, "claimed_at", "Invalid workgraph item claim"),
-            leaseExpiresAt: MeerkatClient.parseOptionalString(data.lease_expires_at),
-        };
-    }
-    static parseWorkCompletionPolicy(raw) {
-        if (raw === undefined || raw === null) {
-            return { kind: "self_attest" };
-        }
-        const policy = MeerkatClient.requireRecord(raw, "completion_policy", "Invalid workgraph item");
-        const kind = MeerkatClient.requireStringField(policy, "kind", "Invalid workgraph completion policy");
-        switch (kind) {
-            case "self_attest":
-            case "host_confirmed":
-            case "principal_confirmed":
-                return { kind };
-            case "supervisor":
-                return {
-                    kind,
-                    owner_key: MeerkatClient.parseWorkOwnerKey(policy.owner_key, "Invalid workgraph completion policy"),
-                };
-            case "reviewer_quorum":
-                return {
-                    kind,
-                    threshold: MeerkatClient.requireNumberField(policy, "threshold", "Invalid workgraph completion policy"),
-                };
-            default:
-                throw new MeerkatError("INVALID_RESPONSE", "Invalid workgraph completion policy: invalid kind");
-        }
-    }
-    static parseWorkItem(data) {
-        const status = MeerkatClient.requireStringField(data, "status", "Invalid workgraph item");
-        if (!["open", "in_progress", "blocked", "completed", "cancelled", "failed"].includes(status)) {
-            throw new MeerkatError("INVALID_RESPONSE", "Invalid workgraph item: invalid status");
-        }
-        const priority = MeerkatClient.requireStringField(data, "priority", "Invalid workgraph item");
-        if (!["low", "medium", "high"].includes(priority)) {
-            throw new MeerkatError("INVALID_RESPONSE", "Invalid workgraph item: invalid priority");
-        }
-        return {
-            id: MeerkatClient.requireStringField(data, "id", "Invalid workgraph item"),
-            realmId: MeerkatClient.requireStringField(data, "realm_id", "Invalid workgraph item"),
-            namespace: MeerkatClient.requireStringField(data, "namespace", "Invalid workgraph item"),
-            title: MeerkatClient.requireStringField(data, "title", "Invalid workgraph item"),
-            description: MeerkatClient.parseOptionalString(data.description),
-            status: status,
-            priority: priority,
-            completionPolicy: MeerkatClient.parseWorkCompletionPolicy(data.completion_policy),
-            labels: MeerkatClient.parseStringArray(data.labels, "Invalid workgraph item labels"),
-            owner: MeerkatClient.parseWorkGraphOwner(data.owner, "Invalid workgraph item"),
-            claim: MeerkatClient.parseWorkGraphClaim(data.claim),
-            machineState: MeerkatClient.requireRecord(data.machine_state, "machine_state", "Invalid workgraph item"),
-            revision: MeerkatClient.requireNumberField(data, "revision", "Invalid workgraph item"),
-            dueAt: MeerkatClient.parseOptionalString(data.due_at),
-            notBefore: MeerkatClient.parseOptionalString(data.not_before),
-            snoozedUntil: MeerkatClient.parseOptionalString(data.snoozed_until),
-            createdAt: MeerkatClient.requireStringField(data, "created_at", "Invalid workgraph item"),
-            updatedAt: MeerkatClient.requireStringField(data, "updated_at", "Invalid workgraph item"),
-            terminalAt: MeerkatClient.parseOptionalString(data.terminal_at),
-            externalRefs: MeerkatClient.parseRecordArray(data.external_refs, "Invalid workgraph external refs").map((ref) => ({
-                kind: MeerkatClient.requireStringField(ref, "kind", "Invalid workgraph external ref"),
-                id: MeerkatClient.requireStringField(ref, "id", "Invalid workgraph external ref"),
-                url: MeerkatClient.parseOptionalString(ref.url),
-            })),
-            evidenceRefs: MeerkatClient.parseRecordArray(data.evidence_refs, "Invalid workgraph evidence refs").map((ref) => ({
-                kind: MeerkatClient.requireStringField(ref, "kind", "Invalid workgraph evidence ref"),
-                id: MeerkatClient.requireStringField(ref, "id", "Invalid workgraph evidence ref"),
-                label: MeerkatClient.parseOptionalString(ref.label),
-                summary: MeerkatClient.parseOptionalString(ref.summary),
-            })),
-        };
-    }
-    static parseWorkItemArray(value, context = "Invalid workgraph item list") {
-        return MeerkatClient.requireRecordArray(value, context).map((item) => MeerkatClient.parseWorkItem(item));
-    }
-    static parseWorkGraphGoalResult(data) {
-        return {
-            item: MeerkatClient.parseWorkItem(MeerkatClient.requireRecord(data.item, "item", "Invalid workgraph goal result")),
-            attention: MeerkatClient.parseWorkAttentionBinding(MeerkatClient.requireRecord(data.attention, "attention", "Invalid workgraph goal result")),
-        };
-    }
-    static parseWorkAttentionBinding(data) {
-        const bindingId = MeerkatClient.requireStringField(data, "binding_id", "Invalid workgraph attention binding");
-        const createdAt = MeerkatClient.requireStringField(data, "created_at", "Invalid workgraph attention binding");
-        const delegatedAuthority = MeerkatClient.requireStringField(data, "delegated_authority", "Invalid workgraph attention binding");
-        if (!WORK_ATTENTION_DELEGATED_AUTHORITIES.has(delegatedAuthority)) {
-            throw new MeerkatError("INVALID_RESPONSE", "Invalid workgraph attention binding: invalid delegated_authority");
-        }
-        const mode = MeerkatClient.requireStringField(data, "mode", "Invalid workgraph attention binding");
-        if (!WORK_ATTENTION_MODES.has(mode)) {
-            throw new MeerkatError("INVALID_RESPONSE", "Invalid workgraph attention binding: invalid mode");
-        }
-        const updatedAt = MeerkatClient.requireStringField(data, "updated_at", "Invalid workgraph attention binding");
-        const status = MeerkatClient.requireRecord(data.status, "status", "Invalid workgraph attention binding");
-        const statusState = MeerkatClient.requireStringField(status, "state", "Invalid workgraph attention status");
-        if (!WORK_ATTENTION_STATES.has(statusState)) {
-            throw new MeerkatError("INVALID_RESPONSE", "Invalid workgraph attention status: invalid state");
-        }
-        const target = MeerkatClient.requireRecord(data.target, "target", "Invalid workgraph attention binding");
-        const targetKind = MeerkatClient.requireStringField(target, "kind", "Invalid workgraph attention target");
-        if (targetKind === "session") {
-            MeerkatClient.requireStringField(target, "session_id", "Invalid workgraph attention target");
-        }
-        else if (targetKind === "lowered_owner") {
-            MeerkatClient.requireRecord(target.owner_key, "owner_key", "Invalid workgraph attention target");
-        }
-        else {
-            throw new MeerkatError("INVALID_RESPONSE", "Invalid workgraph attention target: invalid kind");
-        }
-        const workRef = MeerkatClient.requireRecord(data.work_ref, "work_ref", "Invalid workgraph attention binding");
-        MeerkatClient.requireStringField(workRef, "realm_id", "Invalid workgraph attention work ref");
-        MeerkatClient.requireStringField(workRef, "namespace", "Invalid workgraph attention work ref");
-        MeerkatClient.requireStringField(workRef, "item_id", "Invalid workgraph attention work ref");
-        const attention = {
-            bindingId,
-            createdAt,
-            delegatedAuthority: delegatedAuthority,
-            machineState: MeerkatClient.optionalRecord(data.machine_state),
-            mode: mode,
-            projectionPolicy: MeerkatClient.optionalRecord(data.projection_policy),
-            status: status,
-            target: targetKind === "session"
-                ? {
-                    kind: "session",
-                    sessionId: MeerkatClient.requireStringField(target, "session_id", "Invalid workgraph attention target"),
-                }
-                : {
-                    kind: "loweredOwner",
-                    ownerKey: MeerkatClient.parseWorkOwnerKey(target.owner_key, "Invalid workgraph attention target"),
-                },
-            updatedAt,
-            workRef: {
-                realmId: MeerkatClient.requireStringField(workRef, "realm_id", "Invalid workgraph attention work ref"),
-                namespace: MeerkatClient.requireStringField(workRef, "namespace", "Invalid workgraph attention work ref"),
-                itemId: MeerkatClient.requireStringField(workRef, "item_id", "Invalid workgraph attention work ref"),
-            },
-        };
-        return attention;
-    }
-    static parseWorkAttentionBindingArray(value) {
-        return MeerkatClient.requireRecordArray(value, "Invalid workgraph attention list").map((attention) => MeerkatClient.parseWorkAttentionBinding(attention));
-    }
-    static parseWorkGraphEdge(data) {
-        const kind = MeerkatClient.requireStringField(data, "kind", "Invalid workgraph edge");
-        if (!["blocks", "parent", "related", "supersedes", "derived_from"].includes(kind)) {
-            throw new MeerkatError("INVALID_RESPONSE", "Invalid workgraph edge: invalid kind");
-        }
-        return {
-            realmId: MeerkatClient.requireStringField(data, "realm_id", "Invalid workgraph edge"),
-            namespace: MeerkatClient.requireStringField(data, "namespace", "Invalid workgraph edge"),
-            kind: kind,
-            fromId: MeerkatClient.requireStringField(data, "from_id", "Invalid workgraph edge"),
-            toId: MeerkatClient.requireStringField(data, "to_id", "Invalid workgraph edge"),
-            createdAt: MeerkatClient.requireStringField(data, "created_at", "Invalid workgraph edge"),
-        };
-    }
-    static parseWorkGraphEvent(data) {
-        const kind = MeerkatClient.requireStringField(data, "kind", "Invalid workgraph event");
-        if (![
-            "created",
-            "updated",
-            "claimed",
-            "released",
-            "blocked",
-            "closed",
-            "linked",
-            "evidence_added",
-            "attention_created",
-            "attention_updated",
-        ].includes(kind)) {
-            throw new MeerkatError("INVALID_RESPONSE", "Invalid workgraph event: invalid kind");
-        }
-        return {
-            seq: MeerkatClient.parseOptionalNumber(data.seq),
-            realmId: MeerkatClient.requireStringField(data, "realm_id", "Invalid workgraph event"),
-            namespace: MeerkatClient.requireStringField(data, "namespace", "Invalid workgraph event"),
-            itemId: MeerkatClient.parseOptionalString(data.item_id),
-            kind: kind,
-            at: MeerkatClient.requireStringField(data, "at", "Invalid workgraph event"),
-            payload: data.payload,
-        };
-    }
-    static parseWorkGraphEventArray(value) {
-        return MeerkatClient.requireRecordArray(value, "Invalid workgraph event list").map((event) => MeerkatClient.parseWorkGraphEvent(event));
-    }
-    static parseWorkGraphSnapshot(data) {
-        return {
-            realmId: MeerkatClient.requireStringField(data, "realm_id", "Invalid workgraph snapshot"),
-            namespace: MeerkatClient.parseOptionalString(data.namespace),
-            allNamespaces: MeerkatClient.requireBooleanField(data, "all_namespaces", "Invalid workgraph snapshot"),
-            capturedAt: MeerkatClient.requireStringField(data, "captured_at", "Invalid workgraph snapshot"),
-            eventHighWaterMark: MeerkatClient.parseOptionalNumber(data.event_high_water_mark),
-            items: MeerkatClient.parseWorkItemArray(data.items, "Invalid workgraph snapshot items"),
-            edges: MeerkatClient.requireRecordArray(data.edges, "Invalid workgraph snapshot edges").map((edge) => MeerkatClient.parseWorkGraphEdge(edge)),
-            attention: MeerkatClient.parseWorkAttentionBindingArray(data.attention ?? []),
-            readyItemIds: MeerkatClient.requireStringArray(data.ready_item_ids, "Invalid workgraph snapshot ready item ids"),
-        };
-    }
     static parseMobProfileLookup(data) {
         if (Boolean(data.not_found)) {
             return {
@@ -2752,50 +2668,60 @@ export class MeerkatClient {
         };
     }
     static parseSessionHistory(data) {
-        const rawMessages = Array.isArray(data.messages)
-            ? data.messages
-            : [];
+        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;
         return {
-            sessionId: String(data.session_id ?? ""),
+            sessionId: MeerkatClient.requireStringField(data, "session_id", context),
             sessionRef: data.session_ref != null ? String(data.session_ref) : undefined,
-            messageCount: Number(data.message_count ?? 0),
-            offset: Number(data.offset ?? 0),
+            messageCount: MeerkatClient.requireNumberField(data, "message_count", context),
+            offset: MeerkatClient.requireNumberField(data, "offset", context),
             limit: data.limit != null ? Number(data.limit) : undefined,
-            hasMore: Boolean(data.has_more ?? false),
+            hasMore: MeerkatClient.requireBooleanField(data, "has_more", context),
             messages: rawMessages.map((message) => MeerkatClient.parseSessionMessage(message)),
         };
     }
     static parseSessionTranscriptRevision(data) {
-        const rawMessages = Array.isArray(data.messages)
-            ? data.messages
-            : [];
+        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;
         return {
-            sessionId: String(data.session_id ?? ""),
+            sessionId: MeerkatClient.requireStringField(data, "session_id", context),
             sessionRef: data.session_ref != null ? String(data.session_ref) : undefined,
-            revision: String(data.revision ?? ""),
-            headRevision: String(data.head_revision ?? ""),
-            messageCount: Number(data.message_count ?? 0),
-            offset: Number(data.offset ?? 0),
+            revision: MeerkatClient.requireStringField(data, "revision", context),
+            headRevision: MeerkatClient.requireStringField(data, "head_revision", context),
+            messageCount: MeerkatClient.requireNumberField(data, "message_count", context),
+            offset: MeerkatClient.requireNumberField(data, "offset", context),
             limit: data.limit != null ? Number(data.limit) : undefined,
-            hasMore: Boolean(data.has_more ?? false),
+            hasMore: MeerkatClient.requireBooleanField(data, "has_more", context),
             messages: rawMessages.map((message) => MeerkatClient.parseSessionMessage(message)),
         };
     }
     static parseSessionForkResult(data) {
+        const context = "Invalid session fork response";
         return {
-            sourceSessionId: String(data.source_session_id ?? ""),
-            sessionId: String(data.session_id ?? ""),
+            sourceSessionId: MeerkatClient.requireStringField(data, "source_session_id", context),
+            sessionId: MeerkatClient.requireStringField(data, "session_id", context),
             sessionRef: data.session_ref != null ? String(data.session_ref) : undefined,
-            messageCount: Number(data.message_count ?? 0),
+            messageCount: MeerkatClient.requireNumberField(data, "message_count", context),
         };
     }
     static parseSessionTranscriptRewriteResult(data) {
+        const context = "Invalid session transcript rewrite response";
+        const commit = data.commit;
+        if (typeof commit !== "object" || commit === null || Array.isArray(commit)) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: commit must be an object`);
+        }
         return {
-            sessionId: String(data.session_id ?? ""),
-            parentRevision: String(data.parent_revision ?? ""),
-            revision: String(data.revision ?? ""),
-            messageCount: Number(data.message_count ?? 0),
-            commit: (data.commit ?? {}),
+            sessionId: MeerkatClient.requireStringField(data, "session_id", context),
+            parentRevision: MeerkatClient.requireStringField(data, "parent_revision", context),
+            revision: MeerkatClient.requireStringField(data, "revision", context),
+            messageCount: MeerkatClient.requireNumberField(data, "message_count", context),
+            commit: commit,
         };
     }
     static serializeTranscriptReplacement(replacement) {
@@ -2828,37 +2754,50 @@ export class MeerkatClient {
         throw new Error(`Unsupported transcript replacement type: ${replacement.type}`);
     }
     static parseSessionMessage(data) {
-        const role = String(data.role ?? "");
+        // Transcript truth fails closed: a message without its identity facts
+        // (role, created_at) or with malformed collections is a wire-contract
+        // violation, never coerced to ""/[] placeholder truth.
+        const context = "Invalid session message";
+        const role = MeerkatClient.requireStringField(data, "role", context);
+        const createdAt = MeerkatClient.requireStringField(data, "created_at", context);
         const contentValue = role === "system_notice" && data.content == null && data.body != null
             ? String(data.body)
             : data.content;
-        const rawToolCalls = Array.isArray(data.tool_calls)
-            ? data.tool_calls
-            : [];
-        const rawBlocks = Array.isArray(data.blocks)
-            ? data.blocks
-            : [];
-        const rawResults = Array.isArray(data.results)
-            ? data.results
-            : [];
+        if (data.blocks != null && !Array.isArray(data.blocks)) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: blocks must be a list`);
+        }
+        if (data.results != null && !Array.isArray(data.results)) {
+            throw new MeerkatError("INVALID_RESPONSE", `${context}: results must be a list`);
+        }
+        const rawBlocks = data.blocks ?? [];
+        const rawResults = data.results ?? [];
         return {
             role,
-            createdAt: String(data.created_at ?? ""),
+            createdAt,
             kind: data.kind != null ? String(data.kind) : undefined,
             body: data.body != null ? String(data.body) : undefined,
             content: contentValue != null ? MeerkatClient.parseContentInput(contentValue) : undefined,
-            toolCalls: rawToolCalls.map((toolCall) => ({
-                id: String(toolCall.id ?? ""),
-                name: String(toolCall.name ?? ""),
-                args: toolCall.args,
-            })),
             stopReason: data.stop_reason != null ? String(data.stop_reason) : undefined,
             blocks: rawBlocks.map((block) => MeerkatClient.parseSessionAssistantBlock(block)),
-            results: rawResults.map((result) => ({
-                toolUseId: String(result.tool_use_id ?? ""),
-                content: MeerkatClient.parseContentInput(result.content),
-                isError: Boolean(result.is_error ?? false),
-            })),
+            results: rawResults.map((result) => {
+                if (typeof result !== "object" || result === null) {
+                    throw new MeerkatError("INVALID_RESPONSE", `${context}: tool result must be an object`);
+                }
+                const isError = result.is_error ?? false;
+                if (typeof isError !== "boolean") {
+                    throw new MeerkatError("INVALID_RESPONSE", `${context}: is_error must be a boolean`);
+                }
+                // `WireToolResult.content` is mandatory on the wire; a frame without
+                // it is malformed and must not be coalesced into an empty transcript.
+                if (result.content === undefined || result.content === null) {
+                    throw new MeerkatError("INVALID_RESPONSE", `${context}: tool result missing content`);
+                }
+                return {
+                    toolUseId: MeerkatClient.requireStringField(result, "tool_use_id", context),
+                    content: MeerkatClient.parseContentInput(result.content),
+                    isError,
+                };
+            }),
             raw: { ...data },
         };
     }
@@ -2891,13 +2830,6 @@ export class MeerkatClient {
                     payload.content = camel.content;
                 }
             }
-            if (camel.toolCalls?.length > 0) {
-                payload.tool_calls = camel.toolCalls.map((toolCall) => ({
-                    id: toolCall.id,
-                    name: toolCall.name,
-                    args: toolCall.args,
-                }));
-            }
             if (camel.stopReason !== undefined) {
                 payload.stop_reason = camel.stopReason;
             }
@@ -2981,13 +2913,17 @@ export class MeerkatClient {
         return { type: "text", text: "" };
     }
     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`);
+        }
         const blockData = data.data ?? {};
         const blobRef = blockData.blob_ref;
         const revisedPrompt = blockData.revised_prompt != null && typeof blockData.revised_prompt === "object"
             ? blockData.revised_prompt
             : undefined;
         return {
-            blockType: String(data.block_type ?? ""),
+            blockType: MeerkatClient.requireStringField(data, "block_type", context),
             text: blockData.text != null ? String(blockData.text) : undefined,
             id: blockData.id != null ? String(blockData.id) : undefined,
             name: blockData.name != null ? String(blockData.name) : undefined,