@opencode/protocol 0.0.0-dev-19575 → 0.0.0-dev-19578

package/dist/api.d.ts

@@ -33,11 +33,11 @@ import { WorktreeGroup } from "./groups/worktree.js";
 import { VcsGroup } from "./groups/vcs.js";
 import { MigrationGroup } from "./groups/migration.js";
 import { ConfigGroup } from "./groups/config.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 ProviderGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof IntegrationGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof WebSearchGroup, 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 RpcGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof PtyGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ShellGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ReferenceGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof WorktreeGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof VcsGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ConfigGroup, LocationId>;
+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 ProviderGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof IntegrationGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof WebSearchGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof McpGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ProjectGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof FileSystemGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof CommandGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof SkillGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof RpcGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof PtyGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ShellGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ReferenceGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof WorktreeGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof VcsGroup, LocationId> | HttpApiGroup.AddMiddleware<typeof ConfigGroup, LocationId>;
 type SessionGroups<SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService> = ReturnType<typeof makeSessionGroup<SessionLocationId, SessionLocationService>> | typeof MessageGroup;
 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>>;
-type ApiGroups<LocationId extends HttpApiMiddleware.AnyId, LocationService, FormLocationId extends HttpApiMiddleware.AnyId, FormLocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService, Event extends HttpApiGroup.Constraint> = typeof ServerGroup | typeof DebugGroup | typeof MigrationGroup | typeof GenerateGroup | typeof PersistentPtyGroup | LocationGroups<LocationId> | FormGroups<LocationId, LocationService, FormLocationId, FormLocationService> | SessionGroups<SessionLocationId, SessionLocationService> | MixedMiddlewareGroups<LocationId, LocationService, SessionLocationId, SessionLocationService> | Event;
+type ApiGroups<LocationId extends HttpApiMiddleware.AnyId, LocationService, FormLocationId extends HttpApiMiddleware.AnyId, FormLocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService, Event extends HttpApiGroup.Constraint> = typeof ServerGroup | typeof DebugGroup | typeof MigrationGroup | typeof GenerateGroup | typeof PersistentPtyGroup | typeof CredentialGroup | 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.Constraint> = 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: {

package/dist/api.js

@@ -45,7 +45,7 @@ const makeApiFromGroup = (eventGroup, locationMiddleware, formLocationMiddleware
     .add(ProviderGroup.middleware(locationMiddleware))
     .add(IntegrationGroup.middleware(locationMiddleware))
     .add(McpGroup.middleware(locationMiddleware))
-    .add(CredentialGroup.middleware(locationMiddleware))
+    .add(CredentialGroup)
     .add(ProjectGroup.middleware(locationMiddleware))
     .add(makeFormGroup(locationMiddleware, formLocationMiddleware))
     .add(makePermissionGroup(locationMiddleware, sessionLocationMiddleware))

package/dist/errors.d.ts

@@ -61,6 +61,20 @@ declare const IntegrationNotFoundError_base: Schema.Class<IntegrationNotFoundErr
 }>, import("effect/Cause").YieldableError>;
 export declare class IntegrationNotFoundError extends IntegrationNotFoundError_base {
 }
+declare const IntegrationAttemptNotFoundError_base: Schema.Class<IntegrationAttemptNotFoundError, Schema.TaggedStruct<"IntegrationAttemptNotFoundError", {
+    readonly integrationID: Schema.String;
+    readonly attemptID: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class IntegrationAttemptNotFoundError extends IntegrationAttemptNotFoundError_base {
+}
+declare const IntegrationMethodNotFoundError_base: Schema.Class<IntegrationMethodNotFoundError, Schema.TaggedStruct<"IntegrationMethodNotFoundError", {
+    readonly integrationID: Schema.String;
+    readonly methodID: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class IntegrationMethodNotFoundError extends IntegrationMethodNotFoundError_base {
+}
 declare const ProjectNotFoundError_base: Schema.Class<ProjectNotFoundError, Schema.TaggedStruct<"ProjectNotFoundError", {
     readonly projectID: Schema.String;
     readonly message: Schema.String;

package/dist/errors.js

@@ -50,6 +50,18 @@ export class IntegrationNotFoundError extends Schema.TaggedError()("IntegrationN
     message: Schema.String,
 }, { httpApiStatus: 404 }) {
 }
+export class IntegrationAttemptNotFoundError extends Schema.TaggedError()("IntegrationAttemptNotFoundError", {
+    integrationID: Schema.String,
+    attemptID: Schema.String,
+    message: Schema.String,
+}, { httpApiStatus: 404 }) {
+}
+export class IntegrationMethodNotFoundError extends Schema.TaggedError()("IntegrationMethodNotFoundError", {
+    integrationID: Schema.String,
+    methodID: Schema.String,
+    message: Schema.String,
+}, { httpApiStatus: 404 }) {
+}
 export class ProjectNotFoundError extends Schema.TaggedError()("ProjectNotFoundError", {
     projectID: Schema.String,
     message: Schema.String,

package/dist/groups/credential.d.ts

@@ -4,26 +4,14 @@ export declare const CredentialGroup: HttpApiGroup.HttpApiGroup<"server.credenti
     credentialID: Schema.brand<Schema.String, "Credential.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Credential.ID">;
     };
-}>>, Schema.toCodecStringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-    }>>;
-}>>, Schema.toCodecJson<Schema.Struct<{
+}>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly label: Schema.String;
 }>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"credential.activate", "POST", "/api/credential/:credentialID/activate", Schema.toCodecStringTree<Schema.Struct<{
     credentialID: Schema.brand<Schema.String, "Credential.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Credential.ID">;
     };
-}>>, Schema.toCodecStringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-    }>>;
-}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"credential.remove", "DELETE", "/api/credential/:credentialID", Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"credential.remove", "DELETE", "/api/credential/:credentialID", Schema.toCodecStringTree<Schema.Struct<{
     credentialID: Schema.brand<Schema.String, "Credential.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Credential.ID">;
     };
-}>>, Schema.toCodecStringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-    }>>;
-}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never>, false>;
+}>>, never, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never>, false>;

package/dist/groups/credential.js

@@ -1,15 +1,12 @@
 import { Credential } from "@opencode/schema/credential";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
-import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const CredentialGroup = HttpApiGroup.make("server.credential")
     .add(HttpApiEndpoint.patch("credential.update", "/api/credential/:credentialID", {
     params: { credentialID: Credential.ID },
-    query: LocationQuery,
     payload: Schema.Struct({ label: Schema.String }),
     success: HttpApiSchema.NoContent,
 })
-    .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
     identifier: "credential.update",
     summary: "Update credential",
@@ -18,10 +15,8 @@ export const CredentialGroup = HttpApiGroup.make("server.credential")
     .annotateMerge(OpenApi.annotations({ title: "credential" }))
     .add(HttpApiEndpoint.post("credential.activate", "/api/credential/:credentialID/activate", {
     params: { credentialID: Credential.ID },
-    query: LocationQuery,
     success: HttpApiSchema.NoContent,
 })
-    .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
     identifier: "credential.activate",
     summary: "Activate credential",
@@ -29,10 +24,8 @@ export const CredentialGroup = HttpApiGroup.make("server.credential")
 })))
     .add(HttpApiEndpoint.delete("credential.remove", "/api/credential/:credentialID", {
     params: { credentialID: Credential.ID },
-    query: LocationQuery,
     success: HttpApiSchema.NoContent,
 })
-    .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
     identifier: "credential.remove",
     summary: "Remove credential",

package/dist/groups/integration.d.ts

@@ -1,7 +1,7 @@
 import { Integration } from "@opencode/schema/integration";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
-import { IntegrationNotFoundError, InvalidRequestError } from "../errors.js";
+import { IntegrationAttemptNotFoundError, IntegrationMethodNotFoundError, IntegrationNotFoundError, InvalidRequestError } from "../errors.js";
 export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integration", HttpApiEndpoint.HttpApiEndpoint<"integration.list", "GET", "/api/integration", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
@@ -1006,7 +1006,7 @@ export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integra
     readonly key: Schema.String;
     readonly answer: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>;
     readonly label: Schema.optional<Schema.String>;
-}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof InvalidRequestError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.oauth.connect", "POST", "/api/integration/:integrationID/connect/oauth", Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof InvalidRequestError | typeof IntegrationNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.oauth.connect", "POST", "/api/integration/:integrationID/connect/oauth", Schema.toCodecStringTree<Schema.Struct<{
     integrationID: Schema.brand<Schema.String, "Integration.ID">;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
@@ -1060,7 +1060,7 @@ export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integra
             readonly expires: Schema.Number;
         }>;
     }>]>;
-}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.oauth.complete", "POST", "/api/integration/:integrationID/connect/oauth/:attemptID/complete", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof IntegrationNotFoundError | typeof IntegrationAttemptNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.oauth.complete", "POST", "/api/integration/:integrationID/connect/oauth/:attemptID/complete", Schema.toCodecStringTree<Schema.Struct<{
     integrationID: Schema.brand<Schema.String, "Integration.ID">;
     attemptID: Schema.brand<Schema.String, "Integration.AttemptID"> & {
         create: () => string & import("effect/Brand").Brand<"Integration.AttemptID">;
@@ -1071,7 +1071,7 @@ export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integra
     }>>;
 }>>, Schema.toCodecJson<Schema.Struct<{
     readonly code: Schema.optional<Schema.String>;
-}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof InvalidRequestError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.oauth.cancel", "DELETE", "/api/integration/:integrationID/connect/oauth/:attemptID", Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof InvalidRequestError | typeof IntegrationNotFoundError | typeof IntegrationAttemptNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.oauth.cancel", "DELETE", "/api/integration/:integrationID/connect/oauth/:attemptID", Schema.toCodecStringTree<Schema.Struct<{
     integrationID: Schema.brand<Schema.String, "Integration.ID">;
     attemptID: Schema.brand<Schema.String, "Integration.AttemptID"> & {
         create: () => string & import("effect/Brand").Brand<"Integration.AttemptID">;
@@ -1102,7 +1102,7 @@ export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integra
             readonly expires: Schema.Number;
         }>;
     }>;
-}>>, Schema.toCodecJson<typeof InvalidRequestError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.command.status", "GET", "/api/integration/:integrationID/connect/command/:attemptID", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof InvalidRequestError | typeof IntegrationNotFoundError | typeof IntegrationMethodNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.command.status", "GET", "/api/integration/:integrationID/connect/command/:attemptID", Schema.toCodecStringTree<Schema.Struct<{
     integrationID: Schema.brand<Schema.String, "Integration.ID">;
     attemptID: Schema.brand<Schema.String, "Integration.AttemptID"> & {
         create: () => string & import("effect/Brand").Brand<"Integration.AttemptID">;
@@ -1142,7 +1142,7 @@ export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integra
             readonly expires: Schema.Number;
         }>;
     }>]>;
-}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.command.cancel", "DELETE", "/api/integration/:integrationID/connect/command/:attemptID", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof IntegrationNotFoundError | typeof IntegrationAttemptNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"integration.command.cancel", "DELETE", "/api/integration/:integrationID/connect/command/:attemptID", Schema.toCodecStringTree<Schema.Struct<{
     integrationID: Schema.brand<Schema.String, "Integration.ID">;
     attemptID: Schema.brand<Schema.String, "Integration.AttemptID"> & {
         create: () => string & import("effect/Brand").Brand<"Integration.AttemptID">;

package/dist/groups/integration.js

@@ -3,7 +3,7 @@ import { Location } from "@opencode/schema/location";
 import { Form } from "@opencode/schema/form";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
-import { IntegrationNotFoundError, InvalidRequestError } from "../errors.js";
+import { IntegrationAttemptNotFoundError, IntegrationMethodNotFoundError, IntegrationNotFoundError, InvalidRequestError, } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const IntegrationGroup = HttpApiGroup.make("server.integration")
     .add(HttpApiEndpoint.get("integration.list", "/api/integration", {
@@ -49,7 +49,7 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
         label: Schema.optional(Schema.String),
     }),
     success: HttpApiSchema.NoContent,
-    error: InvalidRequestError,
+    error: [IntegrationNotFoundError, InvalidRequestError],
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
@@ -78,6 +78,7 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
     params: { integrationID: Integration.ID, attemptID: Integration.AttemptID },
     query: LocationQuery,
     success: Location.response(Integration.AttemptStatus),
+    error: [IntegrationNotFoundError, IntegrationAttemptNotFoundError],
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
@@ -90,7 +91,7 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
     query: LocationQuery,
     payload: Schema.Struct({ code: Schema.optional(Schema.String) }),
     success: HttpApiSchema.NoContent,
-    error: InvalidRequestError,
+    error: [IntegrationNotFoundError, IntegrationAttemptNotFoundError, InvalidRequestError],
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
@@ -117,7 +118,7 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
         label: Schema.optional(Schema.String),
     }),
     success: Location.response(Integration.CommandAttempt),
-    error: InvalidRequestError,
+    error: [IntegrationNotFoundError, IntegrationMethodNotFoundError, InvalidRequestError],
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
@@ -129,6 +130,7 @@ export const IntegrationGroup = HttpApiGroup.make("server.integration")
     params: { integrationID: Integration.ID, attemptID: Integration.AttemptID },
     query: LocationQuery,
     success: Location.response(Integration.CommandAttemptStatus),
+    error: [IntegrationNotFoundError, IntegrationAttemptNotFoundError],
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({

package/dist/groups/mcp.d.ts

@@ -26,7 +26,7 @@ export declare const McpGroup: HttpApiGroup.HttpApiGroup<"server.mcp", HttpApiEn
         }>]>;
         readonly integrationID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Integration.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Integration.ID">>, never, never>;
     }>>;
-}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.add", "PUT", "/api/mcp/:server", Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.add", "PUT", "/api/experimental/mcp/:server", Schema.toCodecStringTree<Schema.Struct<{
     server: Schema.String;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
@@ -34,19 +34,19 @@ export declare const McpGroup: HttpApiGroup.HttpApiGroup<"server.mcp", HttpApiEn
     }>>;
 }>>, Schema.toCodecJson<Schema.Struct<{
     readonly config: Schema.toTaggedUnion<"type", readonly [typeof Mcp.LocalConfig, typeof Mcp.RemoteConfig]>;
-}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.remove", "DELETE", "/api/mcp/:server", Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.remove", "DELETE", "/api/experimental/mcp/:server", Schema.toCodecStringTree<Schema.Struct<{
     server: Schema.String;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
     }>>;
-}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof McpServerNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.connect", "POST", "/api/mcp/:server/connect", Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof McpServerNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.connect", "POST", "/api/experimental/mcp/:server/connect", Schema.toCodecStringTree<Schema.Struct<{
     server: Schema.String;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
     }>>;
-}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof McpServerNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.disconnect", "POST", "/api/mcp/:server/disconnect", Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof McpServerNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.disconnect", "POST", "/api/experimental/mcp/:server/disconnect", Schema.toCodecStringTree<Schema.Struct<{
     server: Schema.String;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{

package/dist/groups/mcp.js

@@ -15,7 +15,7 @@ export const McpGroup = HttpApiGroup.make("server.mcp")
     summary: "List MCP servers",
     description: "Retrieve configured MCP servers and their connection status.",
 })))
-    .add(HttpApiEndpoint.put("mcp.add", "/api/mcp/:server", {
+    .add(HttpApiEndpoint.put("mcp.add", "/api/experimental/mcp/:server", {
     params: { server: Schema.String },
     query: LocationQuery,
     // Wrapped in a struct because the client codegen flattens payload fields and cannot
@@ -25,11 +25,11 @@ export const McpGroup = HttpApiGroup.make("server.mcp")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "mcp.add",
+    identifier: "experimental.mcp.add",
     summary: "Add MCP server",
     description: "Add an MCP server at runtime or replace an existing one, connecting it immediately.",
 })))
-    .add(HttpApiEndpoint.delete("mcp.remove", "/api/mcp/:server", {
+    .add(HttpApiEndpoint.delete("mcp.remove", "/api/experimental/mcp/:server", {
     params: { server: Schema.String },
     query: LocationQuery,
     success: HttpApiSchema.NoContent,
@@ -37,11 +37,11 @@ export const McpGroup = HttpApiGroup.make("server.mcp")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "mcp.remove",
+    identifier: "experimental.mcp.remove",
     summary: "Remove MCP server",
     description: "Stop an MCP server and remove it from the runtime set until restart.",
 })))
-    .add(HttpApiEndpoint.post("mcp.connect", "/api/mcp/:server/connect", {
+    .add(HttpApiEndpoint.post("mcp.connect", "/api/experimental/mcp/:server/connect", {
     params: { server: Schema.String },
     query: LocationQuery,
     success: HttpApiSchema.NoContent,
@@ -49,11 +49,11 @@ export const McpGroup = HttpApiGroup.make("server.mcp")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "mcp.connect",
+    identifier: "experimental.mcp.connect",
     summary: "Connect MCP server",
     description: "Connect an MCP server at runtime, overriding a disabled configuration until restart.",
 })))
-    .add(HttpApiEndpoint.post("mcp.disconnect", "/api/mcp/:server/disconnect", {
+    .add(HttpApiEndpoint.post("mcp.disconnect", "/api/experimental/mcp/:server/disconnect", {
     params: { server: Schema.String },
     query: LocationQuery,
     success: HttpApiSchema.NoContent,
@@ -61,7 +61,7 @@ export const McpGroup = HttpApiGroup.make("server.mcp")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "mcp.disconnect",
+    identifier: "experimental.mcp.disconnect",
     summary: "Disconnect MCP server",
     description: "Disconnect an MCP server at runtime, removing its tools until reconnected.",
 })))

package/dist/groups/session.d.ts

@@ -366,7 +366,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             }, "Invalid cursor", never>;
         }>;
     }>;
-}>>, Schema.toCodecJson<typeof InvalidRequestError | typeof InvalidCursorError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.stats", "GET", "/api/session/stats", never, Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof InvalidRequestError | typeof InvalidCursorError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.stats", "GET", "/api/experimental/session/stats", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly from: Schema.optional<Schema.NumberFromString>;
     readonly to: Schema.optional<Schema.NumberFromString>;
     readonly project: Schema.optional<Schema.brand<Schema.String, "Project.ID"> & {
@@ -2800,15 +2800,10 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     };
 }>>, never, Schema.toCodecJson<Schema.Struct<{
-    readonly boundary: Schema.Union<readonly [Schema.Struct<{
-        readonly type: Schema.Literal<"before">;
-        readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
-        };
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"through">;
-    }>]>;
+    readonly before: Schema.optional<Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    }>;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly data: Schema.Struct<{
         readonly location: Schema.Struct<{

package/dist/groups/session.js

@@ -128,7 +128,7 @@ export const makeSessionGroup = (sessionLocationMiddleware) => HttpApiGroup.make
     summary: "List sessions",
     description: "Retrieve sessions in the requested order. Items keep that order across pages; use cursor.next or cursor.previous to move through the ordered list.",
 })))
-    .add(HttpApiEndpoint.get("session.stats", "/api/session/stats", {
+    .add(HttpApiEndpoint.get("session.stats", "/api/experimental/session/stats", {
     query: Schema.Struct({
         from: Schema.NumberFromString.pipe(Schema.optional),
         to: Schema.NumberFromString.pipe(Schema.optional),
@@ -139,7 +139,7 @@ export const makeSessionGroup = (sessionLocationMiddleware) => HttpApiGroup.make
     success: Schema.Struct({ data: SessionStats.Info }),
     error: InvalidRequestError,
 }).annotateMerge(OpenApi.annotations({
-    identifier: "session.stats",
+    identifier: "experimental.session.stats",
     summary: "Get session statistics",
     description: "Aggregate local session activity, usage, and tool reliability for a time range.",
 })))
@@ -208,7 +208,7 @@ export const makeSessionGroup = (sessionLocationMiddleware) => HttpApiGroup.make
 })))
     .add(HttpApiEndpoint.post("session.fork", "/api/session/:sessionID/fork", {
     params: { sessionID: Session.ID },
-    payload: Schema.Struct({ boundary: Session.ForkRequestBoundary }),
+    payload: Schema.Struct({ before: SessionMessage.ID.pipe(Schema.optional) }),
     success: Schema.Struct({ data: PublicSessionInfo }),
     error: [SessionNotFoundError, MessageNotFoundError, InvalidRequestError],
 })
@@ -216,7 +216,7 @@ export const makeSessionGroup = (sessionLocationMiddleware) => HttpApiGroup.make
     .annotateMerge(OpenApi.annotations({
     identifier: "session.fork",
     summary: "Fork session",
-    description: "Create a child session by copying projected history through or before a message boundary.",
+    description: "Create a child session by copying projected history before a message. Omit before to copy the full history.",
 })))
     .add(HttpApiEndpoint.post("session.switchAgent", "/api/session/:sessionID/agent", {
     params: { sessionID: Session.ID },

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/protocol",
-  "version": "0.0.0-dev-19575",
+  "version": "0.0.0-dev-19578",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -32,7 +32,7 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@opencode/schema": "0.0.0-dev-19575",
+    "@opencode/schema": "0.0.0-dev-19578",
     "effect": "4.0.0-rc.112"
   },
   "devDependencies": {