@opencode-ai/protocol 0.0.0-next-14661

package/dist/api.d.ts

@@ -0,0 +1,44 @@
+import { Context } from "effect";
+import { HttpApi, HttpApiGroup, HttpApiMiddleware } from "effect/unstable/httpapi";
+import { SchemaErrorMiddleware } from "./middleware/schema-error.js";
+import { GenerateGroup } from "./groups/generate.js";
+import { MessageGroup } from "./groups/message.js";
+import { ModelGroup } from "./groups/model.js";
+import { ProviderGroup } from "./groups/provider.js";
+import { makeSessionGroup } from "./groups/session.js";
+import { makePermissionGroup } from "./groups/permission.js";
+import { FileSystemGroup } from "./groups/fs.js";
+import { CommandGroup } from "./groups/command.js";
+import { SkillGroup } from "./groups/skill.js";
+import { EventGroup, makeEventGroup } from "./groups/event.js";
+import type { Definition } from "@opencode-ai/schema/event";
+import { AgentGroup } from "./groups/agent.js";
+import { PluginGroup } from "./groups/plugin.js";
+import { HealthGroup } from "./groups/health.js";
+import { PtyGroup } from "./groups/pty.js";
+import { ShellGroup } from "./groups/shell.js";
+import { makeQuestionGroup } from "./groups/question.js";
+import { ReferenceGroup } from "./groups/reference.js";
+import { Authorization } from "./middleware/authorization.js";
+import { LocationGroup } from "./groups/location.js";
+import { IntegrationGroup } from "./groups/integration.js";
+import { McpGroup } from "./groups/mcp.js";
+import { CredentialGroup } from "./groups/credential.js";
+import { ProjectGroup } from "./groups/project.js";
+import { ProjectCopyGroup } from "./groups/project-copy.js";
+type LocationGroups<LocationId extends HttpApiMiddleware.AnyId> = HttpApiGroup.AddMiddleware<typeof LocationGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof AgentGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof PluginGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ModelGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof GenerateGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ProviderGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof IntegrationGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof McpGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof CredentialGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ProjectGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof FileSystemGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof CommandGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof SkillGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof PtyGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ShellGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ReferenceGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ProjectCopyGroup, LocationId>;
+type SessionGroups<SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService> = ReturnType<typeof makeSessionGroup<SessionLocationId, SessionLocationService>> | HttpApiGroup.AddMiddleware<typeof MessageGroup, SessionLocationId>;
+type MixedMiddlewareGroups<LocationId extends HttpApiMiddleware.AnyId, LocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService> = ReturnType<typeof makePermissionGroup<LocationId, LocationService, SessionLocationId, SessionLocationService>> | ReturnType<typeof makeQuestionGroup<LocationId, LocationService, SessionLocationId, SessionLocationService>>;
+type ApiGroups<LocationId extends HttpApiMiddleware.AnyId, LocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService, Event extends HttpApiGroup.Any> = typeof HealthGroup | LocationGroups<LocationId> | SessionGroups<SessionLocationId, SessionLocationService> | MixedMiddlewareGroups<LocationId, LocationService, SessionLocationId, SessionLocationService> | Event;
+type EventGroupFor<Definitions extends ReadonlyArray<Definition>> = ReturnType<typeof makeEventGroup<Definitions>>;
+export type Api<LocationId extends HttpApiMiddleware.AnyId, LocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService, Event extends HttpApiGroup.Any> = HttpApi.HttpApi<"server", HttpApiGroup.AddMiddleware<HttpApiGroup.AddMiddleware<ApiGroups<LocationId, LocationService, SessionLocationId, SessionLocationService, Event>, Authorization>, SchemaErrorMiddleware>>;
+export declare const makeApi: <const Definitions extends ReadonlyArray<Definition>, LocationId extends HttpApiMiddleware.AnyId, LocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService>(options: {
+    readonly definitions: Definitions;
+    readonly locationMiddleware: Context.Key<LocationId, LocationService>;
+    readonly sessionLocationMiddleware: Context.Key<SessionLocationId, SessionLocationService>;
+}) => Api<LocationId, LocationService, SessionLocationId, SessionLocationService, EventGroupFor<Definitions>>;
+export declare const makeDefaultApi: <LocationId extends HttpApiMiddleware.AnyId, LocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService>(options: {
+    readonly locationMiddleware: Context.Key<LocationId, LocationService>;
+    readonly sessionLocationMiddleware: Context.Key<SessionLocationId, SessionLocationService>;
+}) => Api<LocationId, LocationService, SessionLocationId, SessionLocationService, typeof EventGroup>;
+export {};

package/dist/api.js

@@ -0,0 +1,61 @@
+import { Context } from "effect";
+import { HttpApi, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/unstable/httpapi";
+import { SchemaErrorMiddleware } from "./middleware/schema-error.js";
+import { GenerateGroup } from "./groups/generate.js";
+import { MessageGroup } from "./groups/message.js";
+import { ModelGroup } from "./groups/model.js";
+import { ProviderGroup } from "./groups/provider.js";
+import { makeSessionGroup } from "./groups/session.js";
+import { makePermissionGroup } from "./groups/permission.js";
+import { FileSystemGroup } from "./groups/fs.js";
+import { CommandGroup } from "./groups/command.js";
+import { SkillGroup } from "./groups/skill.js";
+import { EventGroup, makeEventGroup } from "./groups/event.js";
+import { AgentGroup } from "./groups/agent.js";
+import { PluginGroup } from "./groups/plugin.js";
+import { HealthGroup } from "./groups/health.js";
+import { PtyGroup } from "./groups/pty.js";
+import { ShellGroup } from "./groups/shell.js";
+import { makeQuestionGroup } from "./groups/question.js";
+import { ReferenceGroup } from "./groups/reference.js";
+import { Authorization } from "./middleware/authorization.js";
+import { LocationGroup } from "./groups/location.js";
+import { IntegrationGroup } from "./groups/integration.js";
+import { McpGroup } from "./groups/mcp.js";
+import { CredentialGroup } from "./groups/credential.js";
+import { ProjectGroup } from "./groups/project.js";
+import { ProjectCopyGroup } from "./groups/project-copy.js";
+// Protocol owns middleware placement, while Server injects concrete keys so Core service identities stay downstream.
+const makeApiFromGroup = (eventGroup, locationMiddleware, sessionLocationMiddleware) => HttpApi.make("server")
+    .add(HealthGroup)
+    .add(LocationGroup.middleware(locationMiddleware))
+    .add(AgentGroup.middleware(locationMiddleware))
+    .add(PluginGroup.middleware(locationMiddleware))
+    .add(makeSessionGroup(sessionLocationMiddleware))
+    .add(MessageGroup.middleware(sessionLocationMiddleware))
+    .add(ModelGroup.middleware(locationMiddleware))
+    .add(GenerateGroup.middleware(locationMiddleware))
+    .add(ProviderGroup.middleware(locationMiddleware))
+    .add(IntegrationGroup.middleware(locationMiddleware))
+    .add(McpGroup.middleware(locationMiddleware))
+    .add(CredentialGroup.middleware(locationMiddleware))
+    .add(ProjectGroup.middleware(locationMiddleware))
+    .add(makePermissionGroup(locationMiddleware, sessionLocationMiddleware))
+    .add(FileSystemGroup.middleware(locationMiddleware))
+    .add(CommandGroup.middleware(locationMiddleware))
+    .add(SkillGroup.middleware(locationMiddleware))
+    .add(eventGroup)
+    .add(PtyGroup.middleware(locationMiddleware))
+    .add(ShellGroup.middleware(locationMiddleware))
+    .add(makeQuestionGroup(locationMiddleware, sessionLocationMiddleware))
+    .add(ReferenceGroup.middleware(locationMiddleware))
+    .add(ProjectCopyGroup.middleware(locationMiddleware))
+    .annotateMerge(OpenApi.annotations({
+    title: "opencode HttpApi",
+    version: "0.0.1",
+    description: "Experimental HttpApi surface for selected instance routes.",
+}))
+    .middleware(Authorization)
+    .middleware(SchemaErrorMiddleware);
+export const makeApi = (options) => makeApiFromGroup(makeEventGroup(options.definitions), options.locationMiddleware, options.sessionLocationMiddleware);
+export const makeDefaultApi = (options) => makeApiFromGroup(EventGroup, options.locationMiddleware, options.sessionLocationMiddleware);

package/dist/client.d.ts

@@ -0,0 +1,69 @@
+import { InvalidRequestError, SessionNotFoundError } from "./errors.js";
+import type { Api } from "./api.js";
+import type { Context } from "effect";
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import type { EventGroup } from "./groups/event.js";
+declare const LocationMiddleware_base: HttpApiMiddleware.ServiceClass<LocationMiddleware, "@opencode-ai/client/LocationMiddleware", {
+    requires: never;
+    provides: never;
+    error: never;
+    clientError: never;
+    requiredForClient: false;
+    security: never;
+}, HttpApiMiddleware.HttpApiMiddleware<never, never, never>>;
+declare class LocationMiddleware extends LocationMiddleware_base {
+}
+declare const SessionLocationMiddleware_base: HttpApiMiddleware.ServiceClass<SessionLocationMiddleware, "@opencode-ai/client/SessionLocationMiddleware", {
+    requires: never;
+    provides: never;
+    error: readonly [typeof InvalidRequestError, typeof SessionNotFoundError];
+    clientError: never;
+    requiredForClient: false;
+    security: never;
+}, HttpApiMiddleware.HttpApiMiddleware<never, readonly [typeof InvalidRequestError, typeof SessionNotFoundError], never>>;
+declare class SessionLocationMiddleware extends SessionLocationMiddleware_base {
+}
+type ClientApiShape = Api<Context.Service.Identifier<typeof LocationMiddleware>, Context.Service.Shape<typeof LocationMiddleware>, Context.Service.Identifier<typeof SessionLocationMiddleware>, Context.Service.Shape<typeof SessionLocationMiddleware>, typeof EventGroup>;
+export declare const ClientApi: ClientApiShape;
+export declare const groupNames: {
+    readonly "server.health": "health";
+    readonly "server.location": "location";
+    readonly "server.agent": "agent";
+    readonly "server.plugin": "plugin";
+    readonly "server.session": "session";
+    readonly "server.message": "message";
+    readonly "server.model": "model";
+    readonly "server.generate": "generate";
+    readonly "server.provider": "provider";
+    readonly "server.integration": "integration";
+    readonly "server.credential": "credential";
+    readonly "server.permission": "permission";
+    readonly "server.fs": "file";
+    readonly "server.command": "command";
+    readonly "server.skill": "skill";
+    readonly "server.event": "event";
+    readonly "server.pty": "pty";
+    readonly "server.shell": "shell";
+    readonly "server.question": "question";
+    readonly "server.reference": "reference";
+    readonly "server.project": "project";
+    readonly "server.projectCopy": "projectCopy";
+};
+export declare const endpointNames: {
+    readonly "session.messages": "list";
+    readonly "integration.connect.key": "connectKey";
+    readonly "integration.connect.oauth": "connectOauth";
+    readonly "integration.attempt.status": "attemptStatus";
+    readonly "integration.attempt.complete": "attemptComplete";
+    readonly "integration.attempt.cancel": "attemptCancel";
+    readonly "session.revert.stage": "revertStage";
+    readonly "session.revert.clear": "revertClear";
+    readonly "session.revert.commit": "revertCommit";
+    readonly "permission.request.list": "listRequests";
+    readonly "permission.saved.list": "listSaved";
+    readonly "permission.saved.remove": "removeSaved";
+    readonly "question.request.list": "listRequests";
+};
+export declare const promiseOmitEndpoints: Set<string>;
+export declare const effectOmitEndpoints: Set<string>;
+export {};

package/dist/client.js

@@ -0,0 +1,52 @@
+import { InvalidRequestError, SessionNotFoundError } from "./errors.js";
+import { makeDefaultApi } from "./api.js";
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+class LocationMiddleware extends HttpApiMiddleware.Service()("@opencode-ai/client/LocationMiddleware") {
+}
+class SessionLocationMiddleware extends HttpApiMiddleware.Service()("@opencode-ai/client/SessionLocationMiddleware", { error: [InvalidRequestError, SessionNotFoundError] }) {
+}
+export const ClientApi = makeDefaultApi({
+    locationMiddleware: LocationMiddleware,
+    sessionLocationMiddleware: SessionLocationMiddleware,
+});
+export const groupNames = {
+    "server.health": "health",
+    "server.location": "location",
+    "server.agent": "agent",
+    "server.plugin": "plugin",
+    "server.session": "session",
+    "server.message": "message",
+    "server.model": "model",
+    "server.generate": "generate",
+    "server.provider": "provider",
+    "server.integration": "integration",
+    "server.credential": "credential",
+    "server.permission": "permission",
+    "server.fs": "file",
+    "server.command": "command",
+    "server.skill": "skill",
+    "server.event": "event",
+    "server.pty": "pty",
+    "server.shell": "shell",
+    "server.question": "question",
+    "server.reference": "reference",
+    "server.project": "project",
+    "server.projectCopy": "projectCopy",
+};
+export const endpointNames = {
+    "session.messages": "list",
+    "integration.connect.key": "connectKey",
+    "integration.connect.oauth": "connectOauth",
+    "integration.attempt.status": "attemptStatus",
+    "integration.attempt.complete": "attemptComplete",
+    "integration.attempt.cancel": "attemptCancel",
+    "session.revert.stage": "revertStage",
+    "session.revert.clear": "revertClear",
+    "session.revert.commit": "revertCommit",
+    "permission.request.list": "listRequests",
+    "permission.saved.list": "listSaved",
+    "permission.saved.remove": "removeSaved",
+    "question.request.list": "listRequests",
+};
+export const promiseOmitEndpoints = new Set(["pty.connect", "pty.connectToken"]);
+export const effectOmitEndpoints = new Set(["fs.read", "pty.connect", "pty.connectToken"]);

package/dist/errors.d.ts

@@ -0,0 +1,97 @@
+import { Schema } from "effect";
+declare const InvalidRequestError_base: Schema.Class<InvalidRequestError, Schema.TaggedStruct<"InvalidRequestError", {
+    readonly message: Schema.String;
+    readonly kind: Schema.optional<Schema.String>;
+    readonly field: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidRequestError extends InvalidRequestError_base {
+}
+declare const UnauthorizedError_base: Schema.Class<UnauthorizedError, Schema.TaggedStruct<"UnauthorizedError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class UnauthorizedError extends UnauthorizedError_base {
+}
+declare const ConflictError_base: Schema.Class<ConflictError, Schema.TaggedStruct<"ConflictError", {
+    readonly message: Schema.String;
+    readonly resource: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ConflictError extends ConflictError_base {
+}
+declare const SessionBusyError_base: Schema.Class<SessionBusyError, Schema.TaggedStruct<"SessionBusyError", {
+    readonly sessionID: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class SessionBusyError extends SessionBusyError_base {
+}
+declare const ServiceUnavailableError_base: Schema.Class<ServiceUnavailableError, Schema.TaggedStruct<"ServiceUnavailableError", {
+    readonly message: Schema.String;
+    readonly service: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ServiceUnavailableError extends ServiceUnavailableError_base {
+}
+declare const UnknownError_base: Schema.Class<UnknownError, Schema.TaggedStruct<"UnknownError", {
+    readonly message: Schema.String;
+    readonly ref: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class UnknownError extends UnknownError_base {
+}
+declare const ProviderNotFoundError_base: Schema.Class<ProviderNotFoundError, Schema.TaggedStruct<"ProviderNotFoundError", {
+    readonly providerID: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProviderNotFoundError extends ProviderNotFoundError_base {
+}
+declare const SessionNotFoundError_base: Schema.Class<SessionNotFoundError, Schema.TaggedStruct<"SessionNotFoundError", {
+    readonly sessionID: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class SessionNotFoundError extends SessionNotFoundError_base {
+}
+declare const MessageNotFoundError_base: Schema.Class<MessageNotFoundError, Schema.TaggedStruct<"MessageNotFoundError", {
+    readonly sessionID: Schema.String;
+    readonly messageID: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class MessageNotFoundError extends MessageNotFoundError_base {
+}
+declare const SkillNotFoundError_base: Schema.Class<SkillNotFoundError, Schema.TaggedStruct<"SkillNotFoundError", {
+    readonly skill: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class SkillNotFoundError extends SkillNotFoundError_base {
+}
+declare const InvalidCursorError_base: Schema.Class<InvalidCursorError, Schema.TaggedStruct<"InvalidCursorError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidCursorError extends InvalidCursorError_base {
+}
+declare const PermissionNotFoundError_base: Schema.Class<PermissionNotFoundError, Schema.TaggedStruct<"PermissionNotFoundError", {
+    readonly requestID: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class PermissionNotFoundError extends PermissionNotFoundError_base {
+}
+declare const QuestionNotFoundError_base: Schema.Class<QuestionNotFoundError, Schema.TaggedStruct<"QuestionNotFoundError", {
+    readonly requestID: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class QuestionNotFoundError extends QuestionNotFoundError_base {
+}
+declare const ForbiddenError_base: Schema.Class<ForbiddenError, Schema.TaggedStruct<"ForbiddenError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ForbiddenError extends ForbiddenError_base {
+}
+declare const PtyNotFoundError_base: Schema.Class<PtyNotFoundError, Schema.TaggedStruct<"PtyNotFoundError", {
+    readonly ptyID: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class PtyNotFoundError extends PtyNotFoundError_base {
+}
+declare const ShellNotFoundError_base: Schema.Class<ShellNotFoundError, Schema.TaggedStruct<"ShellNotFoundError", {
+    readonly id: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ShellNotFoundError extends ShellNotFoundError_base {
+}
+export {};

package/dist/errors.js

@@ -0,0 +1,74 @@
+import { Schema } from "effect";
+export class InvalidRequestError extends Schema.TaggedErrorClass()("InvalidRequestError", {
+    message: Schema.String,
+    kind: Schema.optional(Schema.String),
+    field: Schema.optional(Schema.String),
+}, { httpApiStatus: 400 }) {
+}
+export class UnauthorizedError extends Schema.TaggedErrorClass()("UnauthorizedError", { message: Schema.String }, { httpApiStatus: 401 }) {
+}
+export class ConflictError extends Schema.TaggedErrorClass()("ConflictError", {
+    message: Schema.String,
+    resource: Schema.optional(Schema.String),
+}, { httpApiStatus: 409 }) {
+}
+export class SessionBusyError extends Schema.TaggedErrorClass()("SessionBusyError", {
+    sessionID: Schema.String,
+    message: Schema.String,
+}, { httpApiStatus: 409 }) {
+}
+export class ServiceUnavailableError extends Schema.TaggedErrorClass()("ServiceUnavailableError", {
+    message: Schema.String,
+    service: Schema.optional(Schema.String),
+}, { httpApiStatus: 503 }) {
+}
+export class UnknownError extends Schema.TaggedErrorClass()("UnknownError", {
+    message: Schema.String,
+    ref: Schema.optional(Schema.String),
+}, { httpApiStatus: 500 }) {
+}
+export class ProviderNotFoundError extends Schema.TaggedErrorClass()("ProviderNotFoundError", {
+    providerID: Schema.String,
+    message: Schema.String,
+}, { httpApiStatus: 404 }) {
+}
+export class SessionNotFoundError extends Schema.TaggedErrorClass()("SessionNotFoundError", {
+    sessionID: Schema.String,
+    message: Schema.String,
+}, { httpApiStatus: 404 }) {
+}
+export class MessageNotFoundError extends Schema.TaggedErrorClass()("MessageNotFoundError", {
+    sessionID: Schema.String,
+    messageID: Schema.String,
+    message: Schema.String,
+}, { httpApiStatus: 404 }) {
+}
+export class SkillNotFoundError extends Schema.TaggedErrorClass()("SkillNotFoundError", {
+    skill: Schema.String,
+    message: Schema.String,
+}, { httpApiStatus: 404 }) {
+}
+export class InvalidCursorError extends Schema.TaggedErrorClass()("InvalidCursorError", { message: Schema.String }, { httpApiStatus: 400 }) {
+}
+export class PermissionNotFoundError extends Schema.TaggedErrorClass()("PermissionNotFoundError", {
+    requestID: Schema.String,
+    message: Schema.String,
+}, { httpApiStatus: 404 }) {
+}
+export class QuestionNotFoundError extends Schema.TaggedErrorClass()("QuestionNotFoundError", {
+    requestID: Schema.String,
+    message: Schema.String,
+}, { httpApiStatus: 404 }) {
+}
+export class ForbiddenError extends Schema.TaggedErrorClass()("ForbiddenError", { message: Schema.String }, { httpApiStatus: 403 }) {
+}
+export class PtyNotFoundError extends Schema.TaggedErrorClass()("PtyNotFoundError", {
+    ptyID: Schema.String,
+    message: Schema.String,
+}, { httpApiStatus: 404 }) {
+}
+export class ShellNotFoundError extends Schema.TaggedErrorClass()("ShellNotFoundError", {
+    id: Schema.String,
+    message: Schema.String,
+}, { httpApiStatus: 404 }) {
+}

package/dist/groups/agent.d.ts

@@ -0,0 +1,91 @@
+import { Agent } from "@opencode-ai/schema/agent";
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+export declare const AgentGroup: HttpApiGroup.HttpApiGroup<"server.agent", HttpApiEndpoint.HttpApiEndpoint<"agent.list", "GET", "/api/agent", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "AgentV2.ID">;
+        readonly model: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
+            readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
+                opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                openai: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                google: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                googleVertex: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                githubCopilot: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                amazonBedrock: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                azure: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                openrouter: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            };
+            readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "VariantID">>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
+            readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
+                opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                openai: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                google: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                googleVertex: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                githubCopilot: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                amazonBedrock: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                azure: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                openrouter: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            };
+            readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "VariantID">>, never, never>;
+        }>>, never, never>;
+        readonly request: Schema.Struct<{
+            readonly headers: Schema.$Record<Schema.String, Schema.String>;
+            readonly body: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>;
+        readonly system: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly mode: Schema.Literals<readonly ["subagent", "primary", "all"]>;
+        readonly hidden: Schema.Boolean;
+        readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.String, Schema.Literals<readonly ["primary", "secondary", "accent", "success", "warning", "error", "info"]>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Literals<readonly ["primary", "secondary", "accent", "success", "warning", "error", "info"]>]>>, never, never>;
+        readonly steps: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>;
+    }> & {
+        empty: (id: Agent.ID) => {
+            readonly id: string & import("effect/Brand").Brand<"AgentV2.ID">;
+            readonly request: {
+                readonly headers: {
+                    readonly [x: string]: string;
+                };
+                readonly body: {
+                    readonly [x: string]: Schema.Json;
+                };
+            };
+            readonly mode: "primary" | "subagent" | "all";
+            readonly hidden: boolean;
+            readonly permissions: readonly {
+                readonly action: string;
+                readonly resource: string;
+                readonly effect: "allow" | "deny" | "ask";
+            }[];
+            readonly model?: {
+                readonly id: string & import("effect/Brand").Brand<"ModelV2.ID">;
+                readonly providerID: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                readonly variant?: (string & import("effect/Brand").Brand<"VariantID">) | undefined;
+            } | undefined;
+            readonly system?: string | undefined;
+            readonly description?: string | undefined;
+            readonly color?: string | undefined;
+            readonly steps?: number | undefined;
+        };
+    }>;
+}>>, HttpApiEndpoint.Json<never>, never, never>, false>;

package/dist/groups/agent.js

@@ -0,0 +1,15 @@
+import { Agent } from "@opencode-ai/schema/agent";
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const AgentGroup = HttpApiGroup.make("server.agent").add(HttpApiEndpoint.get("agent.list", "/api/agent", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Agent.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.agent.list",
+    summary: "List agents",
+    description: "Retrieve currently registered agents.",
+})));

package/dist/groups/command.d.ts

@@ -0,0 +1,51 @@
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+export declare const CommandGroup: HttpApiGroup.HttpApiGroup<"server.command", HttpApiEndpoint.HttpApiEndpoint<"command.list", "GET", "/api/command", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly template: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly agent: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly model: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
+            readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
+                opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                openai: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                google: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                googleVertex: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                githubCopilot: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                amazonBedrock: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                azure: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                openrouter: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            };
+            readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "VariantID">>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
+            readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
+                opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                openai: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                google: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                googleVertex: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                githubCopilot: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                amazonBedrock: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                azure: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                openrouter: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            };
+            readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "VariantID">>, never, never>;
+        }>>, never, never>;
+        readonly subtask: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }>>;
+}>>, HttpApiEndpoint.Json<never>, never, never>, false>;

package/dist/groups/command.js

@@ -0,0 +1,20 @@
+import { Command } from "@opencode-ai/schema/command";
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const CommandGroup = HttpApiGroup.make("server.command")
+    .add(HttpApiEndpoint.get("command.list", "/api/command", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Command.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.command.list",
+    summary: "List commands",
+    description: "Retrieve currently registered commands.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "commands",
+    description: "Experimental command routes.",
+}));

package/dist/groups/credential.d.ts

@@ -0,0 +1,23 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+export declare const CredentialGroup: HttpApiGroup.HttpApiGroup<"server.credential", HttpApiEndpoint.HttpApiEndpoint<"credential.update", "PATCH", "/api/credential/:credentialID", HttpApiEndpoint.StringTree<Schema.Struct<{
+    credentialID: Schema.brand<Schema.String, "Credential.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+    };
+}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly label: Schema.String;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"credential.remove", "DELETE", "/api/credential/:credentialID", HttpApiEndpoint.StringTree<Schema.Struct<{
+    credentialID: Schema.brand<Schema.String, "Credential.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+    };
+}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<never>, never, never>, false>;