@opencode/protocol 0.0.0-reserved → 2.0.0

package/dist/groups/message.js

@@ -0,0 +1,51 @@
+import { Session } from "@opencode/schema/session";
+import { SessionMessage } from "@opencode/schema/session-message";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { InvalidCursorError, SessionNotFoundError, UnknownError } from "../errors.js";
+export const SessionMessagesQuery = Schema.Struct({
+    limit: Schema.optional(Schema.NumberFromString.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(200))).annotate({
+        description: "Maximum number of messages to return. When omitted, the endpoint returns its default page size.",
+    }),
+    order: Schema.optional(Schema.Union([Schema.Literal("asc"), Schema.Literal("desc")])).annotate({
+        description: "Message order for the first page. Use desc for newest first or asc for oldest first.",
+    }),
+    cursor: Schema.optional(Schema.String.annotate({
+        description: "Opaque pagination cursor returned as cursor.previous or cursor.next in the previous response. Do not combine with order.",
+    })),
+    type: Schema.optional(Schema.Literals([
+        "agent-switched",
+        "model-switched",
+        "location-switched",
+        "user",
+        "synthetic",
+        "system",
+        "skill",
+        "shell",
+        "assistant",
+        "compaction",
+    ])).annotate({
+        description: "Filter by message type before pagination. When omitted, all message types are returned. Pass the same type when following cursors.",
+    }),
+}).annotate({ identifier: "SessionMessagesQuery" });
+export const MessageGroup = HttpApiGroup.make("server.message")
+    .add(HttpApiEndpoint.get("session.messages", "/api/session/:sessionID/message", {
+    params: { sessionID: Session.ID },
+    query: SessionMessagesQuery,
+    success: Schema.Struct({
+        data: Schema.Array(SessionMessage.Info),
+        cursor: Schema.Struct({
+            previous: Schema.String.pipe(Schema.optional),
+            next: Schema.String.pipe(Schema.optional),
+        }),
+    }).annotate({ identifier: "SessionMessagesResponse" }),
+    error: [InvalidCursorError, SessionNotFoundError, UnknownError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.message.list",
+    summary: "Get session messages",
+    description: "Retrieve projected messages for a session, optionally filtered by type. Items keep the requested order across pages; use cursor.next or cursor.previous to move through the ordered timeline, passing the same type filter on each page.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "session",
+    description: "Experimental message routes.",
+}));

package/dist/groups/migration.d.ts

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+export declare const V1MigrationStatus: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["required", "completed"]>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"running">;
+    readonly progress: Schema.Struct<{
+        readonly label: Schema.String;
+        readonly numerator: Schema.optional<Schema.Int>;
+        readonly denominator: Schema.optional<Schema.Int>;
+    }>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"error">;
+    readonly error: Schema.String;
+}>]>;
+export declare const MigrationGroup: HttpApiGroup.HttpApiGroup<"server.migration", HttpApiEndpoint.HttpApiEndpoint<"migration.v1.status", "GET", "/api/experimental/migration/v1", never, never, never, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["required", "completed"]>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"running">;
+    readonly progress: Schema.Struct<{
+        readonly label: Schema.String;
+        readonly numerator: Schema.optional<Schema.Int>;
+        readonly denominator: Schema.optional<Schema.Int>;
+    }>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"error">;
+    readonly error: Schema.String;
+}>]>>, never, never, never>, false>;

package/dist/groups/migration.js

@@ -0,0 +1,21 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+const V1MigrationProgress = Schema.Struct({
+    label: Schema.String,
+    numerator: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
+    denominator: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
+});
+export const V1MigrationStatus = Schema.Union([
+    Schema.Struct({ status: Schema.Literals(["required", "completed"]) }),
+    Schema.Struct({ status: Schema.Literal("running"), progress: V1MigrationProgress }),
+    Schema.Struct({ status: Schema.Literal("error"), error: Schema.String }),
+]);
+export const MigrationGroup = HttpApiGroup.make("server.migration")
+    .add(HttpApiEndpoint.get("migration.v1.status", "/api/experimental/migration/v1", {
+    success: V1MigrationStatus,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.experimental.migration.v1.status",
+    summary: "Get V1 migration status",
+    description: "Return the progress of the V1 to V2 session history migration.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "migration" }));

package/dist/groups/model.d.ts

@@ -0,0 +1,314 @@
+import { Model } from "@opencode/schema/model";
+import { Location } from "@opencode/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { ServiceUnavailableError } from "../errors.js";
+export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpApiEndpoint.HttpApiEndpoint<"model.list", "GET", "/api/model", 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 capabilities: Schema.Struct<{
+            readonly tools: Schema.Boolean;
+            readonly input: Schema.$Array<Schema.String>;
+            readonly output: Schema.$Array<Schema.String>;
+            readonly responsesWebsockets: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        }> & {
+            default: () => {
+                tools: true;
+                input: string[];
+                output: string[];
+            };
+        };
+        readonly variants: Schema.$Array<Schema.Struct<{
+            readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+            readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+            readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+            readonly id: Schema.brand<Schema.String, "Model.VariantID">;
+        }>>;
+        readonly time: Schema.Struct<{
+            readonly released: Schema.Finite;
+        }>;
+        readonly cost: Schema.$Array<Schema.Struct<{
+            readonly tier: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly type: Schema.tag<"context">;
+                readonly size: Schema.Int;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly type: Schema.tag<"context">;
+                readonly size: Schema.Int;
+            }>>, never, never>;
+            readonly input: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+            };
+            readonly output: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+            };
+            readonly cache: Schema.Struct<{
+                readonly read: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                    zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+                };
+                readonly write: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                    zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+                };
+            }>;
+        }>>;
+        readonly status: Schema.Literals<readonly ["alpha", "beta", "deprecated", "active"]>;
+        readonly enabled: Schema.Boolean;
+        readonly limit: Schema.Struct<{
+            readonly context: Schema.Int;
+            readonly input: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly output: Schema.Int;
+        }>;
+        readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+        readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+        readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+        readonly id: Schema.brand<Schema.String, "Model.ID">;
+        readonly modelID: 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 canonical: Schema.decodeTo<Schema.optional<Schema.toType<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">;
+        }>>, Schema.optionalKey<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">;
+        }>, never, never>;
+        readonly family: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.Family">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.Family">>, never, never>;
+        readonly name: Schema.String;
+        readonly compatibility: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<Model.ReasoningField, Model.ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<Model.ReasoningField, Model.ReasoningField, never, never>>, never, never>;
+            readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+            readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<Model.ReasoningField, Model.ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<Model.ReasoningField, Model.ReasoningField, never, never>>, never, never>;
+            readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+            readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        }>>, never, never>;
+        readonly package: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly mode: Schema.Literal<"local">;
+        }>, Schema.Struct<{
+            readonly mode: Schema.Literal<"provider">;
+            readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly mode: Schema.Literal<"local">;
+        }>, Schema.Struct<{
+            readonly mode: Schema.Literal<"provider">;
+            readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        }>]>>, never, never>;
+        readonly websocket: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }> & {
+        default: (providerID: import("@opencode/schema/provider").ID, id: Model.ID) => {
+            id: string & import("effect/Brand").Brand<"Model.ID">;
+            modelID: string & import("effect/Brand").Brand<"Model.ID">;
+            providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+            name: string & import("effect/Brand").Brand<"Model.ID">;
+            capabilities: {
+                tools: true;
+                input: string[];
+                output: string[];
+            };
+            variants: never[];
+            time: {
+                released: number;
+            };
+            cost: never[];
+            status: "active";
+            enabled: true;
+            limit: {
+                context: number;
+                output: number;
+            };
+        };
+    }>;
+}>>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"model.default", "GET", "/api/model/default", 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.UndefinedOr<Schema.Struct<{
+        readonly capabilities: Schema.Struct<{
+            readonly tools: Schema.Boolean;
+            readonly input: Schema.$Array<Schema.String>;
+            readonly output: Schema.$Array<Schema.String>;
+            readonly responsesWebsockets: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        }> & {
+            default: () => {
+                tools: true;
+                input: string[];
+                output: string[];
+            };
+        };
+        readonly variants: Schema.$Array<Schema.Struct<{
+            readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+            readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+            readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+            readonly id: Schema.brand<Schema.String, "Model.VariantID">;
+        }>>;
+        readonly time: Schema.Struct<{
+            readonly released: Schema.Finite;
+        }>;
+        readonly cost: Schema.$Array<Schema.Struct<{
+            readonly tier: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly type: Schema.tag<"context">;
+                readonly size: Schema.Int;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly type: Schema.tag<"context">;
+                readonly size: Schema.Int;
+            }>>, never, never>;
+            readonly input: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+            };
+            readonly output: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+            };
+            readonly cache: Schema.Struct<{
+                readonly read: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                    zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+                };
+                readonly write: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                    zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+                };
+            }>;
+        }>>;
+        readonly status: Schema.Literals<readonly ["alpha", "beta", "deprecated", "active"]>;
+        readonly enabled: Schema.Boolean;
+        readonly limit: Schema.Struct<{
+            readonly context: Schema.Int;
+            readonly input: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly output: Schema.Int;
+        }>;
+        readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+        readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+        readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+        readonly id: Schema.brand<Schema.String, "Model.ID">;
+        readonly modelID: 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 canonical: Schema.decodeTo<Schema.optional<Schema.toType<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">;
+        }>>, Schema.optionalKey<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">;
+        }>, never, never>;
+        readonly family: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.Family">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.Family">>, never, never>;
+        readonly name: Schema.String;
+        readonly compatibility: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<Model.ReasoningField, Model.ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<Model.ReasoningField, Model.ReasoningField, never, never>>, never, never>;
+            readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+            readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<Model.ReasoningField, Model.ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<Model.ReasoningField, Model.ReasoningField, never, never>>, never, never>;
+            readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+            readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        }>>, never, never>;
+        readonly package: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly mode: Schema.Literal<"local">;
+        }>, Schema.Struct<{
+            readonly mode: Schema.Literal<"provider">;
+            readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly mode: Schema.Literal<"local">;
+        }>, Schema.Struct<{
+            readonly mode: Schema.Literal<"provider">;
+            readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        }>]>>, never, never>;
+        readonly websocket: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }> & {
+        default: (providerID: import("@opencode/schema/provider").ID, id: Model.ID) => {
+            id: string & import("effect/Brand").Brand<"Model.ID">;
+            modelID: string & import("effect/Brand").Brand<"Model.ID">;
+            providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+            name: string & import("effect/Brand").Brand<"Model.ID">;
+            capabilities: {
+                tools: true;
+                input: string[];
+                output: string[];
+            };
+            variants: never[];
+            time: {
+                released: number;
+            };
+            cost: never[];
+            status: "active";
+            enabled: true;
+            limit: {
+                context: number;
+                output: number;
+            };
+        };
+    }>;
+}>>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never>, false>;

package/dist/groups/model.js

@@ -0,0 +1,33 @@
+import { Model } from "@opencode/schema/model";
+import { Location } from "@opencode/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { ServiceUnavailableError } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const ModelGroup = HttpApiGroup.make("server.model")
+    .add(HttpApiEndpoint.get("model.list", "/api/model", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Model.Info)),
+    error: ServiceUnavailableError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.model.list",
+    summary: "List models",
+    description: "Retrieve the current snapshot of available models ordered by release date. The snapshot may precede initial plugin settlement.",
+})))
+    .add(HttpApiEndpoint.get("model.default", "/api/model/default", {
+    query: LocationQuery,
+    success: Location.response(Schema.UndefinedOr(Model.Info)),
+    error: ServiceUnavailableError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.model.default",
+    summary: "Get default model",
+    description: "Retrieve the model used when a session has no explicit model selection.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "model",
+    description: "Experimental model routes.",
+}));

package/dist/groups/permission.d.ts

@@ -0,0 +1,167 @@
+import { Location } from "@opencode/schema/location";
+import { Context, Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/unstable/httpapi";
+import { PermissionNotFoundError, SessionNotFoundError } from "../errors.js";
+export declare const makePermissionGroup: <LocationId extends HttpApiMiddleware.AnyId, LocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService>(locationMiddleware: Context.Key<LocationId, LocationService>, sessionLocationMiddleware: Context.Key<SessionLocationId, SessionLocationService>) => HttpApiGroup.HttpApiGroup<"server.permission", HttpApiEndpoint.HttpApiEndpoint<"permission.request.list", "GET", "/api/permission/request", 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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly action: Schema.String;
+        readonly resources: Schema.$Array<Schema.String>;
+        readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+        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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"tool">;
+            readonly messageID: Schema.String;
+            readonly id: Schema.String;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"tool">;
+            readonly messageID: Schema.String;
+            readonly id: Schema.String;
+        }>]>>, never, never>;
+        readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
+            create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+        };
+    }>>;
+}>>, never, LocationId, HttpApiMiddleware.Requires<LocationId>> | HttpApiEndpoint.HttpApiEndpoint<"permission.saved.list", "GET", "/api/permission/saved", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly projectID: Schema.optional<Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    }>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly data: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "PermissionSaved.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"PermissionSaved.ID">;
+        };
+        readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+            global: string & import("effect/Brand").Brand<"Project.ID">;
+        };
+        readonly action: Schema.String;
+        readonly resource: Schema.String;
+    }>>;
+}>>, never, LocationId, HttpApiMiddleware.Requires<LocationId>> | HttpApiEndpoint.HttpApiEndpoint<"permission.saved.remove", "DELETE", "/api/permission/saved/:id", Schema.toCodecStringTree<Schema.Struct<{
+    id: Schema.brand<Schema.String, "PermissionSaved.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"PermissionSaved.ID">;
+    };
+}>>, never, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, LocationId, HttpApiMiddleware.Requires<LocationId>> | HttpApiEndpoint.HttpApiEndpoint<"session.permission.create", "POST", "/api/session/:sessionID/permission", Schema.toCodecStringTree<Schema.Struct<{
+    sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly id: Schema.optional<Schema.brand<Schema.String, "Permission.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+    }>;
+    readonly action: Schema.String;
+    readonly resources: Schema.$Array<Schema.String>;
+    readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"tool">;
+        readonly messageID: Schema.String;
+        readonly id: Schema.String;
+    }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"tool">;
+        readonly messageID: Schema.String;
+        readonly id: Schema.String;
+    }>]>>, never, never>;
+    readonly agent: Schema.optional<Schema.brand<Schema.String, "Agent.ID">>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly data: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
+            create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+        };
+        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    }>;
+}>>, Schema.toCodecJson<typeof SessionNotFoundError>, SessionLocationId, HttpApiMiddleware.Requires<SessionLocationId>> | HttpApiEndpoint.HttpApiEndpoint<"session.permission.list", "GET", "/api/session/:sessionID/permission", Schema.toCodecStringTree<Schema.Struct<{
+    sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly data: Schema.$Array<Schema.Struct<{
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly action: Schema.String;
+        readonly resources: Schema.$Array<Schema.String>;
+        readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+        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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"tool">;
+            readonly messageID: Schema.String;
+            readonly id: Schema.String;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"tool">;
+            readonly messageID: Schema.String;
+            readonly id: Schema.String;
+        }>]>>, never, never>;
+        readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
+            create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+        };
+    }>>;
+}>>, Schema.toCodecJson<typeof SessionNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.permission.get", "GET", "/api/session/:sessionID/permission/:requestID", Schema.toCodecStringTree<Schema.Struct<{
+    sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    requestID: Schema.brand<Schema.String, "Permission.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+    };
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly data: Schema.Struct<{
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly action: Schema.String;
+        readonly resources: Schema.$Array<Schema.String>;
+        readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+        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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"tool">;
+            readonly messageID: Schema.String;
+            readonly id: Schema.String;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"tool">;
+            readonly messageID: Schema.String;
+            readonly id: Schema.String;
+        }>]>>, never, never>;
+        readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
+            create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+        };
+    }>;
+}>>, Schema.toCodecJson<typeof SessionNotFoundError | typeof PermissionNotFoundError>, SessionLocationId, HttpApiMiddleware.Requires<SessionLocationId>> | HttpApiEndpoint.HttpApiEndpoint<"session.permission.reply", "POST", "/api/session/:sessionID/permission/:requestID/reply", Schema.toCodecStringTree<Schema.Struct<{
+    sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    requestID: Schema.brand<Schema.String, "Permission.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
+    };
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+    readonly message: Schema.optional<Schema.String>;
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionNotFoundError | typeof PermissionNotFoundError>, SessionLocationId, HttpApiMiddleware.Requires<SessionLocationId>> | HttpApiEndpoint.HttpApiEndpoint<"session.permission.rules", "PUT", "/api/session/:sessionID/permission/rules", Schema.toCodecStringTree<Schema.Struct<{
+    sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly permissions: Schema.$Array<Schema.Struct<{
+        readonly action: Schema.String;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    }>>;
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionNotFoundError>, SessionLocationId, HttpApiMiddleware.Requires<SessionLocationId>>, false>;