onlycode 1.18.0 → 1.20.0

package/src/server/routes/instance/httpapi/errors.ts

@@ -1,193 +0,0 @@
-import { Schema } from "effect"
-
-export class InvalidRequestError extends Schema.TaggedErrorClass<InvalidRequestError>()(
-  "InvalidRequestError",
-  {
-    message: Schema.String,
-    kind: Schema.optional(Schema.String),
-    field: Schema.optional(Schema.String),
-  },
-  { httpApiStatus: 400 },
-) {}
-
-export class UnauthorizedError extends Schema.TaggedErrorClass<UnauthorizedError>()(
-  "UnauthorizedError",
-  { message: Schema.String },
-  { httpApiStatus: 401 },
-) {}
-
-export class ForbiddenError extends Schema.TaggedErrorClass<ForbiddenError>()(
-  "ForbiddenError",
-  { message: Schema.String },
-  { httpApiStatus: 403 },
-) {}
-
-export class ConflictError extends Schema.TaggedErrorClass<ConflictError>()(
-  "ConflictError",
-  {
-    message: Schema.String,
-    resource: Schema.optional(Schema.String),
-  },
-  { httpApiStatus: 409 },
-) {}
-
-export class UpstreamError extends Schema.TaggedErrorClass<UpstreamError>()(
-  "UpstreamError",
-  {
-    message: Schema.String,
-    service: Schema.optional(Schema.String),
-    status: Schema.optional(Schema.Number),
-  },
-  { httpApiStatus: 502 },
-) {}
-
-export class ServiceUnavailableError extends Schema.TaggedErrorClass<ServiceUnavailableError>()(
-  "ServiceUnavailableError",
-  {
-    message: Schema.String,
-    service: Schema.optional(Schema.String),
-  },
-  { httpApiStatus: 503 },
-) {}
-
-export class TimeoutError extends Schema.TaggedErrorClass<TimeoutError>()(
-  "TimeoutError",
-  {
-    message: Schema.String,
-    operation: Schema.optional(Schema.String),
-  },
-  { httpApiStatus: 504 },
-) {}
-
-export class UnknownError extends Schema.TaggedErrorClass<UnknownError>()(
-  "UnknownError",
-  {
-    message: Schema.String,
-    ref: Schema.optional(Schema.String),
-  },
-  { httpApiStatus: 500 },
-) {}
-
-export class ProviderNotFoundError extends Schema.TaggedErrorClass<ProviderNotFoundError>()(
-  "ProviderNotFoundError",
-  {
-    providerID: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class ModelNotFoundError extends Schema.TaggedErrorClass<ModelNotFoundError>()(
-  "ModelNotFoundError",
-  {
-    providerID: Schema.String,
-    modelID: Schema.String,
-    suggestions: Schema.Array(Schema.String),
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class SessionNotFoundError extends Schema.TaggedErrorClass<SessionNotFoundError>()(
-  "SessionNotFoundError",
-  {
-    sessionID: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class MessageNotFoundError extends Schema.TaggedErrorClass<MessageNotFoundError>()(
-  "MessageNotFoundError",
-  {
-    sessionID: Schema.String,
-    messageID: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class InvalidCursorError extends Schema.TaggedErrorClass<InvalidCursorError>()(
-  "InvalidCursorError",
-  { message: Schema.String },
-  { httpApiStatus: 400 },
-) {}
-
-export class SessionBusyError extends Schema.TaggedErrorClass<SessionBusyError>()(
-  "SessionBusyError",
-  {
-    sessionID: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 409 },
-) {}
-
-export class QuestionNotFoundError extends Schema.TaggedErrorClass<QuestionNotFoundError>()(
-  "QuestionNotFoundError",
-  {
-    requestID: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class PermissionNotFoundError extends Schema.TaggedErrorClass<PermissionNotFoundError>()(
-  "PermissionNotFoundError",
-  {
-    requestID: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class McpServerNotFoundError extends Schema.TaggedErrorClass<McpServerNotFoundError>()(
-  "McpServerNotFoundError",
-  {
-    name: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class PtyNotFoundError extends Schema.TaggedErrorClass<PtyNotFoundError>()(
-  "PtyNotFoundError",
-  {
-    ptyID: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class PtyForbiddenError extends Schema.TaggedErrorClass<PtyForbiddenError>()(
-  "PtyForbiddenError",
-  {
-    message: Schema.String,
-  },
-  { httpApiStatus: 403 },
-) {}
-
-export class ProjectNotFoundError extends Schema.TaggedErrorClass<ProjectNotFoundError>()(
-  "ProjectNotFoundError",
-  {
-    projectID: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class ApiNotFoundError extends Schema.ErrorClass<ApiNotFoundError>("NotFoundError")(
-  {
-    name: Schema.Literal("NotFoundError"),
-    data: Schema.Struct({
-      message: Schema.String,
-    }),
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export function notFound(message: string) {
-  return new ApiNotFoundError({
-    name: "NotFoundError",
-    data: { message },
-  })
-}

package/src/server/routes/instance/httpapi/groups/config.ts

@@ -1,65 +0,0 @@
-import { Config } from "@/config/config"
-import { ConfigV1 } from "@opencode-ai/core/v1/config/config"
-import { Provider } from "@/provider/provider"
-import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { Authorization } from "../middleware/authorization"
-import { InstanceContextMiddleware } from "../middleware/instance-context"
-import { WorkspaceRoutingMiddleware, WorkspaceRoutingQuery } from "../middleware/workspace-routing"
-import { described } from "./metadata"
-
-const root = "/config"
-
-export const ConfigApi = HttpApi.make("config")
-  .add(
-    HttpApiGroup.make("config")
-      .add(
-        HttpApiEndpoint.get("get", root, {
-          query: WorkspaceRoutingQuery,
-          success: described(ConfigV1.Info, "Get config info"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "config.get",
-            summary: "Get configuration",
-            description: "Retrieve the current OnlyCode configuration settings and preferences.",
-          }),
-        ),
-        HttpApiEndpoint.patch("update", root, {
-          query: WorkspaceRoutingQuery,
-          payload: ConfigV1.Info,
-          success: described(ConfigV1.Info, "Successfully updated config"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "config.update",
-            summary: "Update configuration",
-            description: "Update OnlyCode configuration settings and preferences.",
-          }),
-        ),
-        HttpApiEndpoint.get("providers", `${root}/providers`, {
-          query: WorkspaceRoutingQuery,
-          success: described(Provider.ConfigProvidersResult, "List of providers"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "config.providers",
-            summary: "List config providers",
-            description: "Get a list of all configured AI providers and their default models.",
-          }),
-        ),
-      )
-      .annotateMerge(
-        OpenApi.annotations({
-          title: "config",
-          description: "Experimental HttpApi config routes.",
-        }),
-      )
-      .middleware(InstanceContextMiddleware)
-      .middleware(WorkspaceRoutingMiddleware)
-      .middleware(Authorization),
-  )
-  .annotateMerge(
-    OpenApi.annotations({
-      title: "opencode experimental HttpApi",
-      version: "0.0.1",
-      description: "Experimental HttpApi surface for selected instance routes.",
-    }),
-  )

package/src/server/routes/instance/httpapi/groups/control-plane.ts

@@ -1,35 +0,0 @@
-import { MoveSession } from "@opencode-ai/core/control-plane/move-session"
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { described } from "./metadata"
-
-const root = "/experimental/control-plane"
-export const MoveSessionPayload = Schema.Struct({ ...MoveSession.Input.fields })
-
-export class ApiMoveSessionError extends Schema.ErrorClass<ApiMoveSessionError>("MoveSessionError")(
-  {
-    name: Schema.Literal("MoveSessionError"),
-    data: Schema.Struct({
-      message: Schema.String,
-    }),
-  },
-  { httpApiStatus: 400 },
-) {}
-
-export const ControlPlaneApi = HttpApi.make("controlPlane").add(
-  HttpApiGroup.make("controlPlane")
-    .add(
-      HttpApiEndpoint.post("moveSession", `${root}/move-session`, {
-        payload: MoveSessionPayload,
-        success: described(HttpApiSchema.NoContent, "Session moved"),
-        error: ApiMoveSessionError,
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "experimental.controlPlane.moveSession",
-          summary: "Move session",
-          description: "Move a session to another project directory, optionally transferring local changes.",
-        }),
-      ),
-    )
-    .annotateMerge(OpenApi.annotations({ title: "controlPlane", description: "Control-plane orchestration routes." })),
-)

package/src/server/routes/instance/httpapi/groups/control.ts

@@ -1,76 +0,0 @@
-import { Auth } from "@/auth"
-
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { described } from "./metadata"
-import { ProviderV2 } from "@opencode-ai/core/provider"
-
-const AuthParams = Schema.Struct({
-  providerID: ProviderV2.ID,
-})
-
-const LogQuery = Schema.Struct({
-  directory: Schema.optional(Schema.String),
-  workspace: Schema.optional(Schema.String),
-})
-
-export const LogInput = Schema.Struct({
-  service: Schema.String.annotate({ description: "Service name for the log entry" }),
-  level: Schema.Union([
-    Schema.Literal("debug"),
-    Schema.Literal("info"),
-    Schema.Literal("error"),
-    Schema.Literal("warn"),
-  ]).annotate({ description: "Log level" }),
-  message: Schema.String.annotate({ description: "Log message" }),
-  extra: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)).annotate({
-    description: "Additional metadata for the log entry",
-  }),
-})
-
-export const ControlPaths = {
-  auth: "/auth/:providerID",
-  log: "/log",
-} as const
-
-export const ControlApi = HttpApi.make("control").add(
-  HttpApiGroup.make("control")
-    .add(
-      HttpApiEndpoint.put("authSet", ControlPaths.auth, {
-        params: AuthParams,
-        payload: Auth.Info,
-        success: described(Schema.Boolean, "Successfully set authentication credentials"),
-        error: HttpApiError.BadRequest,
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "auth.set",
-          summary: "Set auth credentials",
-          description: "Set authentication credentials",
-        }),
-      ),
-      HttpApiEndpoint.delete("authRemove", ControlPaths.auth, {
-        params: AuthParams,
-        success: described(Schema.Boolean, "Successfully removed authentication credentials"),
-        error: HttpApiError.BadRequest,
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "auth.remove",
-          summary: "Remove auth credentials",
-          description: "Remove authentication credentials",
-        }),
-      ),
-      HttpApiEndpoint.post("log", ControlPaths.log, {
-        query: LogQuery,
-        payload: LogInput,
-        success: described(Schema.Boolean, "Log entry written successfully"),
-        error: HttpApiError.BadRequest,
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "app.log",
-          summary: "Write log",
-          description: "Write a log entry to the server logs with specified level and metadata.",
-        }),
-      ),
-    )
-    .annotateMerge(OpenApi.annotations({ title: "control", description: "Control plane routes." })),
-)

package/src/server/routes/instance/httpapi/groups/event.ts

@@ -1,29 +0,0 @@
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { Authorization } from "../middleware/authorization"
-import { InstanceContextMiddleware } from "../middleware/instance-context"
-import { WorkspaceRoutingMiddleware, WorkspaceRoutingQuery } from "../middleware/workspace-routing"
-
-export const EventPaths = {
-  event: "/event",
-} as const
-
-export const EventApi = HttpApi.make("event").add(
-  HttpApiGroup.make("event")
-    .add(
-      HttpApiEndpoint.get("subscribe", EventPaths.event, {
-        query: WorkspaceRoutingQuery,
-        success: Schema.String.pipe(HttpApiSchema.asText({ contentType: "text/event-stream" })),
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "event.subscribe",
-          summary: "Subscribe to events",
-          description: "Get events",
-        }),
-      ),
-    )
-    .middleware(InstanceContextMiddleware)
-    .middleware(WorkspaceRoutingMiddleware)
-    .middleware(Authorization)
-    .annotateMerge(OpenApi.annotations({ title: "event", description: "Instance event stream route." })),
-)

package/src/server/routes/instance/httpapi/groups/experimental.ts

@@ -1,275 +0,0 @@
-import { AccountID, OrgID } from "@/account/schema"
-import { MCP } from "@/mcp"
-
-import { Session } from "@/session/session"
-import { SessionID } from "@/session/schema"
-import { Worktree } from "@/worktree"
-import { NonNegativeInt } from "@opencode-ai/core/schema"
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { Authorization } from "../middleware/authorization"
-import { InstanceContextMiddleware } from "../middleware/instance-context"
-import {
-  WorkspaceRoutingMiddleware,
-  WorkspaceRoutingQuery,
-  WorkspaceRoutingQueryFields,
-} from "../middleware/workspace-routing"
-import { described } from "./metadata"
-import { QueryBoolean } from "./query"
-import { ProviderV2 } from "@opencode-ai/core/provider"
-import { ModelV2 } from "@opencode-ai/core/model"
-
-const ConsoleStateResponse = Schema.Struct({
-  consoleManagedProviders: Schema.mutable(Schema.Array(Schema.String)),
-  activeOrgName: Schema.optionalKey(Schema.String),
-  switchableOrgCount: NonNegativeInt,
-}).annotate({ identifier: "ConsoleState" })
-
-const CapabilitiesResponse = Schema.Struct({
-  backgroundSubagents: Schema.Boolean,
-}).annotate({ identifier: "ExperimentalCapabilities" })
-
-const ConsoleOrgOption = Schema.Struct({
-  accountID: Schema.String,
-  accountEmail: Schema.String,
-  accountUrl: Schema.String,
-  orgID: Schema.String,
-  orgName: Schema.String,
-  active: Schema.Boolean,
-})
-
-const ConsoleOrgList = Schema.Struct({
-  orgs: Schema.Array(ConsoleOrgOption),
-})
-
-export const ConsoleSwitchPayload = Schema.Struct({
-  accountID: AccountID,
-  orgID: OrgID,
-})
-
-const ToolIDs = Schema.Array(Schema.String).annotate({ identifier: "ToolIDs" })
-const ToolListItem = Schema.Struct({
-  id: Schema.String,
-  description: Schema.String,
-  parameters: Schema.Unknown,
-}).annotate({ identifier: "ToolListItem" })
-const ToolList = Schema.Array(ToolListItem).annotate({ identifier: "ToolList" })
-export const ToolListQuery = Schema.Struct({
-  ...WorkspaceRoutingQueryFields,
-  provider: ProviderV2.ID,
-  model: ModelV2.ID,
-})
-
-const WorktreeList = Schema.Array(Schema.String)
-const WorktreeErrorName = Schema.Union([
-  Schema.Literal("WorktreeNotGitError"),
-  Schema.Literal("WorktreeNameGenerationFailedError"),
-  Schema.Literal("WorktreeCreateFailedError"),
-  Schema.Literal("WorktreeStartCommandFailedError"),
-  Schema.Literal("WorktreeRemoveFailedError"),
-  Schema.Literal("WorktreeResetFailedError"),
-  Schema.Literal("WorktreeListFailedError"),
-])
-export class WorktreeApiError extends Schema.ErrorClass<WorktreeApiError>("WorktreeError")(
-  {
-    name: WorktreeErrorName,
-    data: Schema.Struct({ message: Schema.String }),
-  },
-  { httpApiStatus: 400 },
-) {}
-export const SessionListQuery = Schema.Struct({
-  ...WorkspaceRoutingQueryFields,
-  roots: Schema.optional(QueryBoolean),
-  start: Schema.optional(Schema.NumberFromString),
-  cursor: Schema.optional(Schema.NumberFromString),
-  search: Schema.optional(Schema.String),
-  limit: Schema.optional(Schema.NumberFromString),
-  archived: Schema.optional(QueryBoolean),
-})
-
-export const ExperimentalPaths = {
-  capabilities: "/experimental/capabilities",
-  console: "/experimental/console",
-  consoleOrgs: "/experimental/console/orgs",
-  consoleSwitch: "/experimental/console/switch",
-  tool: "/experimental/tool",
-  toolIDs: "/experimental/tool/ids",
-  worktree: "/experimental/worktree",
-  worktreeReset: "/experimental/worktree/reset",
-  session: "/experimental/session",
-  sessionBackground: "/experimental/session/:sessionID/background",
-  resource: "/experimental/resource",
-} as const
-
-export const ExperimentalApi = HttpApi.make("experimental")
-  .add(
-    HttpApiGroup.make("experimental")
-      .add(
-        HttpApiEndpoint.get("capabilities", ExperimentalPaths.capabilities, {
-          query: WorkspaceRoutingQuery,
-          success: described(CapabilitiesResponse, "Experimental capabilities"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.capabilities.get",
-            summary: "Get experimental capabilities",
-            description: "Get experimental features enabled on the OnlyCode server.",
-          }),
-        ),
-        HttpApiEndpoint.get("console", ExperimentalPaths.console, {
-          query: WorkspaceRoutingQuery,
-          success: described(ConsoleStateResponse, "Active Console provider metadata"),
-          error: HttpApiError.InternalServerError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.console.get",
-            summary: "Get active Console provider metadata",
-            description: "Get the active Console org name and the set of provider IDs managed by that Console org.",
-          }),
-        ),
-        HttpApiEndpoint.get("consoleOrgs", ExperimentalPaths.consoleOrgs, {
-          query: WorkspaceRoutingQuery,
-          success: described(ConsoleOrgList, "Switchable Console orgs"),
-          error: HttpApiError.InternalServerError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.console.listOrgs",
-            summary: "List switchable Console orgs",
-            description: "Get the available Console orgs across logged-in accounts, including the current active org.",
-          }),
-        ),
-        HttpApiEndpoint.post("consoleSwitch", ExperimentalPaths.consoleSwitch, {
-          query: WorkspaceRoutingQuery,
-          payload: ConsoleSwitchPayload,
-          success: described(Schema.Boolean, "Switch success"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.console.switchOrg",
-            summary: "Switch active Console org",
-            description: "Persist a new active Console account/org selection for the current local OnlyCode state.",
-          }),
-        ),
-        HttpApiEndpoint.get("tool", ExperimentalPaths.tool, {
-          query: ToolListQuery,
-          success: described(ToolList, "Tools"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "tool.list",
-            summary: "List tools",
-            description:
-              "Get a list of available tools with their JSON schema parameters for a specific provider and model combination.",
-          }),
-        ),
-        HttpApiEndpoint.get("toolIDs", ExperimentalPaths.toolIDs, {
-          query: WorkspaceRoutingQuery,
-          success: described(ToolIDs, "Tool IDs"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "tool.ids",
-            summary: "List tool IDs",
-            description:
-              "Get a list of all available tool IDs, including both built-in tools and dynamically registered tools.",
-          }),
-        ),
-        HttpApiEndpoint.get("worktree", ExperimentalPaths.worktree, {
-          query: WorkspaceRoutingQuery,
-          success: described(WorktreeList, "List of worktree directories"),
-          error: WorktreeApiError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "worktree.list",
-            summary: "List worktrees",
-            description: "List all sandbox worktrees for the current project.",
-          }),
-        ),
-        HttpApiEndpoint.post("worktreeCreate", ExperimentalPaths.worktree, {
-          disableCodecs: true,
-          query: WorkspaceRoutingQuery,
-          payload: [HttpApiSchema.NoContent, Worktree.CreateInput],
-          success: described(Worktree.Info, "Worktree created"),
-          error: WorktreeApiError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "worktree.create",
-            summary: "Create worktree",
-            description: "Create a new git worktree for the current project and run any configured startup scripts.",
-          }),
-        ),
-        HttpApiEndpoint.delete("worktreeRemove", ExperimentalPaths.worktree, {
-          query: WorkspaceRoutingQuery,
-          payload: Worktree.RemoveInput,
-          success: described(Schema.Boolean, "Worktree removed"),
-          error: WorktreeApiError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "worktree.remove",
-            summary: "Remove worktree",
-            description: "Remove a git worktree and delete its branch.",
-          }),
-        ),
-        HttpApiEndpoint.post("worktreeReset", ExperimentalPaths.worktreeReset, {
-          query: WorkspaceRoutingQuery,
-          payload: Worktree.ResetInput,
-          success: described(Schema.Boolean, "Worktree reset"),
-          error: WorktreeApiError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "worktree.reset",
-            summary: "Reset worktree",
-            description: "Reset a worktree branch to the primary default branch.",
-          }),
-        ),
-        HttpApiEndpoint.get("session", ExperimentalPaths.session, {
-          query: SessionListQuery,
-          success: described(Schema.Array(Session.GlobalInfo), "List of sessions"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.session.list",
-            summary: "List sessions",
-            description:
-              "Get a list of all OnlyCode sessions across projects, sorted by most recently updated. Archived sessions are excluded by default.",
-          }),
-        ),
-        HttpApiEndpoint.post("sessionBackground", ExperimentalPaths.sessionBackground, {
-          params: { sessionID: SessionID },
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Boolean, "Backgrounded subagents"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.session.background",
-            summary: "Background subagents",
-            description:
-              "Detach any synchronous subagents currently blocking the session and continue them in the background.",
-          }),
-        ),
-        HttpApiEndpoint.get("resource", ExperimentalPaths.resource, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Record(Schema.String, MCP.Resource), "MCP resources"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.resource.list",
-            summary: "Get MCP resources",
-            description: "Get all available MCP resources from connected servers. Optionally filter by name.",
-          }),
-        ),
-      )
-      .annotateMerge(
-        OpenApi.annotations({
-          title: "experimental",
-          description: "Experimental HttpApi read-only routes.",
-        }),
-      )
-      .middleware(InstanceContextMiddleware)
-      .middleware(WorkspaceRoutingMiddleware)
-      .middleware(Authorization),
-  )
-  .annotateMerge(
-    OpenApi.annotations({
-      title: "opencode experimental HttpApi",
-      version: "0.0.1",
-      description: "Experimental HttpApi surface for selected instance routes.",
-    }),
-  )