feat(protocol): publish package

packages/protocol/src/api.ts

@@ -1,31 +1,97 @@
 import { Context } from "effect"
 import { HttpApi, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/unstable/httpapi"
-import { SchemaErrorMiddleware } from "./middleware/schema-error"
-import { GenerateGroup } from "./groups/generate"
-import { MessageGroup } from "./groups/message"
-import { ModelGroup } from "./groups/model"
-import { ProviderGroup } from "./groups/provider"
-import { makeSessionGroup } from "./groups/session"
-import { makePermissionGroup } from "./groups/permission"
-import { FileSystemGroup } from "./groups/fs"
-import { CommandGroup } from "./groups/command"
-import { SkillGroup } from "./groups/skill"
-import { EventGroup, makeEventGroup } from "./groups/event"
+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"
-import { PluginGroup } from "./groups/plugin"
-import { HealthGroup } from "./groups/health"
-import { PtyGroup } from "./groups/pty"
-import { ShellGroup } from "./groups/shell"
-import { makeQuestionGroup } from "./groups/question"
-import { ReferenceGroup } from "./groups/reference"
-import { Authorization } from "./middleware/authorization"
-import { LocationGroup } from "./groups/location"
-import { IntegrationGroup } from "./groups/integration"
-import { McpGroup } from "./groups/mcp"
-import { CredentialGroup } from "./groups/credential"
-import { ProjectGroup } from "./groups/project"
-import { ProjectCopyGroup } from "./groups/project-copy"
+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
+  >
+>
 
 // Protocol owns middleware placement, while Server injects concrete keys so Core service identities stay downstream.
 const makeApiFromGroup = <
@@ -38,7 +104,7 @@ const makeApiFromGroup = <
   eventGroup: Group,
   locationMiddleware: Context.Key<LocationId, LocationService>,
   sessionLocationMiddleware: Context.Key<SessionLocationId, SessionLocationService>,
-) =>
+): Api<LocationId, LocationService, SessionLocationId, SessionLocationService, Group> =>
   HttpApi.make("server")
     .add(HealthGroup)
     .add(LocationGroup.middleware(locationMiddleware))
@@ -74,15 +140,16 @@ const makeApiFromGroup = <
     .middleware(SchemaErrorMiddleware)
 
 export const makeApi = <
+  const Definitions extends ReadonlyArray<Definition>,
   LocationId extends HttpApiMiddleware.AnyId,
   LocationService,
   SessionLocationId extends HttpApiMiddleware.AnyId,
   SessionLocationService,
 >(options: {
-  readonly definitions: ReadonlyArray<Definition>
+  readonly definitions: Definitions
   readonly locationMiddleware: Context.Key<LocationId, LocationService>
   readonly sessionLocationMiddleware: Context.Key<SessionLocationId, SessionLocationService>
-}) =>
+}): Api<LocationId, LocationService, SessionLocationId, SessionLocationService, EventGroupFor<Definitions>> =>
   makeApiFromGroup(makeEventGroup(options.definitions), options.locationMiddleware, options.sessionLocationMiddleware)
 
 export const makeDefaultApi = <
@@ -93,4 +160,5 @@ export const makeDefaultApi = <
 >(options: {
   readonly locationMiddleware: Context.Key<LocationId, LocationService>
   readonly sessionLocationMiddleware: Context.Key<SessionLocationId, SessionLocationService>
-}) => makeApiFromGroup(EventGroup, options.locationMiddleware, options.sessionLocationMiddleware)
+}): Api<LocationId, LocationService, SessionLocationId, SessionLocationService, typeof EventGroup> =>
+  makeApiFromGroup(EventGroup, options.locationMiddleware, options.sessionLocationMiddleware)

packages/protocol/src/client.ts

@@ -1,6 +1,9 @@
-import { InvalidRequestError, SessionNotFoundError } from "./errors"
-import { makeDefaultApi } from "./api"
+import { InvalidRequestError, SessionNotFoundError } from "./errors.js"
+import { makeDefaultApi } from "./api.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"
 
 class LocationMiddleware extends HttpApiMiddleware.Service<LocationMiddleware>()(
   "@opencode-ai/client/LocationMiddleware",
@@ -11,7 +14,15 @@ class SessionLocationMiddleware extends HttpApiMiddleware.Service<SessionLocatio
   { error: [InvalidRequestError, SessionNotFoundError] },
 ) {}
 
-export const ClientApi = makeDefaultApi({
+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 const ClientApi: ClientApiShape = makeDefaultApi({
   locationMiddleware: LocationMiddleware,
   sessionLocationMiddleware: SessionLocationMiddleware,
 })

packages/protocol/src/groups/agent.ts

@@ -2,7 +2,7 @@ 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"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 export const AgentGroup = HttpApiGroup.make("server.agent").add(
   HttpApiEndpoint.get("agent.list", "/api/agent", {

packages/protocol/src/groups/command.ts

@@ -2,7 +2,7 @@ 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"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 export const CommandGroup = HttpApiGroup.make("server.command")
   .add(

packages/protocol/src/groups/credential.ts

@@ -1,7 +1,7 @@
 import { Credential } from "@opencode-ai/schema/credential"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { LocationQuery, locationQueryOpenApi } from "./location"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 export const CredentialGroup = HttpApiGroup.make("server.credential")
   .add(

packages/protocol/src/groups/fs.ts

@@ -3,7 +3,7 @@ import { Location } from "@opencode-ai/schema/location"
 import { PositiveInt, RelativePath } from "@opencode-ai/schema/schema"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { LocationQuery, locationQueryOpenApi } from "./location"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 const ListQuery = Schema.Struct({
   ...LocationQuery.fields,

packages/protocol/src/groups/generate.ts

@@ -1,8 +1,8 @@
 import { Model } from "@opencode-ai/schema/model"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { InvalidRequestError, ServiceUnavailableError } from "../errors"
-import { LocationQuery, locationQueryOpenApi } from "./location"
+import { InvalidRequestError, ServiceUnavailableError } from "../errors.js"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 export const GenerateGroup = HttpApiGroup.make("server.generate")
   .add(

packages/protocol/src/groups/integration.ts

@@ -2,8 +2,8 @@ import { Integration } from "@opencode-ai/schema/integration"
 import { Location } from "@opencode-ai/schema/location"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { InvalidRequestError } from "../errors"
-import { LocationQuery, locationQueryOpenApi } from "./location"
+import { InvalidRequestError } from "../errors.js"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 const Inputs = Schema.Record(Schema.String, Schema.String)
 

packages/protocol/src/groups/mcp.ts

@@ -2,7 +2,7 @@ import { Mcp } from "@opencode-ai/schema/mcp"
 import { Location } from "@opencode-ai/schema/location"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { LocationQuery, locationQueryOpenApi } from "./location"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 export const McpGroup = HttpApiGroup.make("server.mcp")
   .add(

packages/protocol/src/groups/message.ts

@@ -2,7 +2,7 @@ import { Session } from "@opencode-ai/schema/session"
 import { SessionMessage } from "@opencode-ai/schema/session-message"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { InvalidCursorError, SessionNotFoundError, UnknownError } from "../errors"
+import { InvalidCursorError, SessionNotFoundError, UnknownError } from "../errors.js"
 
 export const SessionMessagesQuery = Schema.Struct({
   limit: Schema.optional(

packages/protocol/src/groups/model.ts

@@ -2,8 +2,8 @@ import { Model } from "@opencode-ai/schema/model"
 import { Location } from "@opencode-ai/schema/location"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { ServiceUnavailableError } from "../errors"
-import { LocationQuery, locationQueryOpenApi } from "./location"
+import { ServiceUnavailableError } from "../errors.js"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 export const ModelGroup = HttpApiGroup.make("server.model")
   .add(

packages/protocol/src/groups/permission.ts

@@ -6,8 +6,8 @@ import { Project } from "@opencode-ai/schema/project"
 import { Session } from "@opencode-ai/schema/session"
 import { Context, Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { PermissionNotFoundError, SessionNotFoundError } from "../errors"
-import { LocationQuery, locationQueryOpenApi } from "./location"
+import { PermissionNotFoundError, SessionNotFoundError } from "../errors.js"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 export const makePermissionGroup = <
   LocationId extends HttpApiMiddleware.AnyId,

packages/protocol/src/groups/plugin.ts

@@ -2,7 +2,7 @@ import { Location } from "@opencode-ai/schema/location"
 import { Plugin } from "@opencode-ai/schema/plugin"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { LocationQuery, locationQueryOpenApi } from "./location"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 export const PluginGroup = HttpApiGroup.make("server.plugin")
   .add(

packages/protocol/src/groups/project-copy.ts

@@ -2,7 +2,7 @@ import { ProjectCopy } from "@opencode-ai/schema/project-copy"
 import { Project } from "@opencode-ai/schema/project"
 import { Schema, Struct } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { LocationQuery, locationQueryOpenApi } from "./location"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 const root = "/experimental/project/:projectID/copy"
 

packages/protocol/src/groups/project.ts

@@ -1,6 +1,6 @@
 import { Project } from "@opencode-ai/schema/project"
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { LocationQuery, locationQueryOpenApi } from "./location"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 const root = "/api/project"
 

packages/protocol/src/groups/provider.ts

@@ -2,8 +2,8 @@ import { Provider } from "@opencode-ai/schema/provider"
 import { Location } from "@opencode-ai/schema/location"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { ProviderNotFoundError, ServiceUnavailableError } from "../errors"
-import { LocationQuery, locationQueryOpenApi } from "./location"
+import { ProviderNotFoundError, ServiceUnavailableError } from "../errors.js"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 export const ProviderGroup = HttpApiGroup.make("server.provider")
   .add(

packages/protocol/src/groups/pty.ts

@@ -3,8 +3,8 @@ import { PtyTicket } from "@opencode-ai/schema/pty-ticket"
 import { Location } from "@opencode-ai/schema/location"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { ForbiddenError, PtyNotFoundError } from "../errors"
-import { LocationQuery, locationQueryOpenApi } from "./location"
+import { ForbiddenError, PtyNotFoundError } from "../errors.js"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 export const PTY_CONNECT_TICKET_QUERY = "ticket"
 export const PTY_CONNECT_TOKEN_HEADER = "x-opencode-ticket"

packages/protocol/src/groups/question.ts

@@ -3,8 +3,8 @@ import { Location } from "@opencode-ai/schema/location"
 import { Session } from "@opencode-ai/schema/session"
 import { Context, Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { QuestionNotFoundError, SessionNotFoundError } from "../errors"
-import { LocationQuery, locationQueryOpenApi } from "./location"
+import { QuestionNotFoundError, SessionNotFoundError } from "../errors.js"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 export const makeQuestionGroup = <
   LocationId extends HttpApiMiddleware.AnyId,

packages/protocol/src/groups/reference.ts

@@ -2,7 +2,7 @@ import { Location } from "@opencode-ai/schema/location"
 import { Reference } from "@opencode-ai/schema/reference"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { LocationQuery, locationQueryOpenApi } from "./location"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 export const ReferenceGroup = HttpApiGroup.make("server.reference")
   .add(

packages/protocol/src/groups/session.ts

@@ -17,7 +17,7 @@ import {
   SessionNotFoundError,
   SkillNotFoundError,
   UnknownError,
-} from "../errors"
+} from "../errors.js"
 import { Agent } from "@opencode-ai/schema/agent"
 import { Model } from "@opencode-ai/schema/model"
 import { Location } from "@opencode-ai/schema/location"

packages/protocol/src/groups/shell.ts

@@ -2,8 +2,8 @@ import { Shell } from "@opencode-ai/schema/shell"
 import { Location } from "@opencode-ai/schema/location"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { ShellNotFoundError } from "../errors"
-import { LocationQuery, locationQueryOpenApi } from "./location"
+import { ShellNotFoundError } from "../errors.js"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 export const ShellGroup = HttpApiGroup.make("server.shell")
   .add(

packages/protocol/src/groups/skill.ts

@@ -2,7 +2,7 @@ import { Skill } from "@opencode-ai/schema/skill"
 import { Location } from "@opencode-ai/schema/location"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { LocationQuery, locationQueryOpenApi } from "./location"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
 export const SkillGroup = HttpApiGroup.make("server.skill")
   .add(

packages/protocol/src/middleware/authorization.ts

@@ -1,5 +1,5 @@
 import { HttpApiMiddleware } from "effect/unstable/httpapi"
-import { UnauthorizedError } from "../errors"
+import { UnauthorizedError } from "../errors.js"
 
 export class Authorization extends HttpApiMiddleware.Service<Authorization>()("@opencode/HttpApiAuthorization", {
   error: UnauthorizedError,

packages/protocol/src/middleware/schema-error.ts

@@ -1,5 +1,5 @@
 import { HttpApiMiddleware } from "effect/unstable/httpapi"
-import { InvalidRequestError } from "../errors"
+import { InvalidRequestError } from "../errors.js"
 
 export class SchemaErrorMiddleware extends HttpApiMiddleware.Service<SchemaErrorMiddleware>()(
   "@opencode/HttpApiSchemaError",