@opencode-ai/protocol 0.0.0-dev-17471

package/dist/groups/agent.d.ts

@@ -0,0 +1,194 @@
+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";
+import { AgentNotFoundError } from "../errors.js";
+export declare const AgentGroup: HttpApiGroup.HttpApiGroup<"server.agent", HttpApiEndpoint.HttpApiEndpoint<"agent.list", "GET", "/api/agent", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Agent.ID">;
+        readonly name: Schema.brand<Schema.String, "Agent.Name">;
+        readonly model: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Model.ID">;
+            readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+                opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+                anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+                openai: string & import("effect/Brand").Brand<"Provider.ID">;
+                google: string & import("effect/Brand").Brand<"Provider.ID">;
+                googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+                githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+                amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+                azure: string & import("effect/Brand").Brand<"Provider.ID">;
+                openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+                mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+                gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+            };
+            readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+        }> & {
+            parse: (input: string) => {
+                readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+                readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+                readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
+            };
+        }>>, Schema.optionalKey<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Model.ID">;
+            readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+                opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+                anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+                openai: string & import("effect/Brand").Brand<"Provider.ID">;
+                google: string & import("effect/Brand").Brand<"Provider.ID">;
+                googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+                githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+                amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+                azure: string & import("effect/Brand").Brand<"Provider.ID">;
+                openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+                mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+                gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+            };
+            readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+        }> & {
+            parse: (input: string) => {
+                readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+                readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+                readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
+            };
+        }>, never, never>;
+        readonly request: Schema.Struct<{
+            readonly settings: Schema.withConstructorDefault<Schema.$Record<Schema.String, Schema.Any>>;
+            readonly headers: Schema.$Record<Schema.String, Schema.String>;
+            readonly body: Schema.$Record<Schema.String, Schema.Any>;
+        }>;
+        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.String>>, Schema.optionalKey<Schema.String>, 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"]>;
+        }>>;
+    }> & {
+        default: (id: Agent.ID) => {
+            id: string & import("effect/Brand").Brand<"Agent.ID">;
+            name: string & import("effect/Brand").Brand<"Agent.Name">;
+            request: {
+                settings: {};
+                headers: {};
+                body: {};
+            };
+            mode: "primary";
+            hidden: false;
+            permissions: ({
+                action: string;
+                resource: string;
+                effect: "allow";
+            } | {
+                action: string;
+                resource: string;
+                effect: "ask";
+            })[];
+        };
+    }>;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"agent.get", "GET", "/api/agent/:agentID", Schema.toCodecStringTree<Schema.Struct<{
+    agentID: Schema.brand<Schema.String, "Agent.ID">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Agent.ID">;
+        readonly name: Schema.brand<Schema.String, "Agent.Name">;
+        readonly model: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Model.ID">;
+            readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+                opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+                anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+                openai: string & import("effect/Brand").Brand<"Provider.ID">;
+                google: string & import("effect/Brand").Brand<"Provider.ID">;
+                googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+                githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+                amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+                azure: string & import("effect/Brand").Brand<"Provider.ID">;
+                openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+                mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+                gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+            };
+            readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+        }> & {
+            parse: (input: string) => {
+                readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+                readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+                readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
+            };
+        }>>, Schema.optionalKey<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Model.ID">;
+            readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+                opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+                anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+                openai: string & import("effect/Brand").Brand<"Provider.ID">;
+                google: string & import("effect/Brand").Brand<"Provider.ID">;
+                googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+                githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+                amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+                azure: string & import("effect/Brand").Brand<"Provider.ID">;
+                openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+                mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+                gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+            };
+            readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+        }> & {
+            parse: (input: string) => {
+                readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+                readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+                readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
+            };
+        }>, never, never>;
+        readonly request: Schema.Struct<{
+            readonly settings: Schema.withConstructorDefault<Schema.$Record<Schema.String, Schema.Any>>;
+            readonly headers: Schema.$Record<Schema.String, Schema.String>;
+            readonly body: Schema.$Record<Schema.String, Schema.Any>;
+        }>;
+        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.String>>, Schema.optionalKey<Schema.String>, 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"]>;
+        }>>;
+    }> & {
+        default: (id: Agent.ID) => {
+            id: string & import("effect/Brand").Brand<"Agent.ID">;
+            name: string & import("effect/Brand").Brand<"Agent.Name">;
+            request: {
+                settings: {};
+                headers: {};
+                body: {};
+            };
+            mode: "primary";
+            hidden: false;
+            permissions: ({
+                action: string;
+                resource: string;
+                effect: "allow";
+            } | {
+                action: string;
+                resource: string;
+                effect: "ask";
+            })[];
+        };
+    };
+}>>, Schema.toCodecJson<typeof AgentNotFoundError>, never, never>, false>;

package/dist/groups/agent.js

@@ -0,0 +1,30 @@
+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";
+import { AgentNotFoundError } from "../errors.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.",
+})))
+    .add(HttpApiEndpoint.get("agent.get", "/api/agent/:agentID", {
+    params: { agentID: Agent.ID },
+    query: LocationQuery,
+    success: Location.response(Agent.Info),
+    error: AgentNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.agent.get",
+    summary: "Get agent",
+    description: "Retrieve a single currently registered agent.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "agent" }));

package/dist/groups/command.d.ts

@@ -0,0 +1,63 @@
+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", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<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.brand<Schema.String, "Agent.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Agent.ID">>, never, never>;
+        readonly model: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Model.ID">;
+            readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+                opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+                anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+                openai: string & import("effect/Brand").Brand<"Provider.ID">;
+                google: string & import("effect/Brand").Brand<"Provider.ID">;
+                googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+                githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+                amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+                azure: string & import("effect/Brand").Brand<"Provider.ID">;
+                openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+                mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+                gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+            };
+            readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+        }> & {
+            parse: (input: string) => {
+                readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+                readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+                readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
+            };
+        }>>, Schema.optionalKey<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Model.ID">;
+            readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+                opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+                anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+                openai: string & import("effect/Brand").Brand<"Provider.ID">;
+                google: string & import("effect/Brand").Brand<"Provider.ID">;
+                googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+                githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+                amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+                azure: string & import("effect/Brand").Brand<"Provider.ID">;
+                openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+                mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+                gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+            };
+            readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+        }> & {
+            parse: (input: string) => {
+                readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+                readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+                readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
+            };
+        }>, never, never>;
+        readonly subtask: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }>>;
+}>>, 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: "command",
+    description: "Experimental command routes.",
+}));

package/dist/groups/config.d.ts

@@ -0,0 +1,9 @@
+import { Config } from "@opencode-ai/schema/config";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+export declare const ConfigGroup: HttpApiGroup.HttpApiGroup<"server.config", HttpApiEndpoint.HttpApiEndpoint<"config.get", "GET", "/api/config", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.$Array<Schema.Union<readonly [typeof Config.Document, typeof Config.Directory, typeof Config.AgentsDirectory, typeof Config.ClaudeDirectory]>>>, never, never, never>, false>;

package/dist/groups/config.js

@@ -0,0 +1,16 @@
+import { Config } from "@opencode-ai/schema/config";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const ConfigGroup = HttpApiGroup.make("server.config")
+    .add(HttpApiEndpoint.get("config.get", "/api/config", {
+    query: LocationQuery,
+    success: Schema.Array(Config.Entry),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.config.get",
+    summary: "Get configuration",
+    description: "Return configuration documents and discovery sources for the requested location, from lowest to highest priority.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "config", description: "Location-scoped configuration 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", 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>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+    readonly label: Schema.String;
+}>>, 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>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never>, false>;

package/dist/groups/credential.js

@@ -0,0 +1,29 @@
+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.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: "v2.credential.update",
+    summary: "Update credential",
+    description: "Update a stored credential label.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "credential" }))
+    .add(HttpApiEndpoint.delete("credential.remove", "/api/credential/:credentialID", {
+    params: { credentialID: Credential.ID },
+    query: LocationQuery,
+    success: HttpApiSchema.NoContent,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.credential.remove",
+    summary: "Remove credential",
+    description: "Remove a stored integration credential.",
+})));

package/dist/groups/debug.d.ts

@@ -0,0 +1,17 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+export declare const DebugGroup: HttpApiGroup.HttpApiGroup<"server.debug", HttpApiEndpoint.HttpApiEndpoint<"debug.location", "GET", "/api/debug/location", never, never, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+    }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+    }>, never, never>;
+}>>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"debug.location.evict", "DELETE", "/api/debug/location", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never>, false>;

package/dist/groups/debug.js

@@ -0,0 +1,23 @@
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const DebugGroup = HttpApiGroup.make("server.debug")
+    .add(HttpApiEndpoint.get("debug.location", "/api/debug/location", {
+    success: Schema.Array(Location.Ref),
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.debug.location.list",
+    summary: "List loaded locations",
+    description: "List locations currently loaded by the server.",
+})))
+    .add(HttpApiEndpoint.delete("debug.location.evict", "/api/debug/location", {
+    query: LocationQuery,
+    success: HttpApiSchema.NoContent,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.debug.location.evict",
+    summary: "Evict a loaded location",
+    description: "Dispose the requested location's cached services so its next use boots them fresh.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "debug" }));