@greppleai/grip 0.0.0-stage → 0.0.1

package/dist/core/remote-workspace-protocol/contract.js

@@ -0,0 +1,809 @@
+import { createHash } from "node:crypto";
+import { Type } from "typebox";
+import { Compile } from "typebox/compile";
+export const REMOTE_WORKSPACE_PROTOCOL_VERSIONS = [{ major: 1, minMinor: 0, maxMinor: 0 }];
+export const REMOTE_WORKSPACE_CAPABILITIES = [
+    "catalog_refresh",
+    "tool_updates",
+    "primitive_operations",
+    "lsp_status",
+    "file_transfer",
+    "artifacts",
+];
+export const REMOTE_WORKSPACE_METHODS = [
+    "catalog.get",
+    "tool.invoke",
+    "workspace.access",
+    "workspace.read",
+    "workspace.write",
+    "workspace.mkdir",
+    "workspace.stat",
+    "workspace.readdir",
+    "workspace.glob",
+    "workspace.grep",
+    "workspace.detect_image_mime",
+    "workspace.exec",
+    "lsp.status",
+    "resource.read",
+    "artifact.read",
+    "transfer.upload",
+    "transfer.download",
+];
+export const REMOTE_WORKSPACE_ERROR_CODES = [
+    "invalid_request",
+    "method_not_supported",
+    "incompatible_version",
+    "capability_mismatch",
+    "schema_mismatch",
+    "stale_generation",
+    "not_available",
+    "limit_exceeded",
+    "deadline_exceeded",
+    "cancelled",
+    "generation_retired",
+    "connection_draining",
+    "result_too_large",
+    "internal_error",
+];
+export const DEFAULT_REMOTE_WORKSPACE_PROTOCOL_LIMITS = {
+    maxMessageBytes: 2 * 1024 * 1024,
+    maxStringBytes: 1536 * 1024,
+    maxDepth: 32,
+    maxObjectKeys: 4096,
+    maxArrayLength: 4096,
+    maxNodes: 16_384,
+    maxRequestMs: 10 * 60 * 1000,
+    maxTransferChunkBytes: 64 * 1024,
+    maxPendingTransferBytes: 256 * 1024,
+    maxPendingInboundBytes: 4 * 1024 * 1024,
+    maxPendingInboundMessages: 64,
+    maxPendingOutboundBytes: 4 * 1024 * 1024,
+    maxPendingOutboundMessages: 128,
+    maxTransferBytes: 100 * 1024 * 1024,
+    maxTransferChunks: 16_384,
+    maxActiveRequests: 64,
+    maxActiveTransfers: 8,
+    maxCancellationMs: 100,
+    maxTransportSendMs: 10_000,
+};
+const closedObject = { additionalProperties: false };
+const safeIntegerOptions = { minimum: 0, maximum: Number.MAX_SAFE_INTEGER };
+const RequestIdSchema = Type.String({ minLength: 1, maxLength: 128, pattern: "^[A-Za-z0-9._:-]+$" });
+const HashSchema = Type.String({ pattern: "^[0-9a-f]{64}$" });
+const CapabilitySchema = Type.String({ minLength: 1, maxLength: 128, pattern: "^[a-z][a-z0-9_.-]*$" });
+const RemoteWorkspaceMethodSchema = Type.Union([
+    Type.Literal("catalog.get"),
+    Type.Literal("tool.invoke"),
+    Type.Literal("workspace.access"),
+    Type.Literal("workspace.read"),
+    Type.Literal("workspace.write"),
+    Type.Literal("workspace.mkdir"),
+    Type.Literal("workspace.stat"),
+    Type.Literal("workspace.readdir"),
+    Type.Literal("workspace.glob"),
+    Type.Literal("workspace.grep"),
+    Type.Literal("workspace.detect_image_mime"),
+    Type.Literal("workspace.exec"),
+    Type.Literal("lsp.status"),
+    Type.Literal("resource.read"),
+    Type.Literal("artifact.read"),
+    Type.Literal("transfer.upload"),
+    Type.Literal("transfer.download"),
+]);
+export const RemoteWorkspaceVersionRangeSchema = Type.Object({
+    major: Type.Integer({ minimum: 1, maximum: 65535 }),
+    minMinor: Type.Integer({ minimum: 0, maximum: 65535 }),
+    maxMinor: Type.Integer({ minimum: 0, maximum: 65535 }),
+}, closedObject);
+export const RemoteWorkspaceVersionSchema = Type.Object({
+    major: Type.Integer({ minimum: 1, maximum: 65535 }),
+    minor: Type.Integer({ minimum: 0, maximum: 65535 }),
+}, closedObject);
+export const RemoteWorkspaceLimitsSchema = Type.Object({
+    maxMessageBytes: Type.Integer({ minimum: 1024, maximum: 64 * 1024 * 1024 }),
+    maxStringBytes: Type.Integer({ minimum: 1, maximum: 64 * 1024 * 1024 }),
+    maxDepth: Type.Integer({ minimum: 1, maximum: 256 }),
+    maxObjectKeys: Type.Integer({ minimum: 1, maximum: 1_000_000 }),
+    maxArrayLength: Type.Integer({ minimum: 1, maximum: 1_000_000 }),
+    maxNodes: Type.Integer({ minimum: 1, maximum: 2_000_000 }),
+    maxRequestMs: Type.Integer({ minimum: 1, maximum: 24 * 60 * 60 * 1000 }),
+    maxTransferChunkBytes: Type.Integer({ minimum: 1024, maximum: 1024 * 1024 }),
+    maxPendingTransferBytes: Type.Integer({ minimum: 1024, maximum: 16 * 1024 * 1024 }),
+    maxPendingInboundBytes: Type.Integer({ minimum: 1024, maximum: 64 * 1024 * 1024 }),
+    maxPendingInboundMessages: Type.Integer({ minimum: 1, maximum: 100_000 }),
+    maxPendingOutboundBytes: Type.Integer({ minimum: 1024, maximum: 64 * 1024 * 1024 }),
+    maxPendingOutboundMessages: Type.Integer({ minimum: 1, maximum: 100_000 }),
+    maxTransferBytes: Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }),
+    maxTransferChunks: Type.Integer({ minimum: 1, maximum: 1_000_000 }),
+    maxActiveRequests: Type.Integer({ minimum: 1, maximum: 10_000_000 }),
+    maxActiveTransfers: Type.Integer({ minimum: 1, maximum: 10_000 }),
+    maxCancellationMs: Type.Integer({ minimum: 1, maximum: 60_000 }),
+    maxTransportSendMs: Type.Integer({ minimum: 1, maximum: 5 * 60_000 }),
+}, closedObject);
+export const RemoteWorkspaceIdentitySchema = Type.Object({
+    id: Type.String({ minLength: 16, maxLength: 128, pattern: "^[A-Za-z0-9_-]+$" }),
+    root: Type.String({ minLength: 1, maxLength: 32_768 }),
+    pathFlavor: Type.Union([Type.Literal("posix"), Type.Literal("windows")]),
+}, closedObject);
+export const RemoteWorkspaceToolCatalogEntrySchema = Type.Object({
+    name: Type.String({ minLength: 1, maxLength: 128, pattern: "^[A-Za-z][A-Za-z0-9_.-]*$" }),
+    executionMode: Type.Union([
+        Type.Literal("read"),
+        Type.Literal("mutation"),
+        Type.Literal("process"),
+        Type.Literal("service"),
+    ]),
+    parameterSchema: Type.Record(Type.String({ maxLength: 256 }), Type.Unknown()),
+    schemaHash: HashSchema,
+    featureFlags: Type.Array(CapabilitySchema, { maxItems: 256 }),
+}, closedObject);
+export const RemoteWorkspaceCatalogSchema = Type.Object({
+    generation: Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }),
+    tools: Type.Array(RemoteWorkspaceToolCatalogEntrySchema, { maxItems: 1024 }),
+    operations: Type.Array(RemoteWorkspaceMethodSchema, { maxItems: 256 }),
+}, closedObject);
+export const RemoteWorkspaceHandshakeSchema = Type.Object({
+    type: Type.Literal("handshake"),
+    id: RequestIdSchema,
+    versions: Type.Array(RemoteWorkspaceVersionRangeSchema, { minItems: 1, maxItems: 16 }),
+    requiredCapabilities: Type.Array(CapabilitySchema, { maxItems: 256 }),
+    optionalCapabilities: Type.Array(CapabilitySchema, { maxItems: 256 }),
+    receiveLimits: RemoteWorkspaceLimitsSchema,
+}, closedObject);
+export const RemoteWorkspaceHandshakeAckSchema = Type.Object({
+    type: Type.Literal("handshake_ack"),
+    id: RequestIdSchema,
+    version: RemoteWorkspaceVersionSchema,
+    capabilities: Type.Array(CapabilitySchema, { maxItems: 256 }),
+    workspace: RemoteWorkspaceIdentitySchema,
+    limits: RemoteWorkspaceLimitsSchema,
+    catalog: RemoteWorkspaceCatalogSchema,
+    catalogHash: HashSchema,
+    backendMetadata: Type.Object({
+        kind: Type.Literal("remote-workspace"),
+        label: Type.Optional(Type.String({ minLength: 1, maxLength: 256 })),
+    }, closedObject),
+}, closedObject);
+export const RemoteWorkspaceRequestSchema = Type.Object({
+    type: Type.Literal("request"),
+    id: RequestIdSchema,
+    method: Type.String({ minLength: 1, maxLength: 128 }),
+    timeoutMs: Type.Integer({ minimum: 1, maximum: 24 * 60 * 60 * 1000 }),
+    params: Type.Unknown(),
+}, closedObject);
+export const RemoteWorkspaceCancelSchema = Type.Object({
+    type: Type.Literal("cancel"),
+    id: RequestIdSchema,
+    reason: Type.Optional(Type.String({ maxLength: 256 })),
+}, closedObject);
+export const RemoteWorkspaceTransferChunkSchema = Type.Object({
+    type: Type.Literal("transfer_chunk"),
+    id: RequestIdSchema,
+    sequence: Type.Integer(safeIntegerOptions),
+    dataBase64: Type.String({ minLength: 4 }),
+}, closedObject);
+export const RemoteWorkspaceTransferFinishSchema = Type.Object({
+    type: Type.Literal("transfer_finish"),
+    id: RequestIdSchema,
+    length: Type.Integer(safeIntegerOptions),
+    sha256: HashSchema,
+}, closedObject);
+export const RemoteWorkspaceResultSchema = Type.Object({
+    type: Type.Literal("result"),
+    id: RequestIdSchema,
+    result: Type.Unknown(),
+}, closedObject);
+export const RemoteWorkspaceProtocolErrorSchema = Type.Object({
+    code: Type.Union([
+        Type.Literal("invalid_request"),
+        Type.Literal("method_not_supported"),
+        Type.Literal("incompatible_version"),
+        Type.Literal("capability_mismatch"),
+        Type.Literal("schema_mismatch"),
+        Type.Literal("stale_generation"),
+        Type.Literal("not_available"),
+        Type.Literal("limit_exceeded"),
+        Type.Literal("deadline_exceeded"),
+        Type.Literal("cancelled"),
+        Type.Literal("generation_retired"),
+        Type.Literal("connection_draining"),
+        Type.Literal("result_too_large"),
+        Type.Literal("internal_error"),
+    ]),
+    message: Type.String({ minLength: 1, maxLength: 4096 }),
+    executionState: Type.Union([
+        Type.Literal("not_started"),
+        Type.Literal("completed"),
+        Type.Literal("indeterminate"),
+    ]),
+    retryable: Type.Boolean(),
+    details: Type.Optional(Type.Unknown()),
+}, closedObject);
+export const RemoteWorkspaceErrorMessageSchema = Type.Object({
+    type: Type.Literal("error"),
+    id: RequestIdSchema,
+    error: RemoteWorkspaceProtocolErrorSchema,
+}, closedObject);
+export const RemoteWorkspaceUpdateSchema = Type.Object({
+    type: Type.Literal("update"),
+    id: RequestIdSchema,
+    sequence: Type.Integer(safeIntegerOptions),
+    update: Type.Unknown(),
+}, closedObject);
+export const RemoteWorkspaceTransferStartSchema = Type.Object({
+    type: Type.Literal("transfer_start"),
+    id: RequestIdSchema,
+    length: Type.Integer(safeIntegerOptions),
+    sha256: HashSchema,
+}, closedObject);
+export const RemoteWorkspaceCatalogChangedSchema = Type.Object({
+    type: Type.Literal("catalog_changed"),
+    generation: Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }),
+    catalogHash: HashSchema,
+}, closedObject);
+export const RemoteWorkspaceClientMessageSchema = Type.Union([
+    RemoteWorkspaceHandshakeSchema,
+    RemoteWorkspaceRequestSchema,
+    RemoteWorkspaceCancelSchema,
+    RemoteWorkspaceTransferChunkSchema,
+    RemoteWorkspaceTransferFinishSchema,
+]);
+export const RemoteWorkspaceServerMessageSchema = Type.Union([
+    RemoteWorkspaceHandshakeAckSchema,
+    RemoteWorkspaceResultSchema,
+    RemoteWorkspaceErrorMessageSchema,
+    RemoteWorkspaceUpdateSchema,
+    RemoteWorkspaceTransferStartSchema,
+    RemoteWorkspaceTransferChunkSchema,
+    RemoteWorkspaceCatalogChangedSchema,
+]);
+const EmptyParamsSchema = Type.Object({}, closedObject);
+const PathParamsSchema = Type.Object({ path: Type.String({ minLength: 1, maxLength: 32_768 }) }, closedObject);
+const CatalogGetParamsSchema = EmptyParamsSchema;
+const SessionEnvironmentSchema = Type.Object({
+    GRIP_SESSION_ID: Type.Optional(Type.String({ maxLength: 32_768 })),
+    GRIP_SESSION_FILE: Type.Optional(Type.String({ maxLength: 32_768 })),
+    GRIP_PROVIDER: Type.Optional(Type.String({ maxLength: 32_768 })),
+    GRIP_MODEL: Type.Optional(Type.String({ maxLength: 32_768 })),
+    GRIP_REASONING_LEVEL: Type.Optional(Type.String({ maxLength: 32_768 })),
+}, closedObject);
+const ToolInvokeParamsSchema = Type.Object({
+    generation: Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }),
+    catalogHash: HashSchema,
+    toolName: Type.String({ minLength: 1, maxLength: 128 }),
+    schemaHash: HashSchema,
+    argumentsPrepared: Type.Literal(true),
+    arguments: Type.Unknown(),
+    executionOptions: Type.Object({
+        imageAutoResize: Type.Optional(Type.Boolean()),
+        shellCommandPrefix: Type.Optional(Type.String({ maxLength: 32_768 })),
+        sessionEnvironment: Type.Optional(SessionEnvironmentSchema),
+    }, closedObject),
+}, closedObject);
+const AccessParamsSchema = Type.Object({
+    path: Type.String({ minLength: 1, maxLength: 32_768 }),
+    mode: Type.Optional(Type.Union([Type.Literal("exists"), Type.Literal("read"), Type.Literal("write"), Type.Literal("readwrite")])),
+}, closedObject);
+const WriteParamsSchema = Type.Object({
+    path: Type.String({ minLength: 1, maxLength: 32_768 }),
+    contentBase64: Type.String(),
+}, closedObject);
+const MkdirParamsSchema = Type.Object({
+    path: Type.String({ minLength: 1, maxLength: 32_768 }),
+    recursive: Type.Boolean(),
+}, closedObject);
+const GlobParamsSchema = Type.Object({
+    pattern: Type.String({ minLength: 1, maxLength: 32_768 }),
+    cwd: Type.String({ minLength: 1, maxLength: 32_768 }),
+    ignore: Type.Array(Type.String({ maxLength: 32_768 }), { maxItems: 4096 }),
+    limit: Type.Integer({ minimum: 1, maximum: 1_000_000 }),
+}, closedObject);
+const GrepParamsSchema = Type.Object({
+    pattern: Type.String({ maxLength: 1024 * 1024 }),
+    path: Type.String({ minLength: 1, maxLength: 32_768 }),
+    glob: Type.Optional(Type.String({ maxLength: 32_768 })),
+    ignoreCase: Type.Optional(Type.Boolean()),
+    literal: Type.Optional(Type.Boolean()),
+    limit: Type.Integer({ minimum: 1, maximum: 1_000_000 }),
+}, closedObject);
+const ExecParamsSchema = Type.Object({
+    command: Type.String({ minLength: 1 }),
+    cwd: Type.String({ minLength: 1, maxLength: 32_768 }),
+}, closedObject);
+const TransferUploadParamsSchema = Type.Object({
+    path: Type.String({ minLength: 1, maxLength: 32_768 }),
+    length: Type.Integer(safeIntegerOptions),
+    sha256: HashSchema,
+    overwrite: Type.Boolean(),
+}, closedObject);
+const TransferDownloadParamsSchema = Type.Object({
+    path: Type.String({ minLength: 1, maxLength: 32_768 }),
+}, closedObject);
+const ToolContentSchema = Type.Union([
+    Type.Object({ type: Type.Literal("text"), text: Type.String() }, closedObject),
+    Type.Object({
+        type: Type.Literal("image"),
+        data: Type.String(),
+        mimeType: Type.String({ minLength: 1, maxLength: 256 }),
+    }, closedObject),
+]);
+const ToolResultSchema = Type.Object({
+    content: Type.Array(ToolContentSchema),
+    details: Type.Optional(Type.Unknown()),
+    terminate: Type.Optional(Type.Boolean()),
+}, closedObject);
+const EmptyResultSchema = EmptyParamsSchema;
+const LspStatusServerSchema = Type.Object({
+    serverId: Type.String({ minLength: 1, maxLength: 256 }),
+    languageIds: Type.Array(Type.String({ maxLength: 256 }), { maxItems: 256 }),
+    transport: Type.String({ minLength: 1, maxLength: 128 }),
+    instanceKey: Type.Optional(Type.String({ maxLength: 4096 })),
+    workspaceRoot: Type.Optional(Type.String({ maxLength: 32_768 })),
+    endpoint: Type.Optional(Type.String({ maxLength: 4096 })),
+    rootUri: Type.Optional(Type.String({ maxLength: 32_768 })),
+    ownership: Type.Union([Type.Literal("managed"), Type.Literal("attached")]),
+    shutdownMode: Type.Union([Type.Literal("protocol"), Type.Literal("disconnect")]),
+    state: Type.Union([
+        Type.Literal("idle"),
+        Type.Literal("connecting"),
+        Type.Literal("initializing"),
+        Type.Literal("running"),
+        Type.Literal("closed"),
+        Type.Literal("failed"),
+        Type.Literal("disposed"),
+    ]),
+    reconnectEligible: Type.Boolean(),
+    running: Type.Boolean(),
+    starting: Type.Boolean(),
+    diagnosticsCount: Type.Integer(safeIntegerOptions),
+    lastError: Type.Optional(Type.String()),
+    lastRequestError: Type.Optional(Type.String()),
+    stderr: Type.Optional(Type.String()),
+    synchronizationError: Type.Optional(Type.String()),
+}, closedObject);
+const LspStatusResultSchema = Type.Object({ enabled: Type.Boolean(), servers: Type.Array(LspStatusServerSchema, { maxItems: 1024 }) }, closedObject);
+const ReadResultSchema = Type.Object({
+    contentBase64: Type.String(),
+    workspace: RemoteWorkspaceIdentitySchema,
+}, closedObject);
+const StatResultSchema = Type.Object({
+    kind: Type.Union([Type.Literal("file"), Type.Literal("directory"), Type.Literal("other")]),
+    workspace: RemoteWorkspaceIdentitySchema,
+}, closedObject);
+const ReaddirResultSchema = Type.Object({
+    entries: Type.Array(Type.String({ maxLength: 32_768 }), { maxItems: 1_000_000 }),
+    workspace: RemoteWorkspaceIdentitySchema,
+}, closedObject);
+const GlobResultSchema = Type.Object({
+    matches: Type.Array(Type.String({ maxLength: 32_768 }), { maxItems: 1_000_000 }),
+    workspace: RemoteWorkspaceIdentitySchema,
+}, closedObject);
+const GrepResultSchema = Type.Object({
+    isDirectory: Type.Boolean(),
+    matches: Type.Array(Type.Object({
+        filePath: Type.String({ minLength: 1, maxLength: 32_768 }),
+        lineNumber: Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }),
+        lineText: Type.Optional(Type.String()),
+    }, closedObject), { maxItems: 1_000_000 }),
+    workspace: RemoteWorkspaceIdentitySchema,
+}, closedObject);
+const MimeResultSchema = Type.Object({
+    mimeType: Type.Union([
+        Type.Literal("image/jpeg"),
+        Type.Literal("image/png"),
+        Type.Literal("image/gif"),
+        Type.Literal("image/webp"),
+        Type.Null(),
+    ]),
+    workspace: RemoteWorkspaceIdentitySchema,
+}, closedObject);
+const ExecResultSchema = Type.Object({ exitCode: Type.Union([Type.Integer({ minimum: 0, maximum: 255 }), Type.Null()]) }, closedObject);
+const TransferResultSchema = Type.Object({
+    length: Type.Integer(safeIntegerOptions),
+    sha256: HashSchema,
+}, closedObject);
+const parameterValidators = {
+    "catalog.get": Compile(CatalogGetParamsSchema),
+    "tool.invoke": Compile(ToolInvokeParamsSchema),
+    "workspace.access": Compile(AccessParamsSchema),
+    "workspace.read": Compile(PathParamsSchema),
+    "workspace.write": Compile(WriteParamsSchema),
+    "workspace.mkdir": Compile(MkdirParamsSchema),
+    "workspace.stat": Compile(PathParamsSchema),
+    "workspace.readdir": Compile(PathParamsSchema),
+    "workspace.glob": Compile(GlobParamsSchema),
+    "workspace.grep": Compile(GrepParamsSchema),
+    "workspace.detect_image_mime": Compile(PathParamsSchema),
+    "workspace.exec": Compile(ExecParamsSchema),
+    "lsp.status": Compile(EmptyParamsSchema),
+    "resource.read": Compile(PathParamsSchema),
+    "artifact.read": Compile(PathParamsSchema),
+    "transfer.upload": Compile(TransferUploadParamsSchema),
+    "transfer.download": Compile(TransferDownloadParamsSchema),
+};
+const resultValidators = {
+    "catalog.get": Compile(RemoteWorkspaceCatalogSchema),
+    "tool.invoke": Compile(ToolResultSchema),
+    "workspace.access": Compile(EmptyResultSchema),
+    "workspace.read": Compile(ReadResultSchema),
+    "workspace.write": Compile(EmptyResultSchema),
+    "workspace.mkdir": Compile(EmptyResultSchema),
+    "workspace.stat": Compile(StatResultSchema),
+    "workspace.readdir": Compile(ReaddirResultSchema),
+    "workspace.glob": Compile(GlobResultSchema),
+    "workspace.grep": Compile(GrepResultSchema),
+    "workspace.detect_image_mime": Compile(MimeResultSchema),
+    "workspace.exec": Compile(ExecResultSchema),
+    "lsp.status": Compile(LspStatusResultSchema),
+    "resource.read": Compile(ReadResultSchema),
+    "artifact.read": Compile(TransferResultSchema),
+    "transfer.upload": Compile(TransferResultSchema),
+    "transfer.download": Compile(TransferResultSchema),
+};
+const clientMessageValidator = Compile(RemoteWorkspaceClientMessageSchema);
+const serverMessageValidator = Compile(RemoteWorkspaceServerMessageSchema);
+const handshakeAckValidator = Compile(RemoteWorkspaceHandshakeAckSchema);
+const limitsValidator = Compile(RemoteWorkspaceLimitsSchema);
+export class RemoteWorkspaceValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RemoteWorkspaceValidationError";
+    }
+}
+function validationMessage(validator, value) {
+    const error = validator.Errors(value)[0];
+    if (!error)
+        return "value does not match the protocol schema";
+    return `${error.instancePath || "/"}: ${error.message}`;
+}
+function parseWithValidator(validator, value, label) {
+    if (!validator.Check(value)) {
+        throw new RemoteWorkspaceValidationError(`Invalid ${label}: ${validationMessage(validator, value)}`);
+    }
+    return value;
+}
+export function validateRemoteWorkspaceProtocolLimits(value) {
+    const limits = parseWithValidator(limitsValidator, value, "protocol limits");
+    if (limits.maxMessageBytes > limits.maxPendingInboundBytes) {
+        throw new RemoteWorkspaceValidationError("maxMessageBytes must not exceed maxPendingInboundBytes");
+    }
+    if (limits.maxMessageBytes > limits.maxPendingOutboundBytes) {
+        throw new RemoteWorkspaceValidationError("maxMessageBytes must not exceed maxPendingOutboundBytes");
+    }
+    if (limits.maxTransferChunkBytes > limits.maxPendingTransferBytes) {
+        throw new RemoteWorkspaceValidationError("maxTransferChunkBytes must not exceed maxPendingTransferBytes");
+    }
+    if (Math.ceil((limits.maxTransferChunkBytes * 4) / 3) + 512 > limits.maxMessageBytes) {
+        throw new RemoteWorkspaceValidationError("maxTransferChunkBytes must fit in one base64 protocol message");
+    }
+    return limits;
+}
+function validateRemoteWorkspaceNodeBudget(depth, state) {
+    state.nodes++;
+    if (state.nodes > state.limits.maxNodes)
+        throw new RemoteWorkspaceValidationError("Protocol value exceeds node limit");
+    if (depth > state.limits.maxDepth)
+        throw new RemoteWorkspaceValidationError("Protocol value exceeds depth limit");
+}
+function validateRemoteWorkspaceScalar(value, limits) {
+    if (value === null || typeof value === "boolean")
+        return true;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new RemoteWorkspaceValidationError("Protocol numbers must be finite");
+        return true;
+    }
+    if (typeof value !== "string")
+        return false;
+    if (Buffer.byteLength(value, "utf8") > limits.maxStringBytes) {
+        throw new RemoteWorkspaceValidationError("Protocol string exceeds byte limit");
+    }
+    return true;
+}
+function enqueueRemoteWorkspaceArray(value, depth, state) {
+    if (value.length > state.limits.maxArrayLength) {
+        throw new RemoteWorkspaceValidationError("Protocol array exceeds item limit");
+    }
+    for (let index = value.length - 1; index >= 0; index--) {
+        state.pending.push({ value: value[index], depth: depth + 1 });
+    }
+}
+function enqueueRemoteWorkspaceObject(value, depth, state) {
+    if (value === null || typeof value !== "object")
+        throw new RemoteWorkspaceValidationError("Protocol values must be JSON-compatible");
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new RemoteWorkspaceValidationError("Protocol objects must be plain JSON objects");
+    }
+    const entries = Object.entries(value);
+    if (entries.length > state.limits.maxObjectKeys) {
+        throw new RemoteWorkspaceValidationError("Protocol object exceeds key limit");
+    }
+    state.objectKeys += entries.length;
+    if (state.objectKeys > state.limits.maxObjectKeys) {
+        throw new RemoteWorkspaceValidationError("Protocol value exceeds total key limit");
+    }
+    for (let index = entries.length - 1; index >= 0; index--) {
+        const entry = entries[index];
+        if (!entry)
+            continue;
+        if (Buffer.byteLength(entry[0], "utf8") > state.limits.maxStringBytes) {
+            throw new RemoteWorkspaceValidationError("Protocol object key exceeds byte limit");
+        }
+        state.pending.push({ value: entry[1], depth: depth + 1 });
+    }
+}
+export function assertRemoteWorkspaceJsonStructure(value, limits = DEFAULT_REMOTE_WORKSPACE_PROTOCOL_LIMITS) {
+    const state = {
+        pending: [{ value, depth: 1 }],
+        nodes: 0,
+        objectKeys: 0,
+        limits,
+    };
+    while (state.pending.length > 0) {
+        const current = state.pending.pop();
+        if (!current)
+            break;
+        validateRemoteWorkspaceNodeBudget(current.depth, state);
+        if (validateRemoteWorkspaceScalar(current.value, limits))
+            continue;
+        if (Array.isArray(current.value)) {
+            enqueueRemoteWorkspaceArray(current.value, current.depth, state);
+            continue;
+        }
+        enqueueRemoteWorkspaceObject(current.value, current.depth, state);
+    }
+}
+export function decodeRemoteWorkspaceMessage(payload, limits = DEFAULT_REMOTE_WORKSPACE_PROTOCOL_LIMITS) {
+    const bytes = typeof payload === "string" ? Buffer.from(payload, "utf8") : payload;
+    if (bytes.byteLength > limits.maxMessageBytes) {
+        throw new RemoteWorkspaceValidationError("Protocol message exceeds byte limit");
+    }
+    const text = typeof payload === "string" ? payload : new TextDecoder("utf-8", { fatal: true }).decode(payload);
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch (error) {
+        throw new RemoteWorkspaceValidationError(`Protocol message is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    assertRemoteWorkspaceJsonStructure(value, limits);
+    return value;
+}
+export function parseRemoteWorkspaceClientMessage(value, limits = DEFAULT_REMOTE_WORKSPACE_PROTOCOL_LIMITS) {
+    assertRemoteWorkspaceJsonStructure(value, limits);
+    return parseWithValidator(clientMessageValidator, value, "client message");
+}
+export function parseRemoteWorkspaceServerMessage(value, limits = DEFAULT_REMOTE_WORKSPACE_PROTOCOL_LIMITS) {
+    assertRemoteWorkspaceJsonStructure(value, limits);
+    return parseWithValidator(serverMessageValidator, value, "server message");
+}
+export function isRemoteWorkspaceMethod(method) {
+    return REMOTE_WORKSPACE_METHODS.includes(method);
+}
+export function parseRemoteWorkspaceRequestParams(method, value, limits = DEFAULT_REMOTE_WORKSPACE_PROTOCOL_LIMITS) {
+    assertRemoteWorkspaceJsonStructure(value, limits);
+    const parsed = parseWithValidator(parameterValidators[method], value, `${method} params`);
+    if (method === "workspace.write") {
+        decodeCanonicalBase64(parsed.contentBase64, limits.maxMessageBytes);
+    }
+    return parsed;
+}
+export function parseRemoteWorkspaceResult(method, value, limits = DEFAULT_REMOTE_WORKSPACE_PROTOCOL_LIMITS) {
+    assertRemoteWorkspaceJsonStructure(value, limits);
+    const validator = resultValidators[method];
+    const parsed = validator ? parseWithValidator(validator, value, `${method} result`) : value;
+    if (method === "workspace.read" || method === "resource.read") {
+        decodeCanonicalBase64(parsed.contentBase64, limits.maxMessageBytes);
+    }
+    return parsed;
+}
+export function parseRemoteWorkspaceToolResult(value, limits = DEFAULT_REMOTE_WORKSPACE_PROTOCOL_LIMITS) {
+    assertRemoteWorkspaceJsonStructure(value, limits);
+    return parseWithValidator(Compile(ToolResultSchema), value, "tool result");
+}
+export function decodeCanonicalBase64(value, maxBytes) {
+    if (value.length % 4 !== 0 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)) {
+        throw new RemoteWorkspaceValidationError("Transfer data is not canonical base64");
+    }
+    const decoded = Buffer.from(value, "base64");
+    if (decoded.byteLength > maxBytes)
+        throw new RemoteWorkspaceValidationError("Transfer chunk exceeds byte limit");
+    if (decoded.toString("base64") !== value) {
+        throw new RemoteWorkspaceValidationError("Transfer data is not canonical base64");
+    }
+    return decoded;
+}
+function canonicalJson(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new RemoteWorkspaceValidationError("Cannot hash a non-finite number");
+        return JSON.stringify(value);
+    }
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map((entry) => canonicalJson(entry)).join(",")}]`;
+    if (typeof value !== "object" || value === undefined) {
+        throw new RemoteWorkspaceValidationError("Cannot hash a non-JSON value");
+    }
+    const entries = Object.entries(value).sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0));
+    return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`).join(",")}}`;
+}
+export function hashRemoteWorkspaceJson(value) {
+    assertRemoteWorkspaceJsonStructure(value);
+    return createHash("sha256").update(canonicalJson(value)).digest("hex");
+}
+export function hashRemoteWorkspaceCatalog(catalog) {
+    return hashRemoteWorkspaceJson(catalog);
+}
+function assertUnique(values, label) {
+    if (new Set(values).size !== values.length)
+        throw new RemoteWorkspaceValidationError(`${label} contains duplicates`);
+}
+export function validateRemoteWorkspaceCatalog(catalog) {
+    parseWithValidator(Compile(RemoteWorkspaceCatalogSchema), catalog, "tool catalog");
+    assertUnique(catalog.operations, "Catalog operations");
+    assertUnique(catalog.tools.map((tool) => tool.name), "Catalog tool names");
+    for (const tool of catalog.tools) {
+        assertUnique(tool.featureFlags, `Feature flags for ${tool.name}`);
+        if (hashRemoteWorkspaceJson(tool.parameterSchema) !== tool.schemaHash) {
+            throw new RemoteWorkspaceValidationError(`Schema hash mismatch for tool ${tool.name}`);
+        }
+    }
+}
+export function validateRemoteWorkspaceLocalToolSchemas(catalog, localToolSchemas) {
+    for (const tool of catalog.tools) {
+        const localHash = localToolSchemas.get(tool.name);
+        if (localHash !== undefined && localHash !== tool.schemaHash) {
+            throw new RemoteWorkspaceValidationError(`Remote schema does not match the local canonical schema for ${tool.name}`);
+        }
+    }
+}
+export function validateRemoteWorkspaceHandshakeAck(ack, offer, localToolSchemas = new Map()) {
+    const parsed = parseWithValidator(handshakeAckValidator, ack, "handshake response");
+    validateRemoteWorkspaceProtocolLimits(offer.receiveLimits);
+    validateRemoteWorkspaceProtocolLimits(parsed.limits);
+    const selected = offer.versions.some((range) => range.major === parsed.version.major &&
+        range.minMinor <= parsed.version.minor &&
+        range.maxMinor >= parsed.version.minor);
+    if (!selected)
+        throw new RemoteWorkspaceValidationError("Server selected a protocol version outside the offered range");
+    const offeredCapabilities = new Set([...offer.requiredCapabilities, ...offer.optionalCapabilities]);
+    for (const capability of parsed.capabilities) {
+        if (!offeredCapabilities.has(capability)) {
+            throw new RemoteWorkspaceValidationError(`Server selected an unoffered capability: ${capability}`);
+        }
+    }
+    const selectedCapabilities = new Set(parsed.capabilities);
+    for (const capability of offer.requiredCapabilities) {
+        if (!selectedCapabilities.has(capability)) {
+            throw new RemoteWorkspaceValidationError(`Server omitted required capability: ${capability}`);
+        }
+    }
+    assertUnique(parsed.capabilities, "Negotiated capabilities");
+    validateRemoteWorkspaceCatalog(parsed.catalog);
+    if (hashRemoteWorkspaceCatalog(parsed.catalog) !== parsed.catalogHash) {
+        throw new RemoteWorkspaceValidationError("Catalog hash does not match the negotiated catalog");
+    }
+    validateRemoteWorkspaceLocalToolSchemas(parsed.catalog, localToolSchemas);
+    for (const key of Object.keys(offer.receiveLimits)) {
+        if (parsed.limits[key] > offer.receiveLimits[key]) {
+            throw new RemoteWorkspaceValidationError(`Server increased negotiated limit: ${key}`);
+        }
+    }
+    return parsed;
+}
+export class RemoteWorkspaceNegotiationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "RemoteWorkspaceNegotiationError";
+        this.code = code;
+    }
+}
+function validateVersionRanges(ranges, label) {
+    for (const range of ranges) {
+        if (range.minMinor > range.maxMinor) {
+            throw new RemoteWorkspaceNegotiationError("incompatible_version", `${label} has an inverted minor range`);
+        }
+    }
+}
+function findCompatibleRemoteWorkspaceVersions(clientVersions, serverVersions) {
+    const serverVersionsByMajor = new Map();
+    for (const server of serverVersions) {
+        const ranges = serverVersionsByMajor.get(server.major) ?? [];
+        ranges.push(server);
+        serverVersionsByMajor.set(server.major, ranges);
+    }
+    const candidates = [];
+    for (const client of clientVersions) {
+        for (const server of serverVersionsByMajor.get(client.major) ?? []) {
+            const minMinor = Math.max(client.minMinor, server.minMinor);
+            const maxMinor = Math.min(client.maxMinor, server.maxMinor);
+            if (minMinor <= maxMinor)
+                candidates.push({ major: client.major, minor: maxMinor });
+        }
+    }
+    return candidates;
+}
+export function negotiateRemoteWorkspaceHandshake(handshake, options) {
+    validateRemoteWorkspaceProtocolLimits(handshake.receiveLimits);
+    validateRemoteWorkspaceProtocolLimits(options.serverLimits);
+    validateVersionRanges(handshake.versions, "Client version offer");
+    validateVersionRanges(options.serverVersions, "Server version offer");
+    assertUnique(handshake.requiredCapabilities, "Required capabilities");
+    assertUnique(handshake.optionalCapabilities, "Optional capabilities");
+    const optionalCapabilities = new Set(handshake.optionalCapabilities);
+    const duplicateOffer = handshake.requiredCapabilities.find((capability) => optionalCapabilities.has(capability));
+    if (duplicateOffer) {
+        throw new RemoteWorkspaceNegotiationError("capability_mismatch", `Capability is both required and optional: ${duplicateOffer}`);
+    }
+    const candidates = findCompatibleRemoteWorkspaceVersions(handshake.versions, options.serverVersions);
+    candidates.sort((left, right) => right.major - left.major || right.minor - left.minor);
+    const version = candidates[0];
+    if (!version) {
+        throw new RemoteWorkspaceNegotiationError("incompatible_version", "No compatible remote workspace protocol version");
+    }
+    const serverCapabilities = new Set(options.serverCapabilities);
+    for (const capability of handshake.requiredCapabilities) {
+        if (!serverCapabilities.has(capability)) {
+            throw new RemoteWorkspaceNegotiationError("capability_mismatch", `Server does not support required capability: ${capability}`);
+        }
+    }
+    const clientCapabilities = new Set([...handshake.requiredCapabilities, ...handshake.optionalCapabilities]);
+    for (const capability of options.requiredClientCapabilities ?? []) {
+        if (!clientCapabilities.has(capability)) {
+            throw new RemoteWorkspaceNegotiationError("capability_mismatch", `Client does not support required capability: ${capability}`);
+        }
+    }
+    const capabilities = Array.from(clientCapabilities)
+        .filter((capability) => serverCapabilities.has(capability))
+        .sort();
+    const clientLimits = handshake.receiveLimits;
+    const serverLimits = options.serverLimits;
+    return {
+        version,
+        capabilities,
+        limits: {
+            maxMessageBytes: Math.min(clientLimits.maxMessageBytes, serverLimits.maxMessageBytes),
+            maxStringBytes: Math.min(clientLimits.maxStringBytes, serverLimits.maxStringBytes),
+            maxDepth: Math.min(clientLimits.maxDepth, serverLimits.maxDepth),
+            maxObjectKeys: Math.min(clientLimits.maxObjectKeys, serverLimits.maxObjectKeys),
+            maxArrayLength: Math.min(clientLimits.maxArrayLength, serverLimits.maxArrayLength),
+            maxNodes: Math.min(clientLimits.maxNodes, serverLimits.maxNodes),
+            maxRequestMs: Math.min(clientLimits.maxRequestMs, serverLimits.maxRequestMs),
+            maxTransferChunkBytes: Math.min(clientLimits.maxTransferChunkBytes, serverLimits.maxTransferChunkBytes),
+            maxPendingTransferBytes: Math.min(clientLimits.maxPendingTransferBytes, serverLimits.maxPendingTransferBytes),
+            maxPendingInboundBytes: Math.min(clientLimits.maxPendingInboundBytes, serverLimits.maxPendingInboundBytes),
+            maxPendingInboundMessages: Math.min(clientLimits.maxPendingInboundMessages, serverLimits.maxPendingInboundMessages),
+            maxPendingOutboundBytes: Math.min(clientLimits.maxPendingOutboundBytes, serverLimits.maxPendingOutboundBytes),
+            maxPendingOutboundMessages: Math.min(clientLimits.maxPendingOutboundMessages, serverLimits.maxPendingOutboundMessages),
+            maxTransferBytes: Math.min(clientLimits.maxTransferBytes, serverLimits.maxTransferBytes),
+            maxTransferChunks: Math.min(clientLimits.maxTransferChunks, serverLimits.maxTransferChunks),
+            maxActiveRequests: Math.min(clientLimits.maxActiveRequests, serverLimits.maxActiveRequests),
+            maxActiveTransfers: Math.min(clientLimits.maxActiveTransfers, serverLimits.maxActiveTransfers),
+            maxCancellationMs: Math.min(clientLimits.maxCancellationMs, serverLimits.maxCancellationMs),
+            maxTransportSendMs: Math.min(clientLimits.maxTransportSendMs, serverLimits.maxTransportSendMs),
+        },
+    };
+}
+export function getRemoteWorkspaceMethodKind(method) {
+    switch (method) {
+        case "workspace.write":
+        case "workspace.mkdir":
+        case "transfer.upload":
+            return "mutation";
+        case "workspace.exec":
+            return "process";
+        case "tool.invoke":
+            return "service";
+        default:
+            return "read";
+    }
+}
+//# sourceMappingURL=contract.js.map