@di-code/coding-agent 0.1.6 → 0.1.8

package/dist/rpc/protocol.js

@@ -1,6 +1,67 @@
+import { validateWebManifest } from "@di-code/plugin-runtime";
 export const RPC_PROTOCOL_VERSION = 1;
 export const RPC_MAX_ID_LENGTH = 128;
 export const RPC_MAX_PROMPT_LENGTH = 1_000_000;
+export const RPC_MAX_ATTACHMENTS_PER_REQUEST = 4;
+export const RPC_MAX_ATTACHMENT_BYTES = 5 * 1024 * 1024;
+/** Allows one JSONL user entry containing a maximum-sized base64 image to be read in a single transcript page. */
+export const RPC_MAX_TRANSCRIPT_BYTES = 8 * 1024 * 1024;
+const RPC_MAX_ATTACHMENT_BASE64_LENGTH = Math.ceil(RPC_MAX_ATTACHMENT_BYTES / 3) * 4;
+/** v1 grows only by methods and optional fields. Clients must negotiate extended events first. */
+export const RPC_METHODS = [
+    "prompt",
+    "cancel",
+    "get_state",
+    "get_capabilities",
+    "resume_events",
+    "list_sessions",
+    "new_session",
+    "open_session",
+    "inspect_session",
+    "rename_session",
+    "delete_session",
+    "branch_session",
+    "get_transcript",
+    "get_tree",
+    "navigate_tree",
+    "steer",
+    "retry",
+    "get_operation",
+    "get_models",
+    "set_model",
+    "get_runtime",
+    "set_runtime",
+    "set_thinking_level",
+    "compact",
+    "set_compaction_enabled",
+    "get_usage",
+    "list_skills",
+    "get_resources",
+    "get_product_state",
+    "list_providers",
+    "get_settings",
+    "set_default_provider",
+    "set_default_model",
+    "set_locale",
+    "set_permission_mode",
+    "configure_custom_provider",
+    "login",
+    "logout",
+    "get_project_trust",
+    "set_project_trust",
+    "list_context_files",
+    "list_mcp_servers",
+    "configure_mcp_server",
+    "remove_mcp_server",
+    "reconnect_mcp_server",
+    "list_plugins",
+    "list_web_contributions",
+    "list_commands",
+    "run_command",
+    "set_plugin_enabled",
+    "create_attachment",
+    "approve_tool",
+];
 const RPC_ERROR_CODES = new Set([
     "PARSE_ERROR",
     "INVALID_REQUEST",
@@ -10,10 +71,14 @@ const RPC_ERROR_CODES = new Set([
     "BUSY",
     "NOT_FOUND",
     "CANCELLED",
+    "DISPOSED",
+    "SESSION_IN_USE",
+    "INVALID_WORKSPACE",
+    "UNAUTHORIZED",
     "INTERNAL_ERROR",
     "PROCESS_EXIT",
 ]);
-const RPC_EVENT_TYPES = new Set([
+const LEGACY_EVENT_TYPES = new Set([
     "agent_start",
     "turn_start",
     "message_start",
@@ -25,8 +90,25 @@ const RPC_EVENT_TYPES = new Set([
     "agent_end",
     "compaction_start",
     "compaction_end",
+    "queue_update",
+    "tree_navigated",
     "usage_update",
 ]);
+const EXTENDED_EVENT_TYPES = new Set([
+    "snapshot_required",
+    "operation_update",
+    "session_changed",
+    "tool_approval",
+    "product_audit",
+]);
+const EXTENDED_EVENT_NAMES = new Set([
+    "sequence",
+    "operation_update",
+    "snapshot_required",
+    "session_changed",
+    "tool_approval",
+    "product_audit",
+]);
 const ASSISTANT_STOP_REASONS = new Set(["stop", "length", "tool_use", "error", "aborted"]);
 export class RpcProtocolError extends Error {
     code;
@@ -44,61 +126,214 @@ function objectRecord(value) {
         : undefined;
 }
 function requiredId(value, field, requestId) {
-    if (typeof value !== "string" || value.length === 0 || value.length > RPC_MAX_ID_LENGTH) {
+    if (typeof value !== "string" || value.length === 0 || value.length > RPC_MAX_ID_LENGTH)
         throw new RpcProtocolError("INVALID_REQUEST", `${field} must be a non-empty string of at most ${RPC_MAX_ID_LENGTH} characters.`, requestId);
-    }
     return value;
 }
 function parseJsonObject(line) {
-    let value;
     try {
-        value = JSON.parse(line);
+        const result = objectRecord(JSON.parse(line));
+        if (!result)
+            throw new RpcProtocolError("INVALID_REQUEST", "RPC input must be a JSON object.");
+        return result;
     }
-    catch {
+    catch (cause) {
+        if (cause instanceof RpcProtocolError)
+            throw cause;
         throw new RpcProtocolError("PARSE_ERROR", "RPC input must be valid JSON.");
     }
-    const record = objectRecord(value);
-    if (!record)
-        throw new RpcProtocolError("INVALID_REQUEST", "RPC input must be a JSON object.");
-    return record;
 }
 function assertVersion(record, requestId) {
-    if (record.version !== RPC_PROTOCOL_VERSION) {
+    if (record.version !== RPC_PROTOCOL_VERSION)
         throw new RpcProtocolError("UNSUPPORTED_VERSION", `Unsupported RPC protocol version; expected ${RPC_PROTOCOL_VERSION}.`, requestId);
-    }
 }
+function stringParam(params, name, id, optional = false) {
+    const value = params[name];
+    if (optional && value === undefined)
+        return;
+    if (typeof value !== "string" || value.length === 0 || value.length > RPC_MAX_PROMPT_LENGTH)
+        throw new RpcProtocolError("INVALID_PARAMS", `${name} must be a non-empty string.`, id);
+}
+function booleanParam(params, name, id) {
+    if (typeof params[name] !== "boolean")
+        throw new RpcProtocolError("INVALID_PARAMS", `${name} must be a boolean.`, id);
+}
+function attachmentIdsParam(params, id) {
+    if (params.attachmentIds === undefined)
+        return;
+    if (!Array.isArray(params.attachmentIds) ||
+        params.attachmentIds.length > RPC_MAX_ATTACHMENTS_PER_REQUEST ||
+        !params.attachmentIds.every((value) => typeof value === "string" && value.length > 0 && value.length <= RPC_MAX_ID_LENGTH))
+        throw new RpcProtocolError("INVALID_PARAMS", `attachmentIds must contain at most ${RPC_MAX_ATTACHMENTS_PER_REQUEST} attachment IDs.`, id);
+}
+function attachmentDataParam(params, id) {
+    const data = params.data;
+    if (typeof data !== "string" || data.length === 0 || data.length > RPC_MAX_ATTACHMENT_BASE64_LENGTH)
+        throw new RpcProtocolError("INVALID_PARAMS", "Attachment data exceeds the permitted size.", id);
+}
+/** Parses every public v1 method before any dispatcher or transport observes it. */
 export function parseRpcRequest(line) {
     const record = parseJsonObject(line);
     const candidateId = typeof record.id === "string" ? record.id : undefined;
     assertVersion(record, candidateId);
-    if (record.kind !== "request") {
+    if (record.kind !== "request")
         throw new RpcProtocolError("INVALID_REQUEST", 'RPC request kind must be "request".', candidateId);
-    }
     const id = requiredId(record.id, "id", candidateId);
     const params = objectRecord(record.params);
     if (!params)
         throw new RpcProtocolError("INVALID_PARAMS", "RPC params must be an object.", id);
-    switch (record.method) {
-        case "prompt": {
-            const message = params.message;
-            if (typeof message !== "string" || message.trim().length === 0 || message.length > RPC_MAX_PROMPT_LENGTH) {
-                throw new RpcProtocolError("INVALID_PARAMS", `prompt.message must be non-empty and at most ${RPC_MAX_PROMPT_LENGTH} characters.`, id);
-            }
-            return { version: RPC_PROTOCOL_VERSION, kind: "request", id, method: "prompt", params: { message } };
-        }
+    if (typeof record.method !== "string" || !RPC_METHODS.includes(record.method))
+        throw new RpcProtocolError("METHOD_NOT_FOUND", "Unknown RPC method.", id);
+    const method = record.method;
+    switch (method) {
+        case "prompt":
+        case "steer":
+            stringParam(params, "message", id);
+            attachmentIdsParam(params, id);
+            break;
         case "cancel":
-            return {
-                version: RPC_PROTOCOL_VERSION,
-                kind: "request",
-                id,
-                method: "cancel",
-                params: { requestId: requiredId(params.requestId, "cancel.requestId", id) },
-            };
-        case "get_state":
-            return { version: RPC_PROTOCOL_VERSION, kind: "request", id, method: "get_state", params: {} };
-        default:
-            throw new RpcProtocolError("METHOD_NOT_FOUND", "Unknown RPC method.", id);
+        case "get_operation":
+        case "open_session":
+        case "inspect_session":
+        case "rename_session":
+        case "delete_session":
+        case "navigate_tree":
+        case "set_model":
+        case "logout":
+        case "reconnect_mcp_server":
+            stringParam(params, method === "cancel" || method === "get_operation"
+                ? "requestId"
+                : method === "open_session"
+                    ? "sessionId"
+                    : method === "inspect_session" || method === "rename_session" || method === "delete_session"
+                        ? "sessionId"
+                        : method === "navigate_tree"
+                            ? "entryId"
+                            : method === "set_model"
+                                ? "modelId"
+                                : method === "logout"
+                                    ? "providerId"
+                                    : "serverId", id);
+            if (method === "rename_session")
+                stringParam(params, "label", id);
+            if (method === "delete_session")
+                stringParam(params, "confirmation", id);
+            break;
+        case "branch_session":
+            if (params.sessionId !== undefined)
+                stringParam(params, "sessionId", id, true);
+            if (params.entryId !== undefined)
+                stringParam(params, "entryId", id, true);
+            break;
+        case "set_runtime":
+            stringParam(params, "providerId", id);
+            stringParam(params, "modelId", id);
+            break;
+        case "run_command":
+            stringParam(params, "name", id);
+            if (!/^[a-z][a-z0-9-]*(?::[a-z][a-z0-9-]*)?$/.test(params.name))
+                throw new RpcProtocolError("INVALID_PARAMS", "run_command.name is invalid.", id);
+            if (params.args !== undefined && (typeof params.args !== "string" || params.args.length > RPC_MAX_PROMPT_LENGTH))
+                throw new RpcProtocolError("INVALID_PARAMS", "args must be a string of at most 1,000,000 characters.", id);
+            break;
+        case "set_default_provider":
+        case "set_default_model":
+        case "set_locale":
+        case "set_permission_mode":
+            stringParam(params, method === "set_default_provider"
+                ? "providerId"
+                : method === "set_default_model"
+                    ? "modelId"
+                    : method === "set_locale"
+                        ? "locale"
+                        : "permissionMode", id);
+            if (method === "set_locale" && params.locale !== "en" && params.locale !== "zh-CN")
+                throw new RpcProtocolError("INVALID_PARAMS", "locale must be en or zh-CN.", id);
+            if (method === "set_permission_mode" &&
+                params.permissionMode !== "ask" &&
+                params.permissionMode !== "allow" &&
+                params.permissionMode !== "deny")
+                throw new RpcProtocolError("INVALID_PARAMS", "permissionMode must be ask, allow, or deny.", id);
+            break;
+        case "configure_custom_provider":
+            for (const name of ["api", "baseUrl", "apiKey", "modelId"])
+                stringParam(params, name, id);
+            if (!["openai-responses", "openai-chat-completions", "anthropic-messages"].includes(params.api))
+                throw new RpcProtocolError("INVALID_PARAMS", "Unsupported custom Provider API.", id);
+            break;
+        case "set_thinking_level":
+            if (params.level !== undefined &&
+                params.level !== "low" &&
+                params.level !== "medium" &&
+                params.level !== "high" &&
+                params.level !== "max")
+                throw new RpcProtocolError("INVALID_PARAMS", "set_thinking_level.level must be a valid thinking level.", id);
+            break;
+        case "retry":
+            stringParam(params, "targetRequestId", id);
+            break;
+        case "login":
+            stringParam(params, "providerId", id);
+            stringParam(params, "apiKey", id);
+            if (params.modelId !== undefined)
+                stringParam(params, "modelId", id, true);
+            if (params.api !== undefined)
+                stringParam(params, "api", id, true);
+            break;
+        case "configure_mcp_server":
+            stringParam(params, "serverId", id);
+            stringParam(params, "scope", id);
+            if (!objectRecord(params.config))
+                throw new RpcProtocolError("INVALID_PARAMS", "config must be an object.", id);
+            break;
+        case "remove_mcp_server":
+            stringParam(params, "serverId", id);
+            if (params.scope !== undefined)
+                stringParam(params, "scope", id, true);
+            break;
+        case "set_plugin_enabled":
+            stringParam(params, "pluginId", id);
+            booleanParam(params, "enabled", id);
+            break;
+        case "set_compaction_enabled":
+        case "set_project_trust":
+            booleanParam(params, method === "set_compaction_enabled" ? "enabled" : "trusted", id);
+            break;
+        case "get_capabilities":
+            if (params.events !== undefined &&
+                (!Array.isArray(params.events) || !params.events.every((item) => typeof item === "string")))
+                throw new RpcProtocolError("INVALID_PARAMS", "get_capabilities.events must be a string array.", id);
+            break;
+        case "resume_events":
+            if (params.lastSequence !== undefined &&
+                (!Number.isSafeInteger(params.lastSequence) || params.lastSequence < 0))
+                throw new RpcProtocolError("INVALID_PARAMS", "resume_events.lastSequence must be a non-negative integer.", id);
+            break;
+        case "create_attachment":
+            stringParam(params, "name", id);
+            stringParam(params, "contentType", id);
+            attachmentDataParam(params, id);
+            if (!["image/png", "image/jpeg", "image/webp", "image/gif"].includes(params.contentType))
+                throw new RpcProtocolError("INVALID_PARAMS", "Attachment contentType is unsupported.", id);
+            break;
+        case "get_transcript":
+            if (params.pageToken !== undefined)
+                stringParam(params, "pageToken", id, true);
+            if (params.pageSize !== undefined &&
+                (!Number.isSafeInteger(params.pageSize) || params.pageSize < 1 || params.pageSize > 200))
+                throw new RpcProtocolError("INVALID_PARAMS", "pageSize must be an integer between 1 and 200.", id);
+            if (params.maxBytes !== undefined &&
+                (!Number.isSafeInteger(params.maxBytes) ||
+                    params.maxBytes < 1024 ||
+                    params.maxBytes > RPC_MAX_TRANSCRIPT_BYTES))
+                throw new RpcProtocolError("INVALID_PARAMS", `maxBytes must be between 1024 and ${RPC_MAX_TRANSCRIPT_BYTES}.`, id);
+            break;
+        case "approve_tool":
+            stringParam(params, "approvalId", id);
+            booleanParam(params, "approved", id);
+            break;
     }
+    return { version: RPC_PROTOCOL_VERSION, kind: "request", id, method, params };
 }
 export function parseRpcServerMessage(line) {
     const record = parseJsonObject(line);
@@ -106,22 +341,26 @@ export function parseRpcServerMessage(line) {
     if (record.kind === "event") {
         requiredId(record.requestId, "requestId");
         const event = objectRecord(record.event);
-        if (!event || typeof event.type !== "string" || !RPC_EVENT_TYPES.has(event.type)) {
+        const type = event?.type;
+        if (typeof type !== "string" ||
+            (!LEGACY_EVENT_TYPES.has(type) && !EXTENDED_EVENT_TYPES.has(type)))
+            throw new RpcProtocolError("INVALID_REQUEST", "RPC event must contain a typed event object.");
+        if (!event)
             throw new RpcProtocolError("INVALID_REQUEST", "RPC event must contain a typed event object.");
-        }
+        if (record.sequence !== undefined && (!Number.isSafeInteger(record.sequence) || record.sequence < 0))
+            throw new RpcProtocolError("INVALID_REQUEST", "RPC event sequence is invalid.");
+        assertEvent(event, type);
         return record;
     }
-    if (record.kind !== "response") {
+    if (record.kind !== "response")
         throw new RpcProtocolError("INVALID_REQUEST", 'RPC server message kind must be "response" or "event".');
-    }
     if (record.ok === false) {
         const error = objectRecord(record.error);
         if (!error ||
             typeof error.code !== "string" ||
             !RPC_ERROR_CODES.has(error.code) ||
-            typeof error.message !== "string") {
+            typeof error.message !== "string")
             throw new RpcProtocolError("INVALID_REQUEST", "RPC error response has an invalid error object.");
-        }
         if (record.id !== undefined)
             requiredId(record.id, "id");
         return record;
@@ -130,94 +369,307 @@ export function parseRpcServerMessage(line) {
         throw new RpcProtocolError("INVALID_REQUEST", "RPC response ok must be a boolean.");
     requiredId(record.id, "id");
     const result = objectRecord(record.result);
-    if (!result) {
-        throw new RpcProtocolError("INVALID_REQUEST", "RPC success response must contain a result object.");
-    }
+    if (!result || typeof result.method !== "string" || !RPC_METHODS.includes(result.method))
+        throw new RpcProtocolError("INVALID_REQUEST", "RPC success response has an unknown method.");
     assertSuccessResult(result);
     return record;
 }
 function assertSuccessResult(result) {
     switch (result.method) {
-        case "prompt": {
-            const message = objectRecord(result.message);
-            if (!message ||
-                message.role !== "assistant" ||
-                !Array.isArray(message.content) ||
-                !message.content.every(isAssistantContent) ||
-                typeof message.provider !== "string" ||
-                typeof message.model !== "string" ||
-                !finiteNumber(message.timestamp) ||
-                typeof message.stopReason !== "string" ||
-                !ASSISTANT_STOP_REASONS.has(message.stopReason) ||
-                !isUsage(message.usage) ||
-                (message.stopReason === "error" || message.stopReason === "aborted"
-                    ? typeof message.errorMessage !== "string"
-                    : message.errorMessage !== undefined)) {
-                throw new RpcProtocolError("INVALID_REQUEST", "RPC prompt response has an invalid message.");
-            }
+        case "prompt":
+        case "retry":
+            assertAssistantMessage(result.message);
             return;
-        }
         case "cancel":
-            if (typeof result.cancelled !== "boolean") {
-                throw new RpcProtocolError("INVALID_REQUEST", "RPC cancel response has an invalid result.");
-            }
+            if (typeof result.cancelled !== "boolean")
+                throw new RpcProtocolError("INVALID_REQUEST", "RPC cancel result is invalid.");
             return;
-        case "get_state": {
-            const state = objectRecord(result.state);
-            if (!state ||
-                typeof state.sessionId !== "string" ||
-                state.sessionId.length === 0 ||
-                typeof state.modelId !== "string" ||
-                state.modelId.length === 0 ||
-                typeof state.isStreaming !== "boolean" ||
-                !Number.isInteger(state.messageCount) ||
-                state.messageCount < 0) {
-                throw new RpcProtocolError("INVALID_REQUEST", "RPC get_state response has an invalid state.");
+        case "get_state":
+            assertState(result.state);
+            return;
+        case "get_capabilities":
+            assertCapabilities(result);
+            return;
+        case "resume_events":
+            if (typeof result.snapshotRequired !== "boolean")
+                throw new RpcProtocolError("INVALID_REQUEST", "RPC resume_events result is invalid.");
+            return;
+        case "get_operation":
+            assertOperationState(result.operation);
+            return;
+        case "create_attachment":
+            assertAttachmentInfo(result.attachment);
+            return;
+        case "get_product_state":
+            assertProductState(result.state);
+            return;
+        case "get_project_trust":
+            if (typeof result.trusted !== "boolean")
+                throw new RpcProtocolError("INVALID_REQUEST", "RPC get_project_trust result is invalid.");
+            return;
+        case "list_sessions":
+            if (!Array.isArray(result.sessions))
+                throw new RpcProtocolError("INVALID_REQUEST", "RPC list_sessions result is invalid.");
+            for (const session of result.sessions)
+                assertSessionInfo(session);
+            return;
+        case "new_session":
+        case "open_session":
+        case "rename_session":
+        case "branch_session":
+            assertSessionInfo(result.session);
+            return;
+        case "inspect_session":
+            if (!objectRecord(result.snapshot))
+                throw new RpcProtocolError("INVALID_REQUEST", "RPC Session snapshot is invalid.");
+            return;
+        case "list_providers":
+            if (!Array.isArray(result.providers))
+                throw new RpcProtocolError("INVALID_REQUEST", "RPC providers result is invalid.");
+            return;
+        case "list_context_files":
+            if (!Array.isArray(result.files))
+                throw new RpcProtocolError("INVALID_REQUEST", "RPC context files result is invalid.");
+            return;
+        case "list_mcp_servers":
+            if (!Array.isArray(result.servers))
+                throw new RpcProtocolError("INVALID_REQUEST", "RPC MCP result is invalid.");
+            return;
+        case "list_web_contributions":
+            {
+                const manifest = objectRecord(result.manifest);
+                if (!manifest || !validateWebManifest(manifest))
+                    throw new RpcProtocolError("INVALID_REQUEST", "RPC Web contribution manifest is invalid.");
             }
             return;
-        }
-        default:
-            throw new RpcProtocolError("INVALID_REQUEST", "RPC success response has an unknown method.");
-    }
-}
-function finiteNumber(value) {
-    return typeof value === "number" && Number.isFinite(value);
-}
-function nonNegativeNumber(value) {
-    return finiteNumber(value) && value >= 0;
-}
-function isAssistantContent(value) {
-    const content = objectRecord(value);
-    if (!content)
-        return false;
-    switch (content.type) {
-        case "text":
-            return typeof content.text === "string";
-        case "thinking":
-            return typeof content.thinking === "string";
-        case "tool_call":
-            return (typeof content.id === "string" &&
-                typeof content.name === "string" &&
-                objectRecord(content.arguments) !== undefined);
-        default:
-            return false;
-    }
-}
-function isUsage(value) {
-    const usage = objectRecord(value);
-    const cost = objectRecord(usage?.cost);
-    return Boolean(usage &&
-        cost &&
-        nonNegativeNumber(usage.input) &&
-        nonNegativeNumber(usage.output) &&
-        nonNegativeNumber(usage.cacheRead) &&
-        nonNegativeNumber(usage.cacheWrite) &&
-        nonNegativeNumber(usage.totalTokens) &&
-        nonNegativeNumber(cost.input) &&
-        nonNegativeNumber(cost.output) &&
-        nonNegativeNumber(cost.cacheRead) &&
-        nonNegativeNumber(cost.cacheWrite) &&
-        nonNegativeNumber(cost.total));
+        case "list_commands":
+            if (!Array.isArray(result.commands))
+                throw new RpcProtocolError("INVALID_REQUEST", "RPC commands result is invalid.");
+            for (const command of result.commands)
+                assertCommandInfo(command);
+            return;
+        case "run_command":
+            if (typeof result.command !== "string" || !result.command)
+                throw new RpcProtocolError("INVALID_REQUEST", "RPC command result is invalid.");
+            if (result.action !== undefined)
+                assertCommandAction(result.action);
+            return;
+        case "configure_mcp_server":
+        case "reconnect_mcp_server":
+            if (!objectRecord(result.server))
+                throw new RpcProtocolError("INVALID_REQUEST", "RPC MCP result is invalid.");
+            return;
+        case "login":
+            if (!objectRecord(result.provider))
+                throw new RpcProtocolError("INVALID_REQUEST", "RPC login result is invalid.");
+            return;
+        case "set_project_trust":
+            if (typeof result.trusted !== "boolean")
+                throw new RpcProtocolError("INVALID_REQUEST", "RPC trust result is invalid.");
+            return;
+        case "logout":
+        case "remove_mcp_server":
+            return;
+        case "get_settings":
+            if (!objectRecord(result.settings))
+                throw new RpcProtocolError("INVALID_REQUEST", "RPC settings result is invalid.");
+            return;
+        case "set_default_provider":
+        case "set_default_model":
+        case "set_locale":
+        case "set_permission_mode":
+        case "configure_custom_provider":
+            return;
+    }
+}
+function assertCapabilities(result) {
+    if (!Array.isArray(result.methods) ||
+        !result.methods.every((method) => typeof method === "string" && RPC_METHODS.includes(method)) ||
+        !Array.isArray(result.events) ||
+        !result.events.every((event) => typeof event === "string" && EXTENDED_EVENT_NAMES.has(event)) ||
+        !Number.isSafeInteger(result.eventBufferSize) ||
+        result.eventBufferSize < 0)
+        throw new RpcProtocolError("INVALID_REQUEST", "RPC get_capabilities result is invalid.");
+}
+function assertSessionInfo(value) {
+    const session = objectRecord(value);
+    if (!session || typeof session.id !== "string" || !session.id || typeof session.label !== "string")
+        throw new RpcProtocolError("INVALID_REQUEST", "RPC Session result is invalid.");
+    if (session.modifiedAt !== undefined && !Number.isFinite(session.modifiedAt))
+        throw new RpcProtocolError("INVALID_REQUEST", "RPC Session modifiedAt is invalid.");
+}
+function assertCommandInfo(value) {
+    const command = objectRecord(value);
+    if (!command ||
+        typeof command.name !== "string" ||
+        !command.name ||
+        typeof command.description !== "string" ||
+        (command.kind !== "command" && command.kind !== "skill"))
+        throw new RpcProtocolError("INVALID_REQUEST", "RPC command info is invalid.");
+}
+function assertCommandAction(value) {
+    const action = objectRecord(value);
+    if (!action || typeof action.command !== "string" || !action.command || typeof action.args !== "string")
+        throw new RpcProtocolError("INVALID_REQUEST", "RPC command action is invalid.");
+}
+function assertOperationState(value) {
+    const operation = objectRecord(value);
+    if (!operation ||
+        typeof operation.requestId !== "string" ||
+        !operation.requestId ||
+        typeof operation.kind !== "string" ||
+        !RPC_METHODS.includes(operation.kind) ||
+        typeof operation.status !== "string" ||
+        !["queued", "running", "completed", "failed", "cancelled", "crashed"].includes(operation.status))
+        throw new RpcProtocolError("INVALID_REQUEST", "RPC operation state is invalid.");
+    if (operation.sessionId !== undefined && typeof operation.sessionId !== "string")
+        throw new RpcProtocolError("INVALID_REQUEST", "RPC operation session ID is invalid.");
+    if (operation.message !== undefined)
+        assertAssistantMessage(operation.message);
+    if (operation.error !== undefined)
+        assertError(operation.error);
+}
+function assertAttachmentInfo(value) {
+    const attachment = objectRecord(value);
+    if (!attachment ||
+        typeof attachment.id !== "string" ||
+        !attachment.id ||
+        typeof attachment.name !== "string" ||
+        !attachment.name ||
+        typeof attachment.contentType !== "string" ||
+        !["image/png", "image/jpeg", "image/webp", "image/gif"].includes(attachment.contentType) ||
+        !Number.isSafeInteger(attachment.bytes) ||
+        attachment.bytes < 0)
+        throw new RpcProtocolError("INVALID_REQUEST", "RPC attachment result is invalid.");
+}
+function assertProductState(value) {
+    const state = objectRecord(value);
+    if (!state || typeof state.projectTrusted !== "boolean")
+        throw new RpcProtocolError("INVALID_REQUEST", "RPC product state is invalid.");
+}
+function assertError(value) {
+    const error = objectRecord(value);
+    if (!error ||
+        typeof error.code !== "string" ||
+        !RPC_ERROR_CODES.has(error.code) ||
+        typeof error.message !== "string")
+        throw new RpcProtocolError("INVALID_REQUEST", "RPC error result is invalid.");
+}
+function assertEvent(event, type) {
+    if (type === "operation_update") {
+        assertOperationState(event.operation);
+        return;
+    }
+    if (type === "session_changed") {
+        if (event.session !== undefined)
+            assertSessionInfo(event.session);
+        return;
+    }
+    if (type === "snapshot_required")
+        return;
+    if (type === "tool_approval") {
+        if (typeof event.approvalId !== "string")
+            throw new RpcProtocolError("INVALID_REQUEST", "RPC tool_approval event is invalid.");
+        return;
+    }
+    if (type === "product_audit") {
+        if (typeof event.action !== "string" ||
+            ![
+                "login",
+                "logout",
+                "set_project_trust",
+                "configure_mcp_server",
+                "remove_mcp_server",
+                "reconnect_mcp_server",
+            ].includes(event.action) ||
+            (event.target !== undefined && typeof event.target !== "string") ||
+            (event.projectTrusted !== undefined && typeof event.projectTrusted !== "boolean"))
+            throw new RpcProtocolError("INVALID_REQUEST", "RPC product_audit event is invalid.");
+        return;
+    }
+    if (type === "tool_execution_start") {
+        if (typeof event.toolCallId !== "string" || typeof event.toolName !== "string" || !objectRecord(event.arguments))
+            throw new RpcProtocolError("INVALID_REQUEST", "RPC tool event is invalid.");
+        return;
+    }
+    if (type === "tool_execution_end") {
+        if (typeof event.toolCallId !== "string" || typeof event.toolName !== "string" || !objectRecord(event.result))
+            throw new RpcProtocolError("INVALID_REQUEST", "RPC tool event is invalid.");
+        return;
+    }
+    if (type === "message_start" || type === "message_end") {
+        if (!objectRecord(event.message))
+            throw new RpcProtocolError("INVALID_REQUEST", "RPC message event is invalid.");
+        return;
+    }
+    if (type === "message_update") {
+        const update = objectRecord(event.event);
+        if (!update || typeof update.type !== "string")
+            throw new RpcProtocolError("INVALID_REQUEST", "RPC message update event is invalid.");
+        return;
+    }
+    if (type === "turn_end") {
+        if (!objectRecord(event.message) || !Array.isArray(event.toolResults))
+            throw new RpcProtocolError("INVALID_REQUEST", "RPC turn event is invalid.");
+        return;
+    }
+    if (type === "agent_end") {
+        if (!Array.isArray(event.messages))
+            throw new RpcProtocolError("INVALID_REQUEST", "RPC agent event is invalid.");
+        return;
+    }
+    if (type === "compaction_start") {
+        if (event.reason !== "threshold" && event.reason !== "manual")
+            throw new RpcProtocolError("INVALID_REQUEST", "RPC compaction event is invalid.");
+        return;
+    }
+    if (type === "compaction_end") {
+        if ((event.reason !== "threshold" && event.reason !== "manual") ||
+            typeof event.success !== "boolean" ||
+            (event.errorMessage !== undefined && typeof event.errorMessage !== "string"))
+            throw new RpcProtocolError("INVALID_REQUEST", "RPC compaction event is invalid.");
+        return;
+    }
+    if (type === "queue_update") {
+        if (!Array.isArray(event.steering) || !event.steering.every((item) => typeof item === "string"))
+            throw new RpcProtocolError("INVALID_REQUEST", "RPC queue event is invalid.");
+        return;
+    }
+    if (type === "tree_navigated") {
+        if (typeof event.oldLeafId !== "string" ||
+            typeof event.newLeafId !== "string" ||
+            typeof event.selectedEntryId !== "string" ||
+            typeof event.restoredEditorText !== "boolean")
+            throw new RpcProtocolError("INVALID_REQUEST", "RPC tree event is invalid.");
+        return;
+    }
+    if (type === "usage_update" && !objectRecord(event.usage)) {
+        throw new RpcProtocolError("INVALID_REQUEST", "RPC usage event is invalid.");
+    }
+}
+function assertState(value) {
+    const state = objectRecord(value);
+    if (!state ||
+        typeof state.sessionId !== "string" ||
+        !state.sessionId ||
+        typeof state.modelId !== "string" ||
+        !state.modelId ||
+        typeof state.isStreaming !== "boolean" ||
+        !Number.isInteger(state.messageCount) ||
+        state.messageCount < 0)
+        throw new RpcProtocolError("INVALID_REQUEST", "RPC get_state response has an invalid state.");
+}
+function assertAssistantMessage(value) {
+    const message = objectRecord(value);
+    if (!message ||
+        message.role !== "assistant" ||
+        !Array.isArray(message.content) ||
+        typeof message.provider !== "string" ||
+        typeof message.model !== "string" ||
+        !Number.isFinite(message.timestamp) ||
+        typeof message.stopReason !== "string" ||
+        !ASSISTANT_STOP_REASONS.has(message.stopReason))
+        throw new RpcProtocolError("INVALID_REQUEST", "RPC prompt response has an invalid message.");
 }
 export function rpcErrorResponse(error) {
     return {