@myagentroam/protocol 0.1.0

package/dist/index.js

@@ -0,0 +1,714 @@
+import { z } from 'zod';
+export const healthStatusSchema = z.object({
+    status: z.literal('ok')
+});
+/** The only wire protocol version understood by this build. */
+export const NODE_PROTOCOL_VERSION = 2;
+export const WORKBENCH_PROTOCOL_VERSION = 1;
+export const nodePlatformSchema = z.enum(['win32', 'linux']);
+export const runnerAvailabilitySchema = z.object({
+    available: z.boolean(),
+    version: z.string().optional()
+});
+export const nodeCapabilitiesSchema = z.object({
+    platform: nodePlatformSchema,
+    architecture: z.string().min(1).max(128),
+    nodeVersion: z.string().min(1).max(128),
+    codex: runnerAvailabilitySchema,
+    claudeCode: runnerAvailabilitySchema
+});
+export const workspaceKindSchema = z.enum(['DIRECTORY', 'GIT_WORKSPACE']);
+export const gitSummarySchema = z.object({
+    commonDir: z.string(),
+    head: z.string(),
+    branch: z.string().nullable(),
+    dirty: z.boolean(),
+    snapshot: z.string()
+});
+/** Runner names are deliberately closed in the first implementation. */
+export const runnerNameSchema = z.enum(['codex', 'claude-code']);
+/** Account-level quota visibility is intentionally separate from a Runner's execution availability. */
+export const runnerUsageStatusSchema = z.object({
+    runner: runnerNameSchema,
+    available: z.boolean(),
+    reasonCode: z.string().min(1).max(80).nullable()
+});
+export const runnerUsageWindowSchema = z.object({
+    id: z.string().min(1).max(80),
+    label: z.string().min(1).max(128),
+    usedPercentage: z.number().finite().min(0).max(100),
+    resetsAt: z.number().int().nonnegative().nullable()
+});
+export const runnerUsageSchema = z.object({
+    runner: runnerNameSchema,
+    windows: z.array(runnerUsageWindowSchema).min(1).max(8),
+    fetchedAt: z.number().int().nonnegative(),
+    cached: z.boolean()
+});
+/** What the runner can do in an existing native conversation. */
+export const runnerControlLevelSchema = z.enum(['OBSERVE', 'MESSAGE', 'INTERRUPT']);
+export const runnerCapabilitiesSchema = z.object({
+    available: z.boolean(),
+    version: z.string().max(128).optional(),
+    controlLevel: runnerControlLevelSchema,
+    supportsResume: z.boolean(),
+    supportsExternalSession: z.boolean()
+});
+/** Fixed runner contracts; implementations are supplied by later runner tasks. */
+export const runnerDefinitionSchema = z.object({
+    name: runnerNameSchema,
+    capabilities: runnerCapabilitiesSchema
+});
+export const runnerDefinitions = {
+    codex: {
+        name: 'codex',
+        capabilities: {
+            available: false,
+            controlLevel: 'INTERRUPT',
+            supportsResume: true,
+            supportsExternalSession: true
+        }
+    },
+    'claude-code': {
+        name: 'claude-code',
+        capabilities: {
+            available: false,
+            controlLevel: 'INTERRUPT',
+            supportsResume: true,
+            supportsExternalSession: true
+        }
+    }
+};
+export const agentRunStatusSchema = z.enum([
+    'QUEUED',
+    'STARTING',
+    'RUNNING',
+    'CANCELLING',
+    'SUCCEEDED',
+    'FAILED',
+    'CANCELLED',
+    'INTERRUPTED'
+]);
+/** Process-local Workspace FIFO projection; queue contents never enter SQLite. */
+export const workspaceQueueItemSchema = z.object({
+    run: z.object({
+        id: z.string().min(1).max(128),
+        sessionId: z.string().min(1).max(128),
+        workspaceId: z.string().min(1).max(128),
+        runner: runnerNameSchema,
+        status: z.literal('QUEUED'),
+        clientMessageId: z.string().min(1).max(128),
+        createdAt: z.number().int().nonnegative()
+    }),
+    sessionId: z.string().min(1).max(128),
+    sessionTitle: z.string().max(160),
+    content: z.string().min(1).max(20_000)
+});
+export const workspaceQueueSchema = z.object({
+    version: z.number().int().nonnegative(),
+    paused: z.boolean(),
+    items: z.array(workspaceQueueItemSchema)
+});
+export const runEventSchema = z.object({
+    runId: z.string().min(1).max(128),
+    sequence: z.number().int().positive(),
+    eventType: z.string().regex(/^[A-Za-z0-9._-]{1,80}$/),
+    payload: z.unknown(),
+    status: agentRunStatusSchema.optional(),
+    version: z.number().int().nonnegative().optional()
+});
+/**
+ * Node-to-Workbench asynchronous notifications.  This is deliberately a
+ * small envelope: business payloads remain owned by the Node and Server only
+ * authenticates and relays them to an Admin page connection.
+ */
+export const workbenchEventCategorySchema = z.enum([
+    'node',
+    'session',
+    'conversation',
+    'run',
+    'queue',
+    'workspace'
+]);
+export const workbenchEventSchema = z.object({
+    sequence: z.number().int().positive(),
+    category: workbenchEventCategorySchema,
+    payload: z.unknown()
+});
+const capabilityAvailabilityBaseSchema = z.object({
+    available: z.boolean(),
+    reasonCode: z.string().min(1).max(80).nullable()
+});
+function refineCapabilityAvailability(schema) {
+    return schema.superRefine((value, context) => {
+        if (value.available && value.reasonCode !== null) {
+            context.addIssue({ code: 'custom', message: 'available capability cannot have reasonCode' });
+        }
+        if (!value.available && value.reasonCode === null) {
+            context.addIssue({ code: 'custom', message: 'unavailable capability requires reasonCode' });
+        }
+    });
+}
+function capabilitySchemaWith(shape) {
+    return refineCapabilityAvailability(capabilityAvailabilityBaseSchema.extend(shape));
+}
+export const capabilityAvailabilitySchema = refineCapabilityAvailability(capabilityAvailabilityBaseSchema);
+export const runnerCommandDescriptorSchema = z
+    .object({
+    id: z.string().min(1).max(128),
+    runner: runnerNameSchema,
+    label: z.string().min(1).max(128),
+    stateLabel: z.string().min(1).max(128).optional(),
+    description: z.string().max(500),
+    /** Commands are entered exactly as the Runner documents them: `/name args`. */
+    inputHint: z.string().max(200),
+    source: z.enum(['CODEX_APP_SERVER', 'CLAUDE_AGENT_SDK']),
+    interaction: z.enum(['RUNNER_TEXT', 'IMMEDIATE_ACTION', 'TOGGLE', 'VALUE']),
+    available: z.boolean(),
+    reasonCode: z.string().min(1).max(80).nullable()
+})
+    .superRefine((value, context) => {
+    if (value.available && value.reasonCode !== null) {
+        context.addIssue({ code: 'custom', message: 'available command cannot have reasonCode' });
+    }
+    if (!value.available && value.reasonCode === null) {
+        context.addIssue({ code: 'custom', message: 'unavailable command requires reasonCode' });
+    }
+});
+export const runnerCommandStateSchema = z.object({
+    commandId: z.string().min(1).max(128),
+    active: z.boolean(),
+    label: z.string().min(1).max(128),
+    detail: z.string().max(500).nullable(),
+    closable: z.boolean(),
+    closeInput: z.string().min(2).max(20_000).nullable(),
+    /** A Node-declared, fixed continuation for a completed structured result. */
+    continuation: z
+        .object({
+        label: z.string().min(1).max(128),
+        prompt: z.string().min(1).max(20_000)
+    })
+        .nullable()
+        .optional()
+});
+export const runnerProfileSchema = z.object({
+    runner: runnerNameSchema,
+    models: z.array(z.object({
+        id: z.string().min(1).max(128),
+        label: z.string().min(1).max(128),
+        supportedEfforts: z.array(z.string().min(1).max(64)).max(32)
+    })),
+    accessOptions: z.array(z.object({
+        id: z.string().min(1).max(128),
+        label: z.string().min(1).max(128),
+        description: z.string().max(500)
+    })),
+    commands: z.array(runnerCommandDescriptorSchema),
+    capabilities: z.array(z.string().min(1).max(80)).max(64)
+});
+/** The last explicitly chosen Composer configuration belongs to one Node Runner. */
+export const runnerDefaultConfigurationSchema = z.object({
+    runner: runnerNameSchema,
+    model: z.string().trim().min(1).max(128),
+    effort: z.string().trim().min(1).max(64),
+    access: z.string().trim().min(1).max(128)
+});
+/** A Runner command is selected from a Node-declared profile, never guessed from `/` text. */
+export const runnerCommandExecutionSchema = z.object({
+    commandId: z.string().min(1).max(128),
+    input: z.string().min(2).max(20_000)
+});
+export const serverWorkbenchCapabilitiesSchema = z.object({
+    workbenchProtocolVersion: z.literal(WORKBENCH_PROTOCOL_VERSION),
+    conversationItemVersions: z.array(z.literal(1)).min(1),
+    supportsWorkspaceActivityStream: z.boolean(),
+    supportsSessionDetailStream: z.boolean(),
+    supportsTerminalBrowserRelay: z.boolean(),
+    supportsTerminalNodeDataChannel: z.boolean(),
+    maxSseSubscriptionsPerUser: z.number().int().positive().max(128),
+    maxTerminalBrowserConnectionsPerUser: z.number().int().nonnegative().max(32)
+});
+export const nodeWorkbenchCapabilitiesSchema = z.object({
+    manifestVersion: z.literal(1),
+    revision: z.number().int().nonnegative(),
+    observedAt: z.number().int().nonnegative(),
+    platform: z.enum(['windows', 'linux']),
+    architecture: z.string().min(1).max(128),
+    conversation: capabilitySchemaWith({
+        itemVersions: z.array(z.literal(1)),
+        supportsSessionCursor: z.boolean(),
+        supportsWorkspaceActivityCursor: z.boolean(),
+        supportsHistoryPaging: z.boolean(),
+        supportsItemFinalSnapshots: z.boolean(),
+        maxPageSize: z.number().int().positive().max(500)
+    }),
+    runners: z.array(runnerProfileSchema),
+    files: capabilitySchemaWith({
+        supportsList: z.boolean(),
+        supportsReadRange: z.boolean(),
+        supportsSearch: z.boolean(),
+        maxDirectoryPageSize: z.number().int().positive().max(1000),
+        maxReadBytes: z.number().int().positive(),
+        maxSearchResults: z.number().int().positive().max(10000)
+    }),
+    git: capabilitySchemaWith({
+        supportsCurrentChanges: z.boolean(),
+        supportsTurnChanges: z.boolean(),
+        maxDiffBytes: z.number().int().positive()
+    }),
+    terminal: capabilitySchemaWith({
+        supportsPty: z.boolean(),
+        supportsConPty: z.boolean(),
+        supportsReplay: z.boolean(),
+        supportsReadonlyAttach: z.boolean(),
+        supportsTakeover: z.boolean(),
+        maxTerminals: z.number().int().nonnegative().max(64),
+        maxReplayBytes: z.number().int().nonnegative(),
+        reconnectWindowMs: z.number().int().nonnegative(),
+        profiles: z.array(z.object({
+            id: z.string().min(1).max(128),
+            label: z.string().min(1).max(128),
+            isDefault: z.boolean()
+        }))
+    })
+});
+export const sessionRuntimeCapabilitySchema = z.enum([
+    'history.read',
+    'events.live',
+    'turn.start',
+    'turn.queue',
+    'turn.interrupt',
+    'run.cancel',
+    'approval.respond',
+    'user-input.respond',
+    'session.rename',
+    'session.remove',
+    'session.pin'
+]);
+export const sessionRuntimeCapabilitiesSchema = z.object({
+    level: z.enum(['MANAGED', 'SHARED_CONTROL', 'OBSERVE_ONLY', 'RESUMABLE', 'UNAVAILABLE']),
+    capabilities: z.array(sessionRuntimeCapabilitySchema),
+    reasonCode: z.string().min(1).max(80).nullable()
+});
+export const sessionActivityStateSchema = z.enum([
+    'MANAGED_ACTIVE',
+    'EXTERNAL_ACTIVE',
+    'IDLE',
+    'UNAVAILABLE'
+]);
+export const eventCursorSchema = z.object({
+    scope: z.enum(['RUN', 'SESSION', 'WORKSPACE_ACTIVITY']),
+    streamId: z.string().min(1).max(128),
+    cursor: z.string().min(1).max(1024)
+});
+const conversationItemBaseSchema = z.object({
+    id: z.string().min(1).max(128),
+    sessionId: z.string().min(1).max(128),
+    turnId: z.string().min(1).max(128),
+    runId: z.string().min(1).max(128).nullable(),
+    parentItemId: z.string().min(1).max(128).nullable(),
+    sourceSequence: z.number().int().positive().nullable(),
+    revision: z.number().int().nonnegative(),
+    status: z.enum([
+        'PENDING',
+        'IN_PROGRESS',
+        'COMPLETED',
+        'FAILED',
+        'DECLINED',
+        'CANCELLED',
+        'INTERRUPTED'
+    ]),
+    startedAt: z.number().int().nonnegative().nullable(),
+    completedAt: z.number().int().nonnegative().nullable()
+});
+export const contextReferenceSchema = z.object({
+    type: z.enum(['file', 'directory', 'changes', 'diff', 'turn', 'message', 'terminal_selection']),
+    referenceId: z.string().min(1).max(128),
+    label: z.string().min(1).max(500),
+    path: z.string().min(1).max(4096).optional(),
+    startLine: z.number().int().positive().optional(),
+    endLine: z.number().int().positive().optional()
+});
+const assistantMessageItemSchema = conversationItemBaseSchema.extend({
+    kind: z.literal('assistant_message'),
+    payload: z.object({
+        text: z.string(),
+        format: z.literal('markdown'),
+        model: z.string().max(128).nullable()
+    })
+});
+const userMessageItemSchema = conversationItemBaseSchema.extend({
+    kind: z.literal('user_message'),
+    payload: z.object({
+        clientMessageId: z.string().min(1).max(128).nullable(),
+        text: z.string(),
+        contexts: z.array(contextReferenceSchema).max(64).default([]),
+        delivery: z.enum(['PENDING', 'ACCEPTED', 'STEERED', 'QUEUED_NEXT_TURN', 'REJECTED'])
+    })
+});
+const planItemSchema = conversationItemBaseSchema.extend({
+    kind: z.literal('plan'),
+    payload: z.object({
+        explanation: z.string().nullable(),
+        steps: z.array(z.object({
+            id: z.string().min(1).max(128),
+            text: z.string(),
+            status: z.enum(['PENDING', 'IN_PROGRESS', 'COMPLETED'])
+        }))
+    })
+});
+const approvalItemSchema = conversationItemBaseSchema.extend({
+    kind: z.literal('approval'),
+    payload: z.object({
+        approvalId: z.string().min(1).max(128),
+        category: z.enum(['COMMAND', 'FILE_CHANGE', 'NETWORK', 'TOOL', 'OTHER']),
+        reason: z.string().nullable(),
+        expiresAt: z.number().int().nonnegative(),
+        resolvedDecision: z.string().nullable()
+    })
+});
+const summaryItemSchema = conversationItemBaseSchema.extend({
+    kind: z.literal('turn_summary'),
+    payload: z.object({
+        status: agentRunStatusSchema,
+        durationMs: z.number().int().nonnegative().nullable()
+    })
+});
+const reasoningSummaryItemSchema = conversationItemBaseSchema.extend({
+    kind: z.literal('reasoning_summary'),
+    payload: z.object({
+        sections: z.array(z.object({ index: z.number().int().nonnegative(), text: z.string() }))
+    })
+});
+const toolCallItemSchema = conversationItemBaseSchema.extend({
+    kind: z.literal('tool_call'),
+    payload: z.object({
+        namespace: z.string().min(1).max(128),
+        toolName: z.string().min(1).max(128),
+        title: z.string().min(1).max(500),
+        inputSummary: z.string().max(10000).nullable(),
+        outputSummary: z.string().max(10000).nullable(),
+        progressLabel: z.string().max(500).nullable(),
+        errorCode: z.string().max(80).nullable(),
+        truncated: z.boolean()
+    })
+});
+const commandExecutionItemSchema = conversationItemBaseSchema.extend({
+    kind: z.literal('command_execution'),
+    payload: z.object({
+        command: z.string().max(10000),
+        cwd: z.string().max(4096).nullable(),
+        outputPreview: z.string().max(10000),
+        outputRef: z.string().min(1).max(128).nullable(),
+        exitCode: z.number().int().nullable(),
+        durationMs: z.number().int().nonnegative().nullable(),
+        truncated: z.boolean()
+    })
+});
+const fileChangeItemSchema = conversationItemBaseSchema.extend({
+    kind: z.literal('file_change'),
+    payload: z.object({
+        changes: z.array(z.object({
+            path: z.string().min(1).max(4096),
+            change: z.enum(['ADDED', 'MODIFIED', 'DELETED', 'RENAMED', 'COPIED', 'TYPE_CHANGED']),
+            additions: z.number().int().nonnegative().nullable(),
+            deletions: z.number().int().nonnegative().nullable(),
+            diffAvailable: z.boolean()
+        }))
+    })
+});
+const userInputRequestItemSchema = conversationItemBaseSchema.extend({
+    kind: z.literal('user_input_request'),
+    payload: z.object({
+        requestId: z.string().min(1).max(128),
+        questions: z.array(z.object({
+            id: z.string().min(1).max(128),
+            prompt: z.string().max(5000),
+            input: z.enum(['SINGLE_SELECT', 'MULTI_SELECT', 'SHORT_TEXT']),
+            options: z.array(z.object({
+                value: z.string().max(500),
+                label: z.string().max(500),
+                description: z.string().max(1000).nullable()
+            })),
+            allowOther: z.boolean()
+        }))
+    })
+});
+const contextCompactionItemSchema = conversationItemBaseSchema.extend({
+    kind: z.literal('context_compaction'),
+    payload: z.object({
+        phase: z.enum(['STARTED', 'COMPLETED']),
+        summary: z.string().max(10000).nullable()
+    })
+});
+const warningItemSchema = conversationItemBaseSchema.extend({
+    kind: z.literal('warning'),
+    payload: z.object({
+        code: z.string().min(1).max(80),
+        message: z.string().max(5000),
+        recoverable: z.boolean()
+    })
+});
+const errorItemSchema = conversationItemBaseSchema.extend({
+    kind: z.literal('error'),
+    payload: z.object({
+        code: z.string().min(1).max(80),
+        message: z.string().max(5000),
+        recoverable: z.boolean(),
+        retryAfterMs: z.number().int().nonnegative().nullable()
+    })
+});
+const unknownItemSchema = conversationItemBaseSchema.extend({
+    kind: z.literal('unknown'),
+    payload: z.object({ sourceEventType: z.string().min(1).max(128), label: z.string().max(500) })
+});
+export const conversationItemSchema = z.discriminatedUnion('kind', [
+    assistantMessageItemSchema,
+    userMessageItemSchema,
+    reasoningSummaryItemSchema,
+    planItemSchema,
+    toolCallItemSchema,
+    commandExecutionItemSchema,
+    fileChangeItemSchema,
+    approvalItemSchema,
+    userInputRequestItemSchema,
+    contextCompactionItemSchema,
+    warningItemSchema,
+    errorItemSchema,
+    summaryItemSchema,
+    unknownItemSchema
+]);
+export const conversationTurnSchema = z.object({
+    id: z.string().min(1).max(128),
+    sessionId: z.string().min(1).max(128),
+    runId: z.string().min(1).max(128).nullable(),
+    userItemId: z.string().min(1).max(128).nullable(),
+    status: z.enum([
+        'QUEUED',
+        'RUNNING',
+        'WAITING_INPUT',
+        'WAITING_APPROVAL',
+        'SUCCEEDED',
+        'FAILED',
+        'CANCELLED',
+        'INTERRUPTED',
+        'LOST'
+    ]),
+    model: z.string().max(128).nullable(),
+    effort: z.string().max(64).nullable(),
+    access: z.string().max(128).nullable(),
+    items: z.array(conversationItemSchema),
+    startedAt: z.number().int().nonnegative().nullable(),
+    completedAt: z.number().int().nonnegative().nullable()
+});
+export const conversationItemDeltaSchema = z.discriminatedUnion('kind', [
+    z.object({
+        kind: z.literal('assistant_text_append'),
+        itemId: z.string().min(1).max(128),
+        itemRevision: z.number().int().nonnegative(),
+        text: z.string()
+    }),
+    z.object({
+        kind: z.literal('plan_replace'),
+        itemId: z.string().min(1).max(128),
+        itemRevision: z.number().int().nonnegative(),
+        steps: z.array(z.object({
+            id: z.string(),
+            text: z.string(),
+            status: z.enum(['PENDING', 'IN_PROGRESS', 'COMPLETED'])
+        }))
+    }),
+    z.object({
+        kind: z.literal('tool_progress_replace'),
+        itemId: z.string().min(1).max(128),
+        itemRevision: z.number().int().nonnegative(),
+        label: z.string().max(500)
+    })
+]);
+export const terminalDataFrameSchema = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal('attach'),
+        terminalId: z.string().min(1).max(128),
+        afterSequence: z.number().int().nonnegative()
+    }),
+    z.object({
+        type: z.literal('resize'),
+        terminalId: z.string().min(1).max(128),
+        rows: z.number().int().positive().max(1000),
+        cols: z.number().int().positive().max(1000)
+    }),
+    z.object({
+        type: z.literal('input'),
+        terminalId: z.string().min(1).max(128),
+        data: z.string().max(65536)
+    }),
+    z.object({
+        type: z.literal('output'),
+        terminalId: z.string().min(1).max(128),
+        sequence: z.number().int().positive(),
+        data: z.string().max(65536)
+    }),
+    z.object({ type: z.literal('close'), terminalId: z.string().min(1).max(128) }),
+    z.object({
+        type: z.literal('exit'),
+        terminalId: z.string().min(1).max(128),
+        exitCode: z.number().int().nullable()
+    }),
+    z.object({
+        type: z.literal('error'),
+        terminalId: z.string().min(1).max(128),
+        code: z.string().min(1).max(80)
+    })
+]);
+export const terminalAttachTicketSchema = z
+    .object({
+    ticket: z.string().min(32).max(512),
+    nodeId: z.string().min(1).max(128),
+    terminalId: z.string().min(1).max(128),
+    userSessionFingerprint: z.string().min(1).max(128),
+    issuedAt: z.number().int().nonnegative(),
+    expiresAt: z.number().int().positive()
+})
+    .superRefine((value, context) => {
+    if (value.expiresAt <= value.issuedAt) {
+        context.addIssue({ code: 'custom', message: 'terminal ticket expiry must follow issuance' });
+    }
+});
+export const workspaceFileEntrySchema = z.object({
+    path: z.string().min(1).max(4096),
+    name: z.string().min(1).max(512),
+    kind: z.enum(['FILE', 'DIRECTORY']),
+    size: z.number().int().nonnegative().nullable(),
+    modifiedAt: z.number().int().nonnegative().nullable()
+});
+export const workspaceFileListSchema = z.object({
+    entries: z.array(workspaceFileEntrySchema),
+    nextCursor: z.string().min(1).max(1024).nullable(),
+    truncated: z.boolean()
+});
+export const workspaceFileReadSchema = z.object({
+    path: z.string().min(1).max(4096),
+    encoding: z.enum(['utf-8', 'base64']),
+    size: z.number().int().nonnegative(),
+    content: z.string(),
+    truncated: z.boolean(),
+    nextOffset: z.number().int().nonnegative().nullable()
+});
+export const workspaceUploadPreflightSchema = z.object({
+    name: z.string().min(1).max(512),
+    status: z.enum(['READY', 'EXISTS_FILE', 'EXISTS_DIRECTORY', 'INVALID_NAME']),
+    path: z.string().min(1).max(4096).nullable()
+});
+export const workspaceUploadSchema = z.object({
+    uploadId: z.string().uuid(),
+    path: z.string().min(1).max(4096),
+    receivedBytes: z.number().int().nonnegative(),
+    size: z.number().int().nonnegative()
+});
+export const workspaceChangeSchema = z.object({
+    path: z.string().min(1).max(4096),
+    state: z.enum(['STAGED', 'UNSTAGED', 'UNTRACKED']),
+    change: z.enum(['ADDED', 'MODIFIED', 'DELETED', 'RENAMED', 'COPIED', 'TYPE_CHANGED']),
+    additions: z.number().int().nonnegative().nullable(),
+    deletions: z.number().int().nonnegative().nullable(),
+    binary: z.boolean(),
+    diffAvailable: z.boolean()
+});
+export const workbenchNodeOperationSchema = z.enum([
+    'node.workbench.capabilities',
+    'runner.usage.status',
+    'runner.usage.read',
+    'workspace.directories.list',
+    'workspace.remove',
+    'session.metadata.update',
+    'session.remove',
+    'session.config.update',
+    'session.turns.list',
+    'session.events.read',
+    'session.context.read',
+    'session.command.execute',
+    'runner.command.execute',
+    'workspace.activity.read',
+    'runner.profiles.list',
+    'runner.defaults.save',
+    'workspace.files.list',
+    'workspace.file.read',
+    'workspace.files.search',
+    'workspace.files.upload.preflight',
+    'workspace.files.upload.create',
+    'workspace.files.upload.chunk',
+    'workspace.files.upload.status',
+    'workspace.files.upload.complete',
+    'workspace.files.upload.cancel',
+    'workspace.changes.current',
+    'workspace.change.diff',
+    'workspace.change.restore',
+    'run.image.read',
+    'terminal.open',
+    'terminal.list',
+    'terminal.close',
+    'terminal.attach.authorize'
+]);
+/**
+ * A small, explicit envelope keeps WebSocket messages independently parseable
+ * and makes it safe to reject future message kinds without guessing payloads.
+ */
+export const nodeEnvelopeSchema = z.object({
+    version: z.literal(NODE_PROTOCOL_VERSION),
+    id: z.string().min(1).max(128),
+    type: z.string().min(1).max(80),
+    replyTo: z.string().min(1).max(128).optional(),
+    payload: z.unknown()
+});
+export const nodeErrorSchema = z.object({
+    code: z.enum([
+        'PROTOCOL_VERSION_UNSUPPORTED',
+        'MESSAGE_TYPE_UNKNOWN',
+        'MESSAGE_INVALID',
+        'NODE_UNAUTHENTICATED',
+        'NODE_DISABLED',
+        'REGISTRATION_TOKEN_INVALID',
+        'WORKSPACE_INVALID',
+        'RUN_NOT_FOUND',
+        'RUN_STATE_INVALID',
+        'RUN_LOST',
+        'APPROVAL_NOT_FOUND',
+        'APPROVAL_EXPIRED',
+        'APPROVAL_ALREADY_DECIDED',
+        'APPROVAL_ALREADY_EXISTS',
+        'WORKBENCH_PROTOCOL_UNSUPPORTED',
+        'CAPABILITY_UNAVAILABLE',
+        'CAPABILITY_VERSION_UNSUPPORTED',
+        'CAPABILITY_STALE',
+        'EVENT_CURSOR_INVALID',
+        'EVENT_CURSOR_GAP',
+        'ITEM_REVISION_CONFLICT',
+        'RUNNER_PROFILE_INVALID',
+        'RUNNER_COMMAND_UNSUPPORTED',
+        'FILE_NOT_FOUND',
+        'FILE_NOT_REGULAR',
+        'FILE_TOO_LARGE',
+        'FILE_ENCODING_UNSUPPORTED',
+        'FILE_PATH_ESCAPE',
+        'DIRECTORY_CURSOR_INVALID',
+        'FILE_SEARCH_LIMIT_EXCEEDED',
+        'GIT_CHANGE_RESTORE_UNAVAILABLE',
+        'TERMINAL_UNAVAILABLE',
+        'TERMINAL_LIMIT_REACHED',
+        'TERMINAL_NOT_FOUND',
+        'TERMINAL_ATTACH_CONFLICT',
+        'TERMINAL_REPLAY_GAP',
+        'TERMINAL_DATA_CHANNEL_UNAVAILABLE',
+        'INTERNAL_ERROR'
+    ])
+});
+export function createEnvelope(type, payload, options = {}) {
+    return {
+        version: NODE_PROTOCOL_VERSION,
+        id: options.id ?? crypto.randomUUID(),
+        type,
+        ...(options.replyTo === undefined ? {} : { replyTo: options.replyTo }),
+        payload
+    };
+}
+//# sourceMappingURL=index.js.map