@moxt-ai/mobius-sdk 0.0.101 → 0.0.102

package/dist/protocol/control-messages.js

@@ -0,0 +1,754 @@
+import { z } from "zod";
+import { ProtocolMessageError } from "./codecs/messages.js";
+import { identifierStringSchema as IDENTIFIER } from "./identifier.js";
+export const WORKSPACE_LIST_KIND = "workspace.list";
+export const WORKSPACE_ENTRIES_KIND = "workspace.entries";
+export const SESSION_PREPARE_KIND = "session.prepare";
+export const SESSION_READY_KIND = "session.ready";
+export const SESSION_LIST_KIND = "session.list";
+export const SESSION_LISTED_KIND = "session.listed";
+export const SESSION_QUERY_KIND = "session.query";
+export const SESSION_QUERIED_KIND = "session.queried";
+export const SESSION_RESTORE_KIND = "session.restore";
+export const SESSION_RESTORED_KIND = "session.restored";
+export const SESSION_CLOSE_KIND = "session.close";
+export const SESSION_CLOSED_KIND = "session.closed";
+export const SESSION_STATUS_CHANGED_KIND = "session.status.changed";
+export const SESSION_RENAME_KIND = "session.rename";
+export const SESSION_RENAMED_KIND = "session.renamed";
+export const SESSION_CONFIGURE_KIND = "session.configure";
+export const SESSION_CONFIG_UPDATED_KIND = "session.config.updated";
+export const SESSION_COMMANDS_UPDATED_KIND = "session.commands.updated";
+export const SESSION_INFO_UPDATED_KIND = "session.info.updated";
+export const SESSION_PERMISSION_REQUESTED_KIND = "session.permission.requested";
+export const SESSION_PERMISSION_RESPOND_KIND = "session.permission.respond";
+export const SESSION_PERMISSION_RESOLVED_KIND = "session.permission.resolved";
+export const SESSION_ELICITATION_REQUESTED_KIND = "session.elicitation.requested";
+export const SESSION_ELICITATION_RESPOND_KIND = "session.elicitation.respond";
+export const SESSION_ELICITATION_RESOLVED_KIND = "session.elicitation.resolved";
+export const SESSION_OPERATION_FAILED_KIND = "session.operation.failed";
+export const AGENT_CONTENT_KIND = "agent.content";
+export const AGENT_SETTINGS_DISCOVER_KIND = "agent.settings.discover";
+export const AGENT_SETTINGS_DISCOVERED_KIND = "agent.settings.discovered";
+export const AGENT_SETTINGS_DISCOVERY_FAILED_KIND = "agent.settings.discovery.failed";
+export const FILE_READ_KIND = "file.read";
+export const FILE_BEGIN_KIND = "file.begin";
+export const FILE_CHUNK_KIND = "file.chunk";
+export const FILE_END_KIND = "file.end";
+export const FILE_FAILED_KIND = "file.failed";
+const DIRECTORY_IDENTIFIER_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,2047}$/;
+const DIRECTORY_IDENTIFIER = z.string().min(1).max(2_048).regex(DIRECTORY_IDENTIFIER_PATTERN);
+const SHORT_TEXT = z.string().max(500);
+const LONG_TEXT = z.string().max(100_000);
+const workspaceEntrySchema = z
+    .object({
+    directoryId: DIRECTORY_IDENTIFIER,
+    name: z.string().min(1).max(255),
+})
+    .readonly();
+const sessionStatusSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("idle") }).readonly(),
+    z
+        .object({
+        commandId: IDENTIFIER,
+        kind: z.literal("working"),
+    })
+        .readonly(),
+]);
+const sessionStatusChangedEventSchema = z
+    .object({
+    kind: z.literal(SESSION_STATUS_CHANGED_KIND),
+    sessionId: IDENTIFIER,
+    status: sessionStatusSchema,
+})
+    .readonly();
+const sessionMetadataSchema = z
+    .object({
+    additionalDirectories: z.array(workspaceEntrySchema).max(16).readonly(),
+    agentId: IDENTIFIER,
+    directoryId: DIRECTORY_IDENTIFIER,
+    directoryLabel: z.string().min(1).max(2_048),
+    prompted: z.boolean(),
+    sessionId: IDENTIFIER,
+    status: sessionStatusSchema.default({ kind: "idle" }),
+    title: z.string().max(500),
+    updatedAt: z.iso.datetime({ offset: true }),
+})
+    .readonly();
+const sessionListCommandSchema = z
+    .object({
+    kind: z.literal(SESSION_LIST_KIND),
+    limit: z.number().int().positive().max(500),
+    requestId: IDENTIFIER,
+})
+    .readonly();
+const sessionsListedEventSchema = z
+    .object({
+    entries: z.array(sessionMetadataSchema).max(500).readonly(),
+    kind: z.literal(SESSION_LISTED_KIND),
+    requestId: IDENTIFIER,
+})
+    .readonly();
+const sessionQueryCommandSchema = z
+    .object({
+    kind: z.literal(SESSION_QUERY_KIND),
+    requestId: IDENTIFIER,
+    sessionIds: z.array(IDENTIFIER).min(1).max(500).readonly(),
+})
+    .readonly();
+const sessionsQueriedEventSchema = z
+    .object({
+    entries: z.array(sessionMetadataSchema).max(500).readonly(),
+    kind: z.literal(SESSION_QUERIED_KIND),
+    requestId: IDENTIFIER,
+})
+    .readonly();
+const sessionRestoreCommandSchema = z
+    .object({
+    kind: z.literal(SESSION_RESTORE_KIND),
+    requestId: IDENTIFIER,
+    sessionId: IDENTIFIER,
+})
+    .readonly();
+const sessionCloseCommandSchema = z
+    .object({
+    kind: z.literal(SESSION_CLOSE_KIND),
+    requestId: IDENTIFIER,
+    sessionId: IDENTIFIER,
+})
+    .readonly();
+const fileReadCommandSchema = z
+    .object({
+    kind: z.literal(FILE_READ_KIND),
+    maxBytes: z
+        .number()
+        .int()
+        .positive()
+        .max(128 * 1024 * 1024),
+    requestId: IDENTIFIER,
+    sessionId: IDENTIFIER,
+    path: z.string().min(1).max(4_096),
+})
+    .readonly();
+const fileBeginEventSchema = z
+    .object({
+    byteLength: z
+        .number()
+        .int()
+        .positive()
+        .max(128 * 1024 * 1024),
+    kind: z.literal(FILE_BEGIN_KIND),
+    mediaType: z.string().min(1).max(255),
+    modifiedAt: z.iso.datetime({ offset: true }),
+    name: z.string().min(1).max(500),
+    requestId: IDENTIFIER,
+    sessionId: IDENTIFIER,
+})
+    .readonly();
+const fileChunkEventSchema = z
+    .object({
+    data: z.string().min(1).max(400_000),
+    kind: z.literal(FILE_CHUNK_KIND),
+    requestId: IDENTIFIER,
+    sequence: z.number().int().nonnegative().max(1_024),
+    sessionId: IDENTIFIER,
+})
+    .readonly();
+const fileEndEventSchema = z
+    .object({
+    kind: z.literal(FILE_END_KIND),
+    requestId: IDENTIFIER,
+    sessionId: IDENTIFIER,
+})
+    .readonly();
+const fileFailedEventSchema = z
+    .object({
+    code: IDENTIFIER,
+    kind: z.literal(FILE_FAILED_KIND),
+    message: z.string().min(1).max(500),
+    requestId: IDENTIFIER,
+    sessionId: IDENTIFIER,
+})
+    .readonly();
+const configValueSchema = z
+    .object({
+    description: SHORT_TEXT,
+    groupId: z.string().max(128),
+    groupName: z.string().max(255),
+    name: z.string().min(1).max(255),
+    // ACP types a select value id as any string, and Agents use the empty
+    // id to mean "the provider's own default" — no explicit setting is
+    // sent. Refusing it would drop the whole option, so the id is bounded
+    // by length alone.
+    value: z.string().max(500),
+})
+    .readonly();
+export const sessionConfigOptionSchema = z
+    .object({
+    booleanValue: z.boolean(),
+    category: z.string().max(128),
+    currentValue: z.string().max(500),
+    description: SHORT_TEXT,
+    id: z.string().min(1).max(128),
+    name: z.string().min(1).max(255),
+    type: z.enum(["boolean", "select"]),
+    values: z.array(configValueSchema).max(500).readonly(),
+})
+    .readonly();
+const sessionConfigOptionsSchema = z.array(sessionConfigOptionSchema).max(100).readonly();
+export const agentSettingSchema = z
+    .object({
+    booleanValue: z.boolean(),
+    category: z.string().max(128),
+    defaultValue: z.string().max(500),
+    description: SHORT_TEXT,
+    id: z.string().min(1).max(128),
+    name: z.string().min(1).max(255),
+    type: z.enum(["boolean", "select"]),
+    values: z.array(configValueSchema).max(500).readonly(),
+})
+    .readonly();
+const agentSettingsSchema = z.array(agentSettingSchema).max(128).readonly();
+export const AGENT_MODEL_EFFORT_RESOLUTION_COMPLETE = "complete";
+export const AGENT_MODEL_EFFORT_RESOLUTION_ON_MODEL_SELECTION = "on_model_selection";
+export const AGENT_MODEL_EFFORT_RESOLUTION_UNAVAILABLE = "unavailable";
+const agentModelEffortResolutionSchema = z.enum([
+    AGENT_MODEL_EFFORT_RESOLUTION_COMPLETE,
+    AGENT_MODEL_EFFORT_RESOLUTION_ON_MODEL_SELECTION,
+    AGENT_MODEL_EFFORT_RESOLUTION_UNAVAILABLE,
+]);
+export const agentModelEffortSchema = z
+    .object({
+    effortSettingId: z.string().max(128),
+    modelSettingId: z.string().max(128),
+    resolution: agentModelEffortResolutionSchema,
+    unsupportedModelIds: z.array(z.string().min(1).max(500)).max(500).readonly().default([]),
+    valuesByModel: z.record(z.string().min(1).max(500), z.array(configValueSchema).max(500).readonly()).readonly(),
+})
+    .readonly();
+const agentSettingsDiscoverCommandSchema = z
+    .object({
+    agentId: IDENTIFIER,
+    kind: z.literal(AGENT_SETTINGS_DISCOVER_KIND),
+    model: z.string().min(1).max(500).optional(),
+    requestId: IDENTIFIER,
+})
+    .readonly();
+const agentSettingsDiscoveredEventSchema = z
+    .object({
+    agentId: IDENTIFIER,
+    agentName: z.string().max(255),
+    agentVersion: z.string().max(128),
+    kind: z.literal(AGENT_SETTINGS_DISCOVERED_KIND),
+    modelEffort: agentModelEffortSchema,
+    requestId: IDENTIFIER,
+    settings: agentSettingsSchema,
+    settingsRevision: z.string().regex(/^[a-f0-9]{64}$/),
+})
+    .readonly();
+const agentSettingsDiscoveryFailedEventSchema = z
+    .object({
+    code: IDENTIFIER,
+    kind: z.literal(AGENT_SETTINGS_DISCOVERY_FAILED_KIND),
+    message: z.string().min(1).max(500),
+    requestId: IDENTIFIER,
+})
+    .readonly();
+export const sessionConfigurationSelectionSchema = z
+    .object({
+    booleanValue: z.boolean(),
+    configId: IDENTIFIER,
+    value: z.string().max(500),
+    valueType: z.enum(["boolean", "select"]),
+})
+    .readonly();
+export const AGENT_DEFAULT_EXECUTION_SETTING = "agent_default";
+export const AGENT_PERMISSION_MODE_CONFIG_ID = "permission_mode";
+export const AGENT_PERMISSION_MODES = Object.freeze([
+    AGENT_DEFAULT_EXECUTION_SETTING,
+    "read-only",
+    "workspace-write",
+    "danger-full-access",
+]);
+export const agentExecutionConfigurationSchema = z
+    .object({
+    model: sessionConfigurationSelectionSchema,
+    permissionMode: z.string().refine((value) => AGENT_PERMISSION_MODES.includes(value)),
+    reasoningEffort: sessionConfigurationSelectionSchema,
+})
+    .superRefine((configuration, context) => {
+    if (configuration.model.valueType !== "select" ||
+        configuration.model.booleanValue ||
+        configuration.model.value.length === 0 ||
+        configuration.reasoningEffort.valueType !== "select" ||
+        configuration.reasoningEffort.booleanValue ||
+        configuration.reasoningEffort.value.length === 0) {
+        context.addIssue({
+            code: "custom",
+            message: "Model and reasoning effort must be explicit select configurations",
+        });
+    }
+    if (configuration.model.configId === configuration.reasoningEffort.configId ||
+        configuration.model.configId === AGENT_PERMISSION_MODE_CONFIG_ID ||
+        configuration.reasoningEffort.configId === AGENT_PERMISSION_MODE_CONFIG_ID) {
+        context.addIssue({
+            code: "custom",
+            message: "Required execution setting identifiers must differ",
+        });
+    }
+})
+    .readonly();
+function agentDefaultSelection(configId) {
+    return Object.freeze({
+        booleanValue: false,
+        configId,
+        value: AGENT_DEFAULT_EXECUTION_SETTING,
+        valueType: "select",
+    });
+}
+export const DEFAULT_AGENT_EXECUTION_CONFIGURATION = Object.freeze({
+    model: agentDefaultSelection("model"),
+    permissionMode: AGENT_DEFAULT_EXECUTION_SETTING,
+    reasoningEffort: agentDefaultSelection("reasoning_effort"),
+});
+export const sessionConfigurationSelectionsSchema = z
+    .array(sessionConfigurationSelectionSchema)
+    .max(100)
+    .superRefine((selections, context) => {
+    const identifiers = new Set();
+    for (const [index, selection] of selections.entries()) {
+        if (identifiers.has(selection.configId)) {
+            context.addIssue({
+                code: "custom",
+                message: "Session configuration identifiers must be unique",
+                path: [index, "configId"],
+            });
+        }
+        identifiers.add(selection.configId);
+    }
+})
+    .readonly();
+export const sessionCapabilitiesSchema = z
+    .object({
+    additionalDirectories: z.boolean(),
+    audioPrompt: z.boolean(),
+    closeSession: z.boolean(),
+    deleteSession: z.boolean(),
+    embeddedContextPrompt: z.boolean(),
+    imagePrompt: z.boolean(),
+    listSessions: z.boolean(),
+    loadSession: z.boolean(),
+    promptQueueing: z.boolean().default(false),
+    renameSession: z.boolean().default(false),
+    resumeSession: z.boolean(),
+    steering: z.boolean().default(false),
+    unstableForkSession: z.boolean().default(false),
+})
+    .readonly();
+const sessionCommandSchema = z
+    .object({
+    description: SHORT_TEXT,
+    inputHint: z.string().max(255),
+    name: z.string().min(1).max(128),
+})
+    .readonly();
+export const permissionOptionSchema = z
+    .object({
+    kind: z.enum(["allow_once", "allow_always", "reject_once", "reject_always"]),
+    name: z.string().min(1).max(255),
+    optionId: z.string().min(1).max(255),
+})
+    .readonly();
+const elicitationOptionSchema = z
+    .object({
+    description: SHORT_TEXT,
+    label: z.string().min(1).max(255),
+    value: z.string().max(500),
+})
+    .readonly();
+export const elicitationFieldSchema = z
+    .object({
+    defaultBooleanValue: z.boolean(),
+    defaultNumberValue: z.number().finite(),
+    defaultStringValue: z.string().max(10_000),
+    description: SHORT_TEXT,
+    format: z.string().max(64),
+    hasDefaultValue: z.boolean(),
+    maximum: z.string().max(128),
+    maximumLength: z.string().max(128),
+    minimum: z.string().max(128),
+    minimumLength: z.string().max(128),
+    name: z.string().min(1).max(128),
+    options: z.array(elicitationOptionSchema).max(200).readonly(),
+    pattern: z.string().max(500),
+    required: z.boolean(),
+    title: z.string().min(1).max(255),
+    type: z.enum(["boolean", "integer", "multiselect", "number", "select", "string"]),
+})
+    .readonly();
+export const displayContentSchema = z
+    .object({
+    artifactId: z.string().max(128).default(""),
+    data: z.string().max(4_000_000),
+    mimeType: z.string().max(255),
+    name: z.string().max(500),
+    newText: LONG_TEXT,
+    oldText: LONG_TEXT,
+    path: z.string().max(2_048),
+    terminalId: z.string().max(255),
+    text: LONG_TEXT,
+    type: z.enum(["diff", "image", "resource", "resource_link", "terminal", "text", "video"]),
+    uri: z.string().max(4_096),
+})
+    .readonly();
+export const promptImageSchema = z
+    .object({
+    data: z.string().min(1).max(4_000_000),
+    mimeType: z.string().min(1).max(255),
+    name: z.string().min(1).max(500),
+})
+    .readonly();
+const promptResourceSchema = z
+    .object({
+    mimeType: z.string().max(255),
+    name: z.string().min(1).max(500),
+    text: z.string().max(1_000_000),
+    type: z.enum(["embedded", "link"]),
+    uri: z.string().min(1).max(4_096),
+})
+    .readonly();
+const workspaceListCommandSchema = z
+    .object({
+    bindingId: IDENTIFIER,
+    directoryId: DIRECTORY_IDENTIFIER,
+    kind: z.literal(WORKSPACE_LIST_KIND),
+    requestId: IDENTIFIER,
+})
+    .readonly();
+const workspaceEntriesEventSchema = z
+    .object({
+    bindingId: IDENTIFIER,
+    directoryId: DIRECTORY_IDENTIFIER,
+    directoryLabel: z.string().min(1).max(2_048),
+    entries: z.array(workspaceEntrySchema).max(500).readonly(),
+    kind: z.literal(WORKSPACE_ENTRIES_KIND),
+    parentDirectoryId: z.string().max(2_048),
+    requestId: IDENTIFIER,
+})
+    .readonly();
+const sessionIdentityFields = {
+    additionalDirectoryIds: z.array(DIRECTORY_IDENTIFIER).max(16).readonly(),
+    agentId: IDENTIFIER,
+    bindingId: IDENTIFIER,
+    directoryId: DIRECTORY_IDENTIFIER,
+    sessionId: IDENTIFIER,
+};
+const sessionPrepareCommandSchema = z
+    .object({
+    ...sessionIdentityFields,
+    configuration: z
+        .object({
+        booleanValue: z.boolean(),
+        configId: z.string().min(1).max(128),
+        value: z.string().max(500),
+        valueType: z.enum(["boolean", "select"]),
+    })
+        .readonly()
+        .optional(),
+    kind: z.literal(SESSION_PREPARE_KIND),
+    requestId: IDENTIFIER,
+    sessionState: z.literal("provisioned").optional(),
+    /** Marks an inspection-only Session preparation. */
+    transient: z.boolean().optional(),
+})
+    .superRefine((command, context) => {
+    if (command.transient === true && command.sessionState === "provisioned") {
+        context.addIssue({
+            code: "custom",
+            message: "A transient Session cannot already be provisioned",
+            path: ["sessionState"],
+        });
+    }
+})
+    .readonly();
+const runtimeTimingsSchema = z
+    .array(z
+    .object({
+    durationMilliseconds: z.number().finite().nonnegative().max(120_000),
+    name: z.string().regex(/^[a-z][a-z0-9-]{0,63}$/),
+})
+    .readonly())
+    .max(16)
+    .readonly();
+export const sessionReadyEventSchema = z
+    .object({
+    additionalDirectories: z.array(workspaceEntrySchema).max(16).readonly(),
+    agentId: IDENTIFIER,
+    agentName: z.string().max(255),
+    agentVersion: z.string().max(128),
+    capabilities: sessionCapabilitiesSchema,
+    commands: z.array(sessionCommandSchema).max(500).readonly(),
+    configOptions: sessionConfigOptionsSchema,
+    directoryId: DIRECTORY_IDENTIFIER,
+    directoryLabel: z.string().min(1).max(2_048),
+    kind: z.literal(SESSION_READY_KIND),
+    requestId: IDENTIFIER,
+    restored: z.boolean(),
+    runtimeTimings: runtimeTimingsSchema.optional(),
+    sessionId: IDENTIFIER,
+})
+    .readonly();
+const sessionRestoredEventSchema = z
+    .object({
+    entry: sessionMetadataSchema,
+    kind: z.literal(SESSION_RESTORED_KIND),
+    ready: sessionReadyEventSchema,
+    requestId: IDENTIFIER,
+})
+    .readonly();
+const sessionClosedEventSchema = z
+    .object({
+    kind: z.literal(SESSION_CLOSED_KIND),
+    requestId: IDENTIFIER,
+    sessionId: IDENTIFIER,
+})
+    .readonly();
+const sessionConfigureCommandSchema = z
+    .object({
+    ...sessionIdentityFields,
+    booleanValue: z.boolean(),
+    configId: z.string().min(1).max(128),
+    kind: z.literal(SESSION_CONFIGURE_KIND),
+    requestId: IDENTIFIER,
+    value: z.string().max(500),
+    valueType: z.enum(["boolean", "select"]),
+})
+    .readonly();
+const sessionRenameCommandSchema = z
+    .object({
+    kind: z.literal(SESSION_RENAME_KIND),
+    requestId: IDENTIFIER,
+    sessionId: IDENTIFIER,
+    title: z.string().min(1).max(500),
+})
+    .readonly();
+const sessionRenamedEventSchema = z
+    .object({
+    kind: z.literal(SESSION_RENAMED_KIND),
+    requestId: IDENTIFIER,
+    sessionId: IDENTIFIER,
+    title: z.string().min(1).max(500),
+    updatedAt: z.string().max(128),
+})
+    .readonly();
+const sessionConfigUpdatedEventSchema = z
+    .object({
+    configOptions: sessionConfigOptionsSchema,
+    kind: z.literal(SESSION_CONFIG_UPDATED_KIND),
+    requestId: IDENTIFIER,
+    sessionId: IDENTIFIER,
+})
+    .readonly();
+const sessionCommandsUpdatedEventSchema = z
+    .object({
+    commands: z.array(sessionCommandSchema).max(500).readonly(),
+    kind: z.literal(SESSION_COMMANDS_UPDATED_KIND),
+    sessionId: IDENTIFIER,
+})
+    .readonly();
+const sessionInfoUpdatedEventSchema = z
+    .object({
+    kind: z.literal(SESSION_INFO_UPDATED_KIND),
+    projectId: IDENTIFIER.optional(),
+    sessionId: IDENTIFIER,
+    title: z.string().max(500).nullable(),
+    updatedAt: z.string().max(128),
+})
+    .readonly();
+export const sessionPermissionRequestedEventSchema = z
+    .object({
+    commandId: IDENTIFIER,
+    interactionId: IDENTIFIER,
+    kind: z.literal(SESSION_PERMISSION_REQUESTED_KIND),
+    options: z.array(permissionOptionSchema).min(1).max(20).readonly(),
+    sessionId: IDENTIFIER,
+    title: z.string().min(1).max(500),
+    toolCallId: z.string().min(1).max(255),
+    toolKind: z.string().max(64),
+})
+    .readonly();
+const sessionPermissionRespondCommandSchema = z
+    .object({
+    interactionId: IDENTIFIER,
+    kind: z.literal(SESSION_PERMISSION_RESPOND_KIND),
+    optionId: z.string().max(255),
+    outcome: z.enum(["cancelled", "selected"]),
+    sessionId: IDENTIFIER,
+})
+    .readonly();
+export const sessionPermissionResolvedEventSchema = z
+    .object({
+    interactionId: IDENTIFIER,
+    kind: z.literal(SESSION_PERMISSION_RESOLVED_KIND),
+    optionId: z.string().max(255),
+    outcome: z.enum(["cancelled", "selected"]),
+    sessionId: IDENTIFIER,
+})
+    .readonly();
+export const sessionElicitationRequestedEventSchema = z
+    .object({
+    accepted: z.boolean(),
+    commandId: IDENTIFIER,
+    elicitationId: z.string().max(255),
+    fields: z.array(elicitationFieldSchema).max(100).readonly(),
+    interactionId: IDENTIFIER,
+    kind: z.literal(SESSION_ELICITATION_REQUESTED_KIND),
+    message: z.string().min(1).max(2_000),
+    mode: z.enum(["form", "url"]),
+    sessionId: IDENTIFIER,
+    url: z.string().max(4_096),
+})
+    .readonly();
+const sessionElicitationRespondCommandSchema = z
+    .object({
+    action: z.enum(["accept", "cancel", "decline"]),
+    content: z.string().max(100_000),
+    interactionId: IDENTIFIER,
+    kind: z.literal(SESSION_ELICITATION_RESPOND_KIND),
+    sessionId: IDENTIFIER,
+})
+    .readonly();
+export const sessionElicitationResolvedEventSchema = z
+    .object({
+    action: z.enum(["accept", "cancel", "decline", "complete"]),
+    interactionId: IDENTIFIER,
+    kind: z.literal(SESSION_ELICITATION_RESOLVED_KIND),
+    sessionId: IDENTIFIER,
+})
+    .readonly();
+const sessionOperationFailedEventSchema = z
+    .object({
+    code: IDENTIFIER,
+    kind: z.literal(SESSION_OPERATION_FAILED_KIND),
+    message: z.string().min(1).max(500),
+    requestId: IDENTIFIER,
+    runtimeTimings: runtimeTimingsSchema.optional(),
+    sessionId: z.string().max(128),
+})
+    .readonly();
+const agentContentEventSchema = z
+    .object({
+    commandId: IDENTIFIER,
+    content: displayContentSchema,
+    contentId: IDENTIFIER,
+    kind: z.literal(AGENT_CONTENT_KIND),
+    messageId: z.string().max(255),
+    sessionId: IDENTIFIER,
+})
+    .readonly();
+function parseJson(encoded) {
+    try {
+        return JSON.parse(encoded);
+    }
+    catch (error) {
+        throw new ProtocolMessageError("Message is not valid JSON", {
+            cause: error,
+        });
+    }
+}
+function decode(encoded, schema) {
+    const result = schema.safeParse(parseJson(encoded));
+    if (!result.success) {
+        throw new ProtocolMessageError("Message does not match its schema", {
+            cause: result.error,
+        });
+    }
+    return result.data;
+}
+function decodeValue(value, schema) {
+    const result = schema.safeParse(value);
+    if (!result.success) {
+        throw new ProtocolMessageError("Message field does not match its schema", {
+            cause: result.error,
+        });
+    }
+    return result.data;
+}
+export const decodeAgentDisplayContentValue = (value) => decodeValue(value, displayContentSchema);
+export const decodePromptImagesValue = (value) => decodeValue(value, z.array(promptImageSchema).max(8).readonly());
+export const decodePromptResourcesValue = (value) => decodeValue(value, z.array(promptResourceSchema).max(16).readonly());
+export const decodeSessionConfigurationSelections = (value) => decodeValue(value, sessionConfigurationSelectionsSchema);
+export const decodeAgentExecutionConfiguration = (value) => decodeValue(value, agentExecutionConfigurationSchema);
+export const decodeSessionConfigOptions = (value) => decodeValue(value, sessionConfigOptionsSchema);
+const encode = (message, schema) => JSON.stringify(decodeValue(message, schema));
+export const decodeAgentSettingsDiscoverCommand = (encoded) => decode(encoded, agentSettingsDiscoverCommandSchema);
+export const encodeAgentSettingsDiscoverCommand = (message) => encode(message, agentSettingsDiscoverCommandSchema);
+export const decodeAgentSettingsDiscoveredEvent = (encoded) => decode(encoded, agentSettingsDiscoveredEventSchema);
+export const encodeAgentSettingsDiscoveredEvent = (message) => encode(message, agentSettingsDiscoveredEventSchema);
+export const decodeAgentSettingsDiscoveryFailedEvent = (encoded) => decode(encoded, agentSettingsDiscoveryFailedEventSchema);
+export const encodeAgentSettingsDiscoveryFailedEvent = (message) => encode(message, agentSettingsDiscoveryFailedEventSchema);
+export const decodeFileReadCommand = (encoded) => decode(encoded, fileReadCommandSchema);
+export const encodeFileReadCommand = (message) => encode(message, fileReadCommandSchema);
+export const decodeFileBeginEvent = (encoded) => decode(encoded, fileBeginEventSchema);
+export const encodeFileBeginEvent = (message) => encode(message, fileBeginEventSchema);
+export const decodeFileChunkEvent = (encoded) => decode(encoded, fileChunkEventSchema);
+export const encodeFileChunkEvent = (message) => encode(message, fileChunkEventSchema);
+export const decodeFileEndEvent = (encoded) => decode(encoded, fileEndEventSchema);
+export const encodeFileEndEvent = (message) => encode(message, fileEndEventSchema);
+export const decodeFileFailedEvent = (encoded) => decode(encoded, fileFailedEventSchema);
+export const encodeFileFailedEvent = (message) => encode(message, fileFailedEventSchema);
+export const decodeWorkspaceListCommand = (encoded) => decode(encoded, workspaceListCommandSchema);
+export const encodeWorkspaceListCommand = (message) => encode(message, workspaceListCommandSchema);
+export const decodeWorkspaceEntriesEvent = (encoded) => decode(encoded, workspaceEntriesEventSchema);
+export const encodeWorkspaceEntriesEvent = (message) => encode(message, workspaceEntriesEventSchema);
+export const decodeSessionListCommand = (encoded) => decode(encoded, sessionListCommandSchema);
+export const encodeSessionListCommand = (message) => encode(message, sessionListCommandSchema);
+export const decodeSessionsListedEvent = (encoded) => decode(encoded, sessionsListedEventSchema);
+export const encodeSessionsListedEvent = (message) => encode(message, sessionsListedEventSchema);
+export const decodeSessionQueryCommand = (encoded) => decode(encoded, sessionQueryCommandSchema);
+export const encodeSessionQueryCommand = (message) => encode(message, sessionQueryCommandSchema);
+export const decodeSessionsQueriedEvent = (encoded) => decode(encoded, sessionsQueriedEventSchema);
+export const encodeSessionsQueriedEvent = (message) => encode(message, sessionsQueriedEventSchema);
+export const decodeSessionRestoreCommand = (encoded) => decode(encoded, sessionRestoreCommandSchema);
+export const encodeSessionRestoreCommand = (message) => encode(message, sessionRestoreCommandSchema);
+export const decodeSessionRestoredEvent = (encoded) => decode(encoded, sessionRestoredEventSchema);
+export const encodeSessionRestoredEvent = (message) => encode(message, sessionRestoredEventSchema);
+export const decodeSessionCloseCommand = (encoded) => decode(encoded, sessionCloseCommandSchema);
+export const encodeSessionCloseCommand = (message) => encode(message, sessionCloseCommandSchema);
+export const decodeSessionClosedEvent = (encoded) => decode(encoded, sessionClosedEventSchema);
+export const encodeSessionClosedEvent = (message) => encode(message, sessionClosedEventSchema);
+export const decodeSessionStatusChangedEvent = (encoded) => decode(encoded, sessionStatusChangedEventSchema);
+export const encodeSessionStatusChangedEvent = (message) => encode(message, sessionStatusChangedEventSchema);
+export const decodeSessionPrepareCommand = (encoded) => decode(encoded, sessionPrepareCommandSchema);
+export const encodeSessionPrepareCommand = (message) => encode(message, sessionPrepareCommandSchema);
+export const decodeSessionReadyEvent = (encoded) => decode(encoded, sessionReadyEventSchema);
+export const encodeSessionReadyEvent = (message) => encode(message, sessionReadyEventSchema);
+export const decodeSessionConfigureCommand = (encoded) => decode(encoded, sessionConfigureCommandSchema);
+export const encodeSessionConfigureCommand = (message) => encode(message, sessionConfigureCommandSchema);
+export const decodeSessionConfigUpdatedEvent = (encoded) => decode(encoded, sessionConfigUpdatedEventSchema);
+export const encodeSessionConfigUpdatedEvent = (message) => encode(message, sessionConfigUpdatedEventSchema);
+export const decodeSessionRenameCommand = (encoded) => decode(encoded, sessionRenameCommandSchema);
+export const encodeSessionRenameCommand = (message) => encode(message, sessionRenameCommandSchema);
+export const decodeSessionRenamedEvent = (encoded) => decode(encoded, sessionRenamedEventSchema);
+export const encodeSessionRenamedEvent = (message) => encode(message, sessionRenamedEventSchema);
+export const decodeSessionCommandsUpdatedEvent = (encoded) => decode(encoded, sessionCommandsUpdatedEventSchema);
+export const encodeSessionCommandsUpdatedEvent = (message) => encode(message, sessionCommandsUpdatedEventSchema);
+export const decodeSessionInfoUpdatedEvent = (encoded) => decode(encoded, sessionInfoUpdatedEventSchema);
+export const encodeSessionInfoUpdatedEvent = (message) => encode(message, sessionInfoUpdatedEventSchema);
+export const decodeSessionPermissionRequestedEvent = (encoded) => decode(encoded, sessionPermissionRequestedEventSchema);
+export const encodeSessionPermissionRequestedEvent = (message) => encode(message, sessionPermissionRequestedEventSchema);
+export const decodeSessionPermissionRespondCommand = (encoded) => decode(encoded, sessionPermissionRespondCommandSchema);
+export const encodeSessionPermissionRespondCommand = (message) => encode(message, sessionPermissionRespondCommandSchema);
+export const decodeSessionPermissionResolvedEvent = (encoded) => decode(encoded, sessionPermissionResolvedEventSchema);
+export const encodeSessionPermissionResolvedEvent = (message) => encode(message, sessionPermissionResolvedEventSchema);
+export const decodeSessionElicitationRequestedEvent = (encoded) => decode(encoded, sessionElicitationRequestedEventSchema);
+export const encodeSessionElicitationRequestedEvent = (message) => encode(message, sessionElicitationRequestedEventSchema);
+export const decodeSessionElicitationRespondCommand = (encoded) => decode(encoded, sessionElicitationRespondCommandSchema);
+export const encodeSessionElicitationRespondCommand = (message) => encode(message, sessionElicitationRespondCommandSchema);
+export const decodeSessionElicitationResolvedEvent = (encoded) => decode(encoded, sessionElicitationResolvedEventSchema);
+export const encodeSessionElicitationResolvedEvent = (message) => encode(message, sessionElicitationResolvedEventSchema);
+export const decodeSessionOperationFailedEvent = (encoded) => decode(encoded, sessionOperationFailedEventSchema);
+export const encodeSessionOperationFailedEvent = (message) => encode(message, sessionOperationFailedEventSchema);
+export const decodeAgentContentEvent = (encoded) => decode(encoded, agentContentEventSchema);
+export const encodeAgentContentEvent = (message) => encode(message, agentContentEventSchema);
+//# sourceMappingURL=control-messages.js.map