@rkat/sdk 0.6.23 → 0.6.24

package/dist/client.js

@@ -78,6 +78,26 @@ 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);
 }
@@ -505,6 +525,18 @@ export class MeerkatClient {
         const raw = await this.request("session/history", params);
         return MeerkatClient.parseSessionHistory(raw);
     }
+    async readSessionTranscriptRevision(sessionId, revision, options) {
+        const params = {
+            session_id: sessionId,
+            revision,
+            offset: options?.offset ?? 0,
+        };
+        if (options?.limit !== undefined) {
+            params.limit = options.limit;
+        }
+        const raw = await this.request("session/transcript_revision", params);
+        return MeerkatClient.parseSessionTranscriptRevision(raw);
+    }
     async forkSessionAt(sessionId, messageIndex, options) {
         const params = {
             session_id: sessionId,
@@ -528,6 +560,43 @@ export class MeerkatClient {
         const raw = await this.request("session/fork_replace", params);
         return MeerkatClient.parseSessionForkResult(raw);
     }
+    async rewriteSessionTranscript(sessionId, selection, replacement, reason, options) {
+        const params = {
+            session_id: sessionId,
+            selection,
+            replacement: replacement.map((message) => MeerkatClient.serializeTranscriptRewriteMessage(message)),
+            reason,
+        };
+        if (options?.actor !== undefined) {
+            params.actor = options.actor;
+        }
+        if (options?.expectedParentRevision !== undefined) {
+            params.expected_parent_revision = options.expectedParentRevision;
+        }
+        if (options?.runningBehavior !== undefined) {
+            params.running_behavior = options.runningBehavior;
+        }
+        const raw = await this.request("session/rewrite_transcript", params);
+        return MeerkatClient.parseSessionTranscriptRewriteResult(raw);
+    }
+    async restoreSessionTranscriptRevision(sessionId, revision, reason, options) {
+        const params = {
+            session_id: sessionId,
+            revision,
+            reason,
+        };
+        if (options?.actor !== undefined) {
+            params.actor = options.actor;
+        }
+        if (options?.expectedParentRevision !== undefined) {
+            params.expected_parent_revision = options.expectedParentRevision;
+        }
+        if (options?.runningBehavior !== undefined) {
+            params.running_behavior = options.runningBehavior;
+        }
+        const raw = await this.request("session/restore_transcript_revision", params);
+        return MeerkatClient.parseSessionTranscriptRewriteResult(raw);
+    }
     // -- Capabilities -------------------------------------------------------
     get capabilities() {
         return this._capabilities;
@@ -738,6 +807,16 @@ export class MeerkatClient {
             events: MeerkatClient.parseWorkGraphEventArray(result.events),
         };
     }
+    async getWorkGraphGoalStatus(params) {
+        const result = await this.request("workgraph/goal/status", MeerkatClient.toWireWorkGraphGoalStatusRequest(params));
+        return MeerkatClient.parseWorkGraphGoalResult(result);
+    }
+    async listWorkGraphAttention(params = {}) {
+        const result = await this.request("workgraph/attention/list", MeerkatClient.toWireWorkGraphAttentionListRequest(params));
+        return {
+            attention: MeerkatClient.parseWorkAttentionBindingArray(result.attention),
+        };
+    }
     async subscribeSessionEvents(sessionId) {
         return this.openEventSubscription("session/stream_open", { session_id: sessionId }, "session/stream_close", MeerkatClient.parseAgentEventEnvelope);
     }
@@ -1951,7 +2030,10 @@ export class MeerkatClient {
     }
     registerRequest(id) {
         return new Promise((resolve, reject) => {
-            this.pendingRequests.set(id, { resolve, reject });
+            this.pendingRequests.set(id, {
+                resolve: (value) => resolve(value),
+                reject,
+            });
         });
     }
     // -- Static helpers -----------------------------------------------------
@@ -1971,6 +2053,15 @@ export class MeerkatClient {
         }
         return raw;
     }
+    static optionalRecord(raw) {
+        if (raw === undefined || raw === null) {
+            return undefined;
+        }
+        if (typeof raw !== "object" || Array.isArray(raw)) {
+            return undefined;
+        }
+        return raw;
+    }
     static requireStringField(raw, field, context) {
         const value = raw[field];
         if (typeof value !== "string" || value.length === 0) {
@@ -2310,6 +2401,25 @@ export class MeerkatClient {
         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 [];
@@ -2357,6 +2467,17 @@ export class MeerkatClient {
             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 {
@@ -2390,6 +2511,31 @@ export class MeerkatClient {
             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)) {
@@ -2407,9 +2553,11 @@ export class MeerkatClient {
             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),
@@ -2433,6 +2581,73 @@ export class MeerkatClient {
     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)) {
@@ -2458,6 +2673,8 @@ export class MeerkatClient {
             "closed",
             "linked",
             "evidence_added",
+            "attention_created",
+            "attention_updated",
         ].includes(kind)) {
             throw new MeerkatError("INVALID_RESPONSE", "Invalid workgraph event: invalid kind");
         }
@@ -2483,6 +2700,7 @@ export class MeerkatClient {
             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"),
         };
     }
@@ -2547,6 +2765,22 @@ export class MeerkatClient {
             messages: rawMessages.map((message) => MeerkatClient.parseSessionMessage(message)),
         };
     }
+    static parseSessionTranscriptRevision(data) {
+        const rawMessages = Array.isArray(data.messages)
+            ? data.messages
+            : [];
+        return {
+            sessionId: String(data.session_id ?? ""),
+            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),
+            limit: data.limit != null ? Number(data.limit) : undefined,
+            hasMore: Boolean(data.has_more ?? false),
+            messages: rawMessages.map((message) => MeerkatClient.parseSessionMessage(message)),
+        };
+    }
     static parseSessionForkResult(data) {
         return {
             sourceSessionId: String(data.source_session_id ?? ""),
@@ -2555,6 +2789,15 @@ export class MeerkatClient {
             messageCount: Number(data.message_count ?? 0),
         };
     }
+    static parseSessionTranscriptRewriteResult(data) {
+        return {
+            sessionId: String(data.session_id ?? ""),
+            parentRevision: String(data.parent_revision ?? ""),
+            revision: String(data.revision ?? ""),
+            messageCount: Number(data.message_count ?? 0),
+            commit: (data.commit ?? {}),
+        };
+    }
     static serializeTranscriptReplacement(replacement) {
         switch (replacement.type) {
             case "message":
@@ -2601,6 +2844,8 @@ export class MeerkatClient {
         return {
             role,
             createdAt: String(data.created_at ?? ""),
+            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 ?? ""),
@@ -2614,6 +2859,84 @@ export class MeerkatClient {
                 content: MeerkatClient.parseContentInput(result.content),
                 isError: Boolean(result.is_error ?? false),
             })),
+            raw: { ...data },
+        };
+    }
+    static serializeTranscriptRewriteMessage(message) {
+        const camel = message;
+        if (camel.createdAt !== undefined) {
+            const payload = {
+                ...(camel.raw ?? {}),
+                role: camel.role,
+                created_at: camel.createdAt,
+            };
+            if (camel.kind !== undefined) {
+                payload.kind = camel.kind;
+            }
+            if (camel.role === "system_notice") {
+                delete payload.body;
+                delete payload.content;
+                if (camel.body !== undefined) {
+                    payload.body = camel.body;
+                }
+                else if (camel.content !== undefined) {
+                    payload.content = camel.content;
+                }
+            }
+            else {
+                if (camel.body !== undefined) {
+                    payload.body = camel.body;
+                }
+                if (camel.content !== undefined) {
+                    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;
+            }
+            if (camel.blocks?.length > 0) {
+                payload.blocks = camel.blocks.map((block) => MeerkatClient.serializeSessionAssistantBlock(block));
+            }
+            if (camel.results?.length > 0) {
+                payload.results = camel.results.map((result) => ({
+                    tool_use_id: result.toolUseId,
+                    content: result.content,
+                    is_error: result.isError,
+                }));
+            }
+            return payload;
+        }
+        return { ...message };
+    }
+    static serializeSessionAssistantBlock(block) {
+        const data = {
+            ...(block.raw?.data ?? {}),
+        };
+        setIfDefined(data, "text", block.text);
+        setIfDefined(data, "id", block.id);
+        setIfDefined(data, "name", block.name);
+        setIfDefined(data, "args", block.args);
+        setIfDefined(data, "image_id", block.imageId);
+        if (block.blobId !== undefined) {
+            data.blob_ref = { blob_id: block.blobId };
+        }
+        setIfDefined(data, "media_type", block.mediaType);
+        setIfDefined(data, "width", block.width);
+        setIfDefined(data, "height", block.height);
+        setIfDefined(data, "revised_prompt", block.revisedPrompt);
+        setIfDefined(data, "meta", block.meta);
+        setIfDefined(data, "source", block.source);
+        return {
+            ...(block.raw ?? {}),
+            block_type: block.blockType,
+            data,
         };
     }
     static parseContentInput(value) {
@@ -2679,6 +3002,7 @@ export class MeerkatClient {
             // 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,
+            raw: { ...data },
         };
     }
     static parseMcpLiveOpResponse(raw) {