@opencode-ai/protocol 0.0.0-next-14854 → 0.0.0-reserved.0

package/README.md

@@ -0,0 +1,3 @@
+# @opencode-ai/protocol
+
+Reserved package name for opencode protocol.

package/index.js

@@ -0,0 +1 @@
+export {}

package/package.json

@@ -1,7 +1,7 @@
 {
-  "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/protocol",
-  "version": "0.0.0-next-14854",
+  "version": "0.0.0-reserved.0",
+  "description": "Reserved package name for opencode protocol.",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -12,27 +12,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "dist"
-  ],
   "exports": {
-    "./*": {
-      "import": "./dist/*.js",
-      "types": "./dist/*.d.ts"
-    }
-  },
-  "scripts": {
-    "build": "bun run script/build.ts",
-    "typecheck": "tsgo --noEmit"
-  },
-  "dependencies": {
-    "@opencode-ai/schema": "0.0.0-next-14854",
-    "effect": "4.0.0-beta.83"
-  },
-  "devDependencies": {
-    "@tsconfig/bun": "1.0.9",
-    "@types/bun": "1.3.13",
-    "@typescript/native-preview": "7.0.0-dev.20251207.1",
-    "typescript": "5.8.2"
+    ".": "./index.js"
   }
 }

package/dist/api.d.ts

@@ -1,49 +0,0 @@
-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 { makeFormGroup } from "./groups/form.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";
-import { VcsGroup } from "./groups/vcs.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> | HttpApiGroup.AddMiddleware<typeof VcsGroup, LocationId>;
-type SessionGroups<SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService> = ReturnType<typeof makeSessionGroup<SessionLocationId, SessionLocationService>> | HttpApiGroup.AddMiddleware<typeof MessageGroup, SessionLocationId>;
-type FormGroups<LocationId extends HttpApiMiddleware.AnyId, LocationService, FormLocationId extends HttpApiMiddleware.AnyId, FormLocationService> = ReturnType<typeof makeFormGroup<LocationId, LocationService, FormLocationId, FormLocationService>>;
-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, FormLocationId extends HttpApiMiddleware.AnyId, FormLocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService, Event extends HttpApiGroup.Any> = typeof HealthGroup | LocationGroups<LocationId> | FormGroups<LocationId, LocationService, FormLocationId, FormLocationService> | 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, FormLocationId extends HttpApiMiddleware.AnyId, FormLocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService, Event extends HttpApiGroup.Any> = HttpApi.HttpApi<"server", HttpApiGroup.AddMiddleware<HttpApiGroup.AddMiddleware<ApiGroups<LocationId, LocationService, FormLocationId, FormLocationService, SessionLocationId, SessionLocationService, Event>, Authorization>, SchemaErrorMiddleware>>;
-export declare const makeApi: <const Definitions extends ReadonlyArray<Definition>, LocationId extends HttpApiMiddleware.AnyId, LocationService, FormLocationId extends HttpApiMiddleware.AnyId, FormLocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService>(options: {
-    readonly definitions: Definitions;
-    readonly locationMiddleware: Context.Key<LocationId, LocationService>;
-    readonly formLocationMiddleware: Context.Key<FormLocationId, FormLocationService>;
-    readonly sessionLocationMiddleware: Context.Key<SessionLocationId, SessionLocationService>;
-}) => Api<LocationId, LocationService, FormLocationId, FormLocationService, SessionLocationId, SessionLocationService, EventGroupFor<Definitions>>;
-export declare const makeDefaultApi: <LocationId extends HttpApiMiddleware.AnyId, LocationService, FormLocationId extends HttpApiMiddleware.AnyId, FormLocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService>(options: {
-    readonly locationMiddleware: Context.Key<LocationId, LocationService>;
-    readonly formLocationMiddleware: Context.Key<FormLocationId, FormLocationService>;
-    readonly sessionLocationMiddleware: Context.Key<SessionLocationId, SessionLocationService>;
-}) => Api<LocationId, LocationService, FormLocationId, FormLocationService, SessionLocationId, SessionLocationService, typeof EventGroup>;
-export {};

package/dist/api.js

@@ -1,65 +0,0 @@
-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 { makeFormGroup } from "./groups/form.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";
-import { VcsGroup } from "./groups/vcs.js";
-// Protocol owns middleware placement, while Server injects concrete keys so Core service identities stay downstream.
-const makeApiFromGroup = (eventGroup, locationMiddleware, formLocationMiddleware, 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(makeFormGroup(locationMiddleware, formLocationMiddleware))
-    .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))
-    .add(VcsGroup.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.formLocationMiddleware, options.sessionLocationMiddleware);
-export const makeDefaultApi = (options) => makeApiFromGroup(EventGroup, options.locationMiddleware, options.formLocationMiddleware, options.sessionLocationMiddleware);

package/dist/client.d.ts

@@ -1,75 +0,0 @@
-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>, 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.form": "form";
-    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";
-    readonly "server.vcs": "vcs";
-};
-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.context.entry.list": "listContextEntries";
-    readonly "session.context.entry.put": "putContextEntry";
-    readonly "session.context.entry.remove": "removeContextEntry";
-    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 "form.request.list": "listRequests";
-    readonly "question.request.list": "listRequests";
-};
-export declare const promiseOmitEndpoints: Set<string>;
-export declare const effectOmitEndpoints: Set<string>;
-export {};

package/dist/client.js

@@ -1,61 +0,0 @@
-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,
-    // The real server uses a form-specific middleware with an undocumented `global` sentinel branch.
-    // The generated client only needs a middleware identity for API typing.
-    formLocationMiddleware: SessionLocationMiddleware,
-    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.form": "form",
-    "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",
-    "server.vcs": "vcs",
-};
-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.context.entry.list": "listContextEntries",
-    "session.context.entry.put": "putContextEntry",
-    "session.context.entry.remove": "removeContextEntry",
-    "session.revert.stage": "revertStage",
-    "session.revert.clear": "revertClear",
-    "session.revert.commit": "revertCommit",
-    "permission.request.list": "listRequests",
-    "permission.saved.list": "listSaved",
-    "permission.saved.remove": "removeSaved",
-    "form.request.list": "listRequests",
-    "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

@@ -1,127 +0,0 @@
-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 CommandNotFoundError_base: Schema.Class<CommandNotFoundError, Schema.TaggedStruct<"CommandNotFoundError", {
-    readonly command: Schema.String;
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class CommandNotFoundError extends CommandNotFoundError_base {
-}
-declare const CommandEvaluationError_base: Schema.Class<CommandEvaluationError, Schema.TaggedStruct<"CommandEvaluationError", {
-    readonly command: Schema.String;
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class CommandEvaluationError extends CommandEvaluationError_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 FormNotFoundError_base: Schema.Class<FormNotFoundError, Schema.TaggedStruct<"FormNotFoundError", {
-    readonly id: Schema.String;
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class FormNotFoundError extends FormNotFoundError_base {
-}
-declare const FormAlreadySettledError_base: Schema.Class<FormAlreadySettledError, Schema.TaggedStruct<"FormAlreadySettledError", {
-    readonly id: Schema.String;
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class FormAlreadySettledError extends FormAlreadySettledError_base {
-}
-declare const FormInvalidAnswerError_base: Schema.Class<FormInvalidAnswerError, Schema.TaggedStruct<"FormInvalidAnswerError", {
-    readonly id: Schema.String;
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class FormInvalidAnswerError extends FormInvalidAnswerError_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

@@ -1,99 +0,0 @@
-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 CommandNotFoundError extends Schema.TaggedErrorClass()("CommandNotFoundError", {
-    command: Schema.String,
-    message: Schema.String,
-}, { httpApiStatus: 404 }) {
-}
-export class CommandEvaluationError extends Schema.TaggedErrorClass()("CommandEvaluationError", {
-    command: Schema.String,
-    message: Schema.String,
-}, { httpApiStatus: 500 }) {
-}
-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 FormNotFoundError extends Schema.TaggedErrorClass()("FormNotFoundError", {
-    id: Schema.String,
-    message: Schema.String,
-}, { httpApiStatus: 404 }) {
-}
-export class FormAlreadySettledError extends Schema.TaggedErrorClass()("FormAlreadySettledError", {
-    id: Schema.String,
-    message: Schema.String,
-}, { httpApiStatus: 409 }) {
-}
-export class FormInvalidAnswerError extends Schema.TaggedErrorClass()("FormInvalidAnswerError", {
-    id: Schema.String,
-    message: Schema.String,
-}, { httpApiStatus: 400 }) {
-}
-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

@@ -1,95 +0,0 @@
-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 settings: Schema.withConstructorDefault<Schema.$Record<Schema.String, Schema.Unknown>>;
-            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 settings: {
-                    readonly [x: string]: unknown;
-                };
-                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

@@ -1,15 +0,0 @@
-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.",
-})));