@kilocode/protocol 0.0.0-stage → 0.0.0-v2-9

package/dist/groups/integration.js

@@ -0,0 +1,169 @@
+import { Integration } from "@opencode/schema/integration";
+import { Location } from "@opencode/schema/location";
+import { Form } from "@opencode/schema/form";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+import { IntegrationAttemptNotFoundError, IntegrationMethodNotFoundError, IntegrationNotFoundError, InvalidRequestError, } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const IntegrationGroup = HttpApiGroup.make("server.integration")
+    .add(HttpApiEndpoint.get("integration.list", "/api/integration", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Integration.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "integration.list",
+    summary: "List integrations",
+    description: "Retrieve available integrations and their authentication methods.",
+})))
+    .add(HttpApiEndpoint.get("integration.get", "/api/integration/:integrationID", {
+    params: { integrationID: Integration.ID },
+    query: LocationQuery,
+    success: Location.response(Integration.Info),
+    error: IntegrationNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "integration.get",
+    summary: "Get integration",
+    description: "Retrieve one integration and its authentication methods.",
+})))
+    .add(HttpApiEndpoint.post("integration.wellknown.add", "/api/experimental/integration/wellknown", {
+    query: LocationQuery,
+    payload: Schema.Struct({ url: Schema.String }),
+    success: HttpApiSchema.NoContent,
+    error: InvalidRequestError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "experimental.integration.wellknown.add",
+    summary: "Add wellknown integration",
+    description: "Discover and persist an experimental wellknown integration source.",
+})))
+    .add(HttpApiEndpoint.post("integration.connect.key", "/api/integration/:integrationID/connect/key", {
+    params: { integrationID: Integration.ID },
+    query: LocationQuery,
+    payload: Schema.Struct({
+        key: Schema.String,
+        answer: Schema.optional(Form.Answer),
+        label: Schema.optional(Schema.String),
+    }),
+    success: HttpApiSchema.NoContent,
+    error: [IntegrationNotFoundError, InvalidRequestError],
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "integration.connect.key",
+    summary: "Connect with key",
+    description: "Run a key authentication method and store the resulting credential.",
+})))
+    .add(HttpApiEndpoint.post("integration.connect.external", "/api/integration/:integrationID/connect/external", {
+    params: { integrationID: Integration.ID },
+    query: LocationQuery,
+    payload: Schema.Struct({
+        methodID: Integration.MethodID,
+        answer: Schema.optional(Form.Answer),
+        label: Schema.optional(Schema.String),
+    }),
+    success: HttpApiSchema.NoContent,
+    error: [IntegrationNotFoundError, InvalidRequestError],
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "integration.connect.external",
+    summary: "Connect with external credentials",
+    description: "Run an external authentication method and store a reference to its credential source.",
+})))
+    .add(HttpApiEndpoint.post("integration.oauth.connect", "/api/integration/:integrationID/connect/oauth", {
+    params: { integrationID: Integration.ID },
+    query: LocationQuery,
+    payload: Schema.Struct({
+        methodID: Integration.MethodID,
+        answer: Schema.optional(Form.Answer),
+        label: Schema.optional(Schema.String),
+    }),
+    success: Location.response(Integration.Attempt),
+    error: InvalidRequestError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "integration.oauth.connect",
+    summary: "Begin OAuth connection",
+    description: "Start an OAuth attempt and return the authorization details.",
+})))
+    .add(HttpApiEndpoint.get("integration.oauth.status", "/api/integration/:integrationID/connect/oauth/:attemptID", {
+    params: { integrationID: Integration.ID, attemptID: Integration.AttemptID },
+    query: LocationQuery,
+    success: Location.response(Integration.AttemptStatus),
+    error: [IntegrationNotFoundError, IntegrationAttemptNotFoundError],
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "integration.oauth.status",
+    summary: "Get OAuth attempt status",
+    description: "Poll the current status of an OAuth attempt.",
+})))
+    .add(HttpApiEndpoint.post("integration.oauth.complete", "/api/integration/:integrationID/connect/oauth/:attemptID/complete", {
+    params: { integrationID: Integration.ID, attemptID: Integration.AttemptID },
+    query: LocationQuery,
+    payload: Schema.Struct({ code: Schema.optional(Schema.String) }),
+    success: HttpApiSchema.NoContent,
+    error: [IntegrationNotFoundError, IntegrationAttemptNotFoundError, InvalidRequestError],
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "integration.oauth.complete",
+    summary: "Complete OAuth connection",
+    description: "Complete a code-based OAuth attempt and store the resulting credential.",
+})))
+    .add(HttpApiEndpoint.delete("integration.oauth.cancel", "/api/integration/:integrationID/connect/oauth/:attemptID", {
+    params: { integrationID: Integration.ID, attemptID: Integration.AttemptID },
+    query: LocationQuery,
+    success: HttpApiSchema.NoContent,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "integration.oauth.cancel",
+    summary: "Cancel OAuth connection",
+    description: "Cancel an OAuth attempt and release its resources.",
+})))
+    .add(HttpApiEndpoint.post("integration.command.connect", "/api/integration/:integrationID/connect/command", {
+    params: { integrationID: Integration.ID },
+    query: LocationQuery,
+    payload: Schema.Struct({
+        methodID: Integration.MethodID,
+        label: Schema.optional(Schema.String),
+    }),
+    success: Location.response(Integration.CommandAttempt),
+    error: [IntegrationNotFoundError, IntegrationMethodNotFoundError, InvalidRequestError],
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "integration.command.connect",
+    summary: "Begin command connection",
+    description: "Start a command authentication attempt.",
+})))
+    .add(HttpApiEndpoint.get("integration.command.status", "/api/integration/:integrationID/connect/command/:attemptID", {
+    params: { integrationID: Integration.ID, attemptID: Integration.AttemptID },
+    query: LocationQuery,
+    success: Location.response(Integration.CommandAttemptStatus),
+    error: [IntegrationNotFoundError, IntegrationAttemptNotFoundError],
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "integration.command.status",
+    summary: "Get command attempt status",
+    description: "Poll the current status and output of a command authentication attempt.",
+})))
+    .add(HttpApiEndpoint.delete("integration.command.cancel", "/api/integration/:integrationID/connect/command/:attemptID", {
+    params: { integrationID: Integration.ID, attemptID: Integration.AttemptID },
+    query: LocationQuery,
+    success: HttpApiSchema.NoContent,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "integration.command.cancel",
+    summary: "Cancel command connection",
+    description: "Cancel a command authentication attempt and terminate its process.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "integration", description: "Integration discovery and authentication routes." }));

package/dist/groups/location.d.ts

@@ -0,0 +1,23 @@
+import { Context, Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/http-api";
+import { ServiceUnavailableError } from "../errors.js";
+export declare const LocationQuery: Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>;
+export declare const locationQueryOpenApi: Context.Context<never>;
+export declare const makeLocationGroup: <LocationId extends HttpApiMiddleware.AnyId, LocationService>(locationMiddleware: Context.Key<LocationId, LocationService>) => HttpApiGroup.HttpApiGroup<"server.location", HttpApiEndpoint.HttpApiEndpoint<"location.get", "GET", "/api/location", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly project: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Project.ID"> & {
+            global: string & import("effect/Brand").Brand<"Project.ID">;
+        };
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly canonical: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+}>>, never, LocationId, HttpApiMiddleware.Requires<LocationId>> | HttpApiEndpoint.HttpApiEndpoint<"location.reload", "POST", "/api/location/reload", never, never, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never>, false>;

package/dist/groups/location.js

@@ -0,0 +1,45 @@
+import { Location } from "@opencode/schema/location";
+import { Context, Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/http-api";
+import { ServiceUnavailableError } from "../errors.js";
+export const LocationQuery = Schema.Struct({
+    location: Schema.optional(Schema.Struct({
+        directory: Schema.optional(Schema.String),
+    })),
+}).annotate({ identifier: "LocationQuery" });
+export const locationQueryOpenApi = OpenApi.annotations({
+    transform: (operation) => {
+        const parameters = operation.parameters;
+        if (!Array.isArray(parameters))
+            return operation;
+        return {
+            ...operation,
+            parameters: parameters.map((parameter) => parameter?.name === "location" && parameter?.in === "query"
+                ? { ...parameter, style: "deepObject", explode: true }
+                : parameter),
+        };
+    },
+});
+// Middleware is applied per endpoint: reload acts on every loaded location and
+// must not boot the caller's location first.
+export const makeLocationGroup = (locationMiddleware) => HttpApiGroup.make("server.location")
+    .add(HttpApiEndpoint.get("location.get", "/api/location", {
+    query: LocationQuery,
+    success: Location.PublicInfo,
+})
+    .middleware(locationMiddleware)
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "location.get",
+    summary: "Get location",
+    description: "Resolve the requested location or the server default location.",
+})))
+    .add(HttpApiEndpoint.post("location.reload", "/api/location/reload", {
+    success: HttpApiSchema.NoContent,
+    error: ServiceUnavailableError,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "location.reload",
+    summary: "Reload configuration",
+    description: "Shut down and rebuild every loaded location. Pending permissions and forms are cancelled; running sessions continue with fresh services at the next step boundary. Emits location.shutdown for client recovery and responds once all replacement builds settle.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "location" }));

package/dist/groups/mcp.d.ts

@@ -0,0 +1,103 @@
+import { Mcp } from "@opencode/schema/mcp";
+import { Context, Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/http-api";
+import { ForbiddenError, LocationNotFoundError, McpServerNotFoundError } from "../errors.js";
+export declare const MCP_CLIENT_PATH = "/api/experimental/client-mcp";
+export declare function hasMcpClientTicketURL(url: URL): boolean;
+export declare const makeMcpGroup: <LocationId extends HttpApiMiddleware.AnyId, LocationService>(locationMiddleware: Context.Key<LocationId, LocationService>) => HttpApiGroup.HttpApiGroup<"server.mcp", HttpApiEndpoint.HttpApiEndpoint<"mcp.add", "PUT", "/api/experimental/mcp/:server", Schema.toCodecStringTree<Schema.Struct<{
+    server: Schema.String;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+    readonly config: Schema.toTaggedUnion<"type", readonly [typeof Mcp.LocalConfig, typeof Mcp.RemoteConfig]>;
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, LocationId, HttpApiMiddleware.Requires<LocationId>> | HttpApiEndpoint.HttpApiEndpoint<"mcp.list", "GET", "/api/mcp", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    readonly data: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly status: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
+            readonly status: Schema.Literal<"connected">;
+        }>, Schema.Struct<{
+            readonly status: Schema.Literal<"pending">;
+        }>, Schema.Struct<{
+            readonly status: Schema.Literal<"disabled">;
+        }>, Schema.Struct<{
+            readonly status: Schema.Literal<"failed">;
+            readonly error: Schema.String;
+        }>, Schema.Struct<{
+            readonly status: Schema.Literal<"needs_auth">;
+            readonly error: Schema.String;
+        }>]>;
+        readonly integrationID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Integration.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Integration.ID">>, never, never>;
+    }>>;
+}>>, never, LocationId, HttpApiMiddleware.Requires<LocationId>> | HttpApiEndpoint.HttpApiEndpoint<"mcp.resource.catalog", "GET", "/api/mcp/resource", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    readonly data: Schema.Struct<{
+        readonly resources: Schema.$Array<Schema.Struct<{
+            readonly server: Schema.String;
+            readonly name: Schema.String;
+            readonly uri: Schema.String;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>>;
+        readonly templates: Schema.$Array<Schema.Struct<{
+            readonly server: Schema.String;
+            readonly name: Schema.String;
+            readonly uriTemplate: Schema.String;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>>;
+    }>;
+}>>, never, LocationId, HttpApiMiddleware.Requires<LocationId>> | HttpApiEndpoint.HttpApiEndpoint<"mcp.connect", "POST", "/api/experimental/mcp/:server/connect", Schema.toCodecStringTree<Schema.Struct<{
+    server: Schema.String;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof McpServerNotFoundError>, LocationId, HttpApiMiddleware.Requires<LocationId>> | HttpApiEndpoint.HttpApiEndpoint<"mcp.disconnect", "POST", "/api/experimental/mcp/:server/disconnect", Schema.toCodecStringTree<Schema.Struct<{
+    server: Schema.String;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof McpServerNotFoundError>, LocationId, HttpApiMiddleware.Requires<LocationId>> | HttpApiEndpoint.HttpApiEndpoint<"mcp.remove", "DELETE", "/api/experimental/mcp/:server", Schema.toCodecStringTree<Schema.Struct<{
+    server: Schema.String;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof McpServerNotFoundError>, LocationId, HttpApiMiddleware.Requires<LocationId>> | HttpApiEndpoint.HttpApiEndpoint<"mcp.clientToken", "POST", "/api/experimental/client-mcp/token", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+    readonly name: Schema.String;
+}>>, never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly "x-opencode-ticket": Schema.optional<Schema.String>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    readonly data: Schema.Struct<{
+        readonly ticket: Schema.String;
+        readonly expires_in: Schema.Int;
+    }>;
+}>>, Schema.toCodecJson<typeof ForbiddenError>, LocationId, HttpApiMiddleware.Requires<LocationId>> | HttpApiEndpoint.HttpApiEndpoint<"mcp.client", "GET", "/api/experimental/client-mcp", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+    readonly name: Schema.String;
+    readonly ticket: Schema.optional<Schema.String>;
+}>>, never, never, Schema.toCodecJson<Schema.Boolean>, Schema.toCodecJson<typeof LocationNotFoundError | typeof ForbiddenError>, never, never>, false>;

package/dist/groups/mcp.js

@@ -0,0 +1,114 @@
+import { Mcp } from "@opencode/schema/mcp";
+import { Location } from "@opencode/schema/location";
+import { PtyTicket } from "@opencode/schema/pty-ticket";
+import { Context, Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/http-api";
+import { ForbiddenError, LocationNotFoundError, McpServerNotFoundError } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+import { PTY_CONNECT_TICKET_QUERY, PTY_CONNECT_TOKEN_HEADER } from "./pty.js";
+export const MCP_CLIENT_PATH = "/api/experimental/client-mcp";
+export function hasMcpClientTicketURL(url) {
+    return url.pathname === MCP_CLIENT_PATH && !!url.searchParams.get(PTY_CONNECT_TICKET_QUERY);
+}
+const McpClientQuery = Schema.Struct({
+    ...LocationQuery.fields,
+    name: Schema.String.check(Schema.isPattern(/^[a-zA-Z0-9_-]+$/)),
+});
+export const makeMcpGroup = (locationMiddleware) => HttpApiGroup.make("server.mcp")
+    .add(HttpApiEndpoint.get("mcp.list", "/api/mcp", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Mcp.Server)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "mcp.list",
+    summary: "List MCP servers",
+    description: "Retrieve configured MCP servers and their connection status.",
+})))
+    .add(HttpApiEndpoint.put("mcp.add", "/api/experimental/mcp/:server", {
+    params: { server: Schema.String },
+    query: LocationQuery,
+    // Wrapped in a struct because the client codegen flattens payload fields and cannot
+    // represent a top-level union payload.
+    payload: Schema.Struct({ config: Mcp.ServerConfig }),
+    success: HttpApiSchema.NoContent,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "experimental.mcp.add",
+    summary: "Add MCP server",
+    description: "Add an MCP server at runtime or replace an existing one, connecting it immediately.",
+})))
+    .add(HttpApiEndpoint.delete("mcp.remove", "/api/experimental/mcp/:server", {
+    params: { server: Schema.String },
+    query: LocationQuery,
+    success: HttpApiSchema.NoContent,
+    error: McpServerNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "experimental.mcp.remove",
+    summary: "Remove MCP server",
+    description: "Stop an MCP server and remove it from the runtime set until restart.",
+})))
+    .add(HttpApiEndpoint.post("mcp.connect", "/api/experimental/mcp/:server/connect", {
+    params: { server: Schema.String },
+    query: LocationQuery,
+    success: HttpApiSchema.NoContent,
+    error: McpServerNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "experimental.mcp.connect",
+    summary: "Connect MCP server",
+    description: "Connect an MCP server at runtime, overriding a disabled configuration until restart.",
+})))
+    .add(HttpApiEndpoint.post("mcp.disconnect", "/api/experimental/mcp/:server/disconnect", {
+    params: { server: Schema.String },
+    query: LocationQuery,
+    success: HttpApiSchema.NoContent,
+    error: McpServerNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "experimental.mcp.disconnect",
+    summary: "Disconnect MCP server",
+    description: "Disconnect an MCP server at runtime, removing its tools until reconnected.",
+})))
+    .add(HttpApiEndpoint.get("mcp.resource.catalog", "/api/mcp/resource", {
+    query: LocationQuery,
+    success: Location.response(Mcp.ResourceCatalog),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "mcp.resource.catalog",
+    summary: "List MCP resources",
+    description: "Retrieve resources and resource templates from connected MCP servers.",
+})))
+    .add(HttpApiEndpoint.post("mcp.clientToken", `${MCP_CLIENT_PATH}/token`, {
+    query: McpClientQuery,
+    headers: Schema.Struct({ [PTY_CONNECT_TOKEN_HEADER]: Schema.optional(Schema.String) }),
+    success: Location.response(PtyTicket.ConnectToken),
+    error: ForbiddenError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "experimental.mcp.client.token",
+    summary: "Create client MCP WebSocket token",
+    description: "Create a short-lived single-use ticket for opening a client MCP WebSocket connection from a browser.",
+})))
+    // The client handler checks origin and ticket before it boots the location itself.
+    .middleware(locationMiddleware)
+    .add(HttpApiEndpoint.get("mcp.client", MCP_CLIENT_PATH, {
+    query: Schema.Struct({ ...McpClientQuery.fields, [PTY_CONNECT_TICKET_QUERY]: Schema.optional(Schema.String) }),
+    success: Schema.Boolean,
+    error: [ForbiddenError, LocationNotFoundError],
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "experimental.mcp.client",
+    summary: "Attach client MCP server",
+    description: "Upgrade to a WebSocket over which the client hosts an MCP server named after `name`; its tools stay available while the socket is open. One JSON-RPC message per text frame. Experimental: may change without compatibility guarantees.",
+    transform: (operation) => ({ ...operation, "x-websocket": true }),
+})))
+    .annotateMerge(OpenApi.annotations({ title: "mcp", description: "MCP server and resource routes." }));