@kilocode/protocol 0.0.0-stage → 0.0.0-v2-9

package/dist/groups/agent.d.ts

@@ -0,0 +1,225 @@
+import { Agent } from "@opencode/schema/agent";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
+import { AgentNotFoundError } from "../errors.js";
+export declare const AgentGroup: HttpApiGroup.HttpApiGroup<"server.agent", 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>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    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.StructWithRest<Schema.Struct<{
+                readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+                readonly headerTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+                readonly chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+                readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+                    readonly type: Schema.Literal<"summary">;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"native">;
+                }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                    readonly type: Schema.Literal<"summary">;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"native">;
+                }>]>>, never, never>;
+                readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
+                readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+            }>, readonly [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> | HttpApiEndpoint.HttpApiEndpoint<"agent.list", "GET", "/api/agent", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    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.StructWithRest<Schema.Struct<{
+                readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+                readonly headerTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+                readonly chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+                readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+                    readonly type: Schema.Literal<"summary">;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"native">;
+                }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                    readonly type: Schema.Literal<"summary">;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"native">;
+                }>]>>, never, never>;
+                readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
+                readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
+            }>, readonly [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>, false>;

package/dist/groups/agent.js

@@ -0,0 +1,30 @@
+import { Agent } from "@opencode/schema/agent";
+import { Location } from "@opencode/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
+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: "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: "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,15 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
+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>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    readonly data: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>;
+}>>, never, never, never>, false>;

package/dist/groups/command.js

@@ -0,0 +1,20 @@
+import { Command } from "@opencode/schema/command";
+import { Location } from "@opencode/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
+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: "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,14 @@
+import { Config } from "@opencode/schema/config";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
+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>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.$Array<Schema.Union<readonly [typeof Config.Document, typeof Config.Directory]>>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"config.shells", "GET", "/api/config/shell", never, never, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
+    readonly path: Schema.String;
+    readonly name: Schema.String;
+    readonly acceptable: Schema.Boolean;
+}>>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"config.update", "PATCH", "/api/experimental/config", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly shell: Schema.NullOr<Schema.String>;
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never>, false>;

package/dist/groups/config.js

@@ -0,0 +1,32 @@
+import { Config } from "@opencode/schema/config";
+import { ConfigShell } from "@opencode/schema/config/shell";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+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: "config.get",
+    summary: "Get configuration",
+    description: "Return configuration documents and discovery sources for the requested location, from lowest to highest priority.",
+})))
+    .add(HttpApiEndpoint.get("config.shells", "/api/config/shell", {
+    success: Schema.Array(ConfigShell.Option),
+}).annotateMerge(OpenApi.annotations({
+    identifier: "config.shells",
+    summary: "List available shells",
+    description: "Return shells available to terminal and agent execution.",
+})))
+    .add(HttpApiEndpoint.patch("config.update", "/api/experimental/config", {
+    payload: Config.Patch,
+    success: HttpApiSchema.NoContent,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "experimental.config.update",
+    summary: "Update global configuration",
+    description: "Patch supported fields in the highest-precedence global configuration document.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "config", description: "Location-scoped configuration routes." }));

package/dist/groups/credential.d.ts

@@ -0,0 +1,93 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
+import { ConflictError } from "../errors.js";
+export declare const CredentialGroup: HttpApiGroup.HttpApiGroup<"server.credential", 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">;
+    };
+}>>, never, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"credential.create", "POST", "/api/credential", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly id: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Credential.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+    }>>, Schema.optionalKey<Schema.brand<Schema.String, "Credential.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+    }>, never, never>;
+    readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
+    readonly label: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly value: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"oauth">;
+        readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+        readonly refresh: Schema.String;
+        readonly access: Schema.String;
+        readonly expires: Schema.Int;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"key">;
+        readonly key: Schema.String;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"external">;
+        readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    }>]>;
+    readonly activate: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly data: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Credential.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+        };
+        readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
+        readonly label: Schema.String;
+        readonly active: Schema.Boolean;
+        readonly value: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"oauth">;
+            readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+            readonly refresh: Schema.String;
+            readonly access: Schema.String;
+            readonly expires: Schema.Int;
+            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"key">;
+            readonly key: Schema.String;
+            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"external">;
+            readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        }>]>;
+    }>;
+}>>, Schema.toCodecJson<typeof ConflictError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"credential.list", "GET", "/api/credential", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly data: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Credential.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+        };
+        readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
+        readonly label: Schema.String;
+        readonly active: Schema.Boolean;
+        readonly value: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"oauth">;
+            readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+            readonly refresh: Schema.String;
+            readonly access: Schema.String;
+            readonly expires: Schema.Int;
+            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"key">;
+            readonly key: Schema.String;
+            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"external">;
+            readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        }>]>;
+    }>>;
+}>>, 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">;
+    };
+}>>, never, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never> | 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">;
+    };
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly label: Schema.String;
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never>, false>;

package/dist/groups/credential.js

@@ -0,0 +1,50 @@
+import { Credential } from "@opencode/schema/credential";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+import { ConflictError } from "../errors.js";
+export const CredentialGroup = HttpApiGroup.make("server.credential")
+    .add(HttpApiEndpoint.get("credential.list", "/api/credential", {
+    success: Schema.Struct({ data: Schema.Array(Credential.Entry) }),
+}).annotateMerge(OpenApi.annotations({
+    identifier: "credential.list",
+    summary: "List credentials",
+    description: "List every stored integration credential, including its secret value.",
+})))
+    .add(HttpApiEndpoint.post("credential.create", "/api/credential", {
+    payload: Credential.CreateInput,
+    success: Schema.Struct({ data: Credential.Entry }),
+    error: ConflictError,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "credential.create",
+    summary: "Create credential",
+    description: "Store an integration credential. It becomes the integration's active credential unless activate is false and the integration already has one. Fails with a conflict when the requested ID already exists.",
+})))
+    .add(HttpApiEndpoint.patch("credential.update", "/api/credential/:credentialID", {
+    params: { credentialID: Credential.ID },
+    payload: Schema.Struct({ label: Schema.String }),
+    success: HttpApiSchema.NoContent,
+})
+    .annotateMerge(OpenApi.annotations({
+    identifier: "credential.update",
+    summary: "Update credential",
+    description: "Update a stored credential label.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "credential" }))
+    .add(HttpApiEndpoint.post("credential.activate", "/api/credential/:credentialID/activate", {
+    params: { credentialID: Credential.ID },
+    success: HttpApiSchema.NoContent,
+})
+    .annotateMerge(OpenApi.annotations({
+    identifier: "credential.activate",
+    summary: "Activate credential",
+    description: "Activate a stored integration credential.",
+})))
+    .add(HttpApiEndpoint.delete("credential.remove", "/api/credential/:credentialID", {
+    params: { credentialID: Credential.ID },
+    success: HttpApiSchema.NoContent,
+})
+    .annotateMerge(OpenApi.annotations({
+    identifier: "credential.remove",
+    summary: "Remove credential",
+    description: "Remove a stored integration credential.",
+})));

package/dist/groups/debug.d.ts

@@ -0,0 +1,22 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
+import { InvalidRequestError, UnknownError } from "../errors.js";
+export declare const DebugGroup: HttpApiGroup.HttpApiGroup<"server.debug", HttpApiEndpoint.HttpApiEndpoint<"debug.heapDump", "POST", "/api/debug/heap-dump", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly directory: Schema.optional<Schema.String>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly path: Schema.String;
+    readonly pid: Schema.Int;
+    readonly memory: Schema.Struct<{
+        readonly rss: Schema.Number;
+        readonly heapTotal: Schema.Number;
+        readonly heapUsed: Schema.Number;
+        readonly external: Schema.Number;
+        readonly arrayBuffers: Schema.Number;
+    }>;
+}>>, Schema.toCodecJson<typeof InvalidRequestError | typeof UnknownError>, never, never> | 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">;
+}>>>, 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>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never>, false>;

package/dist/groups/debug.js

@@ -0,0 +1,49 @@
+import { Location } from "@opencode/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+import { InvalidRequestError, UnknownError } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const DebugGroup = HttpApiGroup.make("server.debug")
+    .add(HttpApiEndpoint.post("debug.heapDump", "/api/debug/heap-dump", {
+    query: Schema.Struct({
+        directory: Schema.String.pipe(Schema.optional, Schema.annotate({
+            description: "Absolute server-local directory to write the snapshot into, created when missing. Defaults to the server's log directory.",
+        })),
+    }),
+    success: Schema.Struct({
+        path: Schema.String,
+        pid: Schema.Int,
+        memory: Schema.Struct({
+            rss: Schema.Number,
+            heapTotal: Schema.Number,
+            heapUsed: Schema.Number,
+            external: Schema.Number,
+            arrayBuffers: Schema.Number,
+        }).annotate({
+            description: "The server process's memory in bytes, read just before the snapshot (Node's process.memoryUsage()). rss covers native memory the snapshot cannot show.",
+        }),
+    }),
+    error: [InvalidRequestError, UnknownError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "debug.heapDump",
+    summary: "Write a heap snapshot",
+    description: "Write a JavaScript heap snapshot of the server process into its log directory, or the requested directory, and return the server-local path once the file is complete. Pauses the server while the heap serializes and can temporarily increase its memory use. The snapshot can contain credentials, prompts, and file contents.",
+})))
+    .add(HttpApiEndpoint.get("debug.location", "/api/debug/location", {
+    success: Schema.Array(Location.PublicRef),
+}).annotateMerge(OpenApi.annotations({
+    identifier: "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: "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" }));