@opencode-ai/protocol 0.0.0-next-14661

package/dist/groups/message.d.ts

@@ -0,0 +1,409 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { InvalidCursorError, SessionNotFoundError, UnknownError } from "../errors.js";
+export declare const SessionMessagesQuery: Schema.Struct<{
+    readonly limit: Schema.optional<Schema.NumberFromString>;
+    readonly order: Schema.optional<Schema.Union<readonly [Schema.Literal<"asc">, Schema.Literal<"desc">]>>;
+    readonly cursor: Schema.optional<Schema.String>;
+}>;
+export declare const MessageGroup: HttpApiGroup.HttpApiGroup<"server.message", HttpApiEndpoint.HttpApiEndpoint<"session.messages", "GET", "/api/session/:sessionID/message", HttpApiEndpoint.StringTree<Schema.Struct<{
+    sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly limit: Schema.optional<Schema.NumberFromString>;
+    readonly order: Schema.optional<Schema.Union<readonly [Schema.Literal<"asc">, Schema.Literal<"desc">]>>;
+    readonly cursor: Schema.optional<Schema.String>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly data: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"agent-switched">;
+        readonly agent: Schema.String;
+        readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        };
+        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 time: Schema.Struct<{
+            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        }>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"model-switched">;
+        readonly model: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
+            readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
+                opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                openai: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                google: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                googleVertex: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                githubCopilot: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                amazonBedrock: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                azure: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                openrouter: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            };
+            readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "VariantID">>, never, never>;
+        }>;
+        readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        };
+        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 time: Schema.Struct<{
+            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        }>;
+    }>, Schema.Struct<{
+        readonly text: Schema.String;
+        readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly uri: Schema.String;
+            readonly mime: Schema.String;
+            readonly name: 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }> & {
+            create: (input: import("@opencode-ai/schema/prompt").FileAttachment) => {
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+                readonly description?: string | undefined;
+                readonly source?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            };
+        }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly uri: Schema.String;
+            readonly mime: Schema.String;
+            readonly name: 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }> & {
+            create: (input: import("@opencode-ai/schema/prompt").FileAttachment) => {
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+                readonly description?: string | undefined;
+                readonly source?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            };
+        }>>, never, never>;
+        readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }>>>, never, never>;
+        readonly type: Schema.Literal<"user">;
+        readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        };
+        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 time: Schema.Struct<{
+            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        }>;
+    }>, 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 text: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly type: Schema.Literal<"synthetic">;
+        readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        };
+        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 time: Schema.Struct<{
+            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        }>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"system">;
+        readonly text: Schema.String;
+        readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        };
+        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 time: Schema.Struct<{
+            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        }>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"skill">;
+        readonly name: Schema.String;
+        readonly text: Schema.String;
+        readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        };
+        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 time: Schema.Struct<{
+            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        }>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"shell">;
+        readonly callID: Schema.String;
+        readonly command: Schema.String;
+        readonly output: Schema.String;
+        readonly time: Schema.Struct<{
+            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+            readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
+        }>;
+        readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        };
+        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<"assistant">;
+        readonly agent: Schema.String;
+        readonly model: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
+            readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
+                opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                openai: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                google: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                googleVertex: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                githubCopilot: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                amazonBedrock: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                azure: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                openrouter: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+                gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            };
+            readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "VariantID">>, never, never>;
+        }>;
+        readonly content: Schema.$Array<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly id: Schema.String;
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"reasoning">;
+            readonly id: Schema.String;
+            readonly text: Schema.String;
+            readonly providerMetadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
+            readonly time: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+                readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+                readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
+            }>>, never, never>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"tool">;
+            readonly id: Schema.String;
+            readonly name: Schema.String;
+            readonly provider: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly executed: Schema.Boolean;
+                readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
+                readonly resultMetadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly executed: Schema.Boolean;
+                readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
+                readonly resultMetadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
+            }>>, never, never>;
+            readonly state: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
+                readonly status: Schema.Literal<"pending">;
+                readonly input: Schema.String;
+            }>, Schema.Struct<{
+                readonly status: Schema.Literal<"running">;
+                readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
+                readonly structured: Schema.$Record<Schema.String, Schema.Unknown>;
+                readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly type: Schema.Literal<"text">;
+                    readonly text: Schema.String;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"file">;
+                    readonly uri: Schema.String;
+                    readonly mime: Schema.String;
+                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                }>]>>;
+            }>, Schema.Struct<{
+                readonly status: Schema.Literal<"completed">;
+                readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
+                readonly attachments: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+                    readonly uri: Schema.String;
+                    readonly mime: Schema.String;
+                    readonly name: 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                        readonly start: Schema.Finite;
+                        readonly end: Schema.Finite;
+                        readonly text: Schema.String;
+                    }>>>, Schema.optionalKey<Schema.Struct<{
+                        readonly start: Schema.Finite;
+                        readonly end: Schema.Finite;
+                        readonly text: Schema.String;
+                    }>>, never, never>;
+                }> & {
+                    create: (input: import("@opencode-ai/schema/prompt").FileAttachment) => {
+                        readonly uri: string;
+                        readonly mime: string;
+                        readonly name?: string | undefined;
+                        readonly description?: string | undefined;
+                        readonly source?: {
+                            readonly start: number;
+                            readonly end: number;
+                            readonly text: string;
+                        } | undefined;
+                    };
+                }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                    readonly uri: Schema.String;
+                    readonly mime: Schema.String;
+                    readonly name: 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                        readonly start: Schema.Finite;
+                        readonly end: Schema.Finite;
+                        readonly text: Schema.String;
+                    }>>>, Schema.optionalKey<Schema.Struct<{
+                        readonly start: Schema.Finite;
+                        readonly end: Schema.Finite;
+                        readonly text: Schema.String;
+                    }>>, never, never>;
+                }> & {
+                    create: (input: import("@opencode-ai/schema/prompt").FileAttachment) => {
+                        readonly uri: string;
+                        readonly mime: string;
+                        readonly name?: string | undefined;
+                        readonly description?: string | undefined;
+                        readonly source?: {
+                            readonly start: number;
+                            readonly end: number;
+                            readonly text: string;
+                        } | undefined;
+                    };
+                }>>, never, never>;
+                readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly type: Schema.Literal<"text">;
+                    readonly text: Schema.String;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"file">;
+                    readonly uri: Schema.String;
+                    readonly mime: Schema.String;
+                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                }>]>>;
+                readonly outputPaths: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                readonly structured: Schema.$Record<Schema.String, Schema.Unknown>;
+                readonly result: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Unknown>>, Schema.optionalKey<Schema.Unknown>, never, never>;
+            }>, Schema.Struct<{
+                readonly status: Schema.Literal<"error">;
+                readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
+                readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly type: Schema.Literal<"text">;
+                    readonly text: Schema.String;
+                }>, Schema.Struct<{
+                    readonly type: Schema.Literal<"file">;
+                    readonly uri: Schema.String;
+                    readonly mime: Schema.String;
+                    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                }>]>>;
+                readonly structured: Schema.$Record<Schema.String, Schema.Unknown>;
+                readonly error: Schema.Struct<{
+                    readonly type: Schema.Literal<"unknown">;
+                    readonly message: Schema.String;
+                }>;
+                readonly result: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Unknown>>, Schema.optionalKey<Schema.Unknown>, never, never>;
+            }>]>;
+            readonly time: Schema.Struct<{
+                readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+                readonly ran: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
+                readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
+                readonly pruned: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
+            }>;
+        }>]>>;
+        readonly snapshot: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly end: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.brand<Schema.String, "RelativePath">>>>, Schema.optionalKey<Schema.$Array<Schema.brand<Schema.String, "RelativePath">>>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly end: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.brand<Schema.String, "RelativePath">>>>, Schema.optionalKey<Schema.$Array<Schema.brand<Schema.String, "RelativePath">>>, never, never>;
+        }>>, never, never>;
+        readonly finish: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly input: Schema.Finite;
+            readonly output: Schema.Finite;
+            readonly reasoning: Schema.Finite;
+            readonly cache: Schema.Struct<{
+                readonly read: Schema.Finite;
+                readonly write: Schema.Finite;
+            }>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly input: Schema.Finite;
+            readonly output: Schema.Finite;
+            readonly reasoning: Schema.Finite;
+            readonly cache: Schema.Struct<{
+                readonly read: Schema.Finite;
+                readonly write: Schema.Finite;
+            }>;
+        }>>, never, never>;
+        readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly type: Schema.Literal<"unknown">;
+            readonly message: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly type: Schema.Literal<"unknown">;
+            readonly message: Schema.String;
+        }>>, never, never>;
+        readonly time: Schema.Struct<{
+            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+            readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
+        }>;
+        readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        };
+        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 id: Schema.brand<Schema.String, "Session.Message.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        };
+        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 time: Schema.Struct<{
+            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        }>;
+        readonly type: Schema.Literal<"compaction">;
+        readonly reason: Schema.Literals<readonly ["auto", "manual"]>;
+        readonly summary: Schema.String;
+        readonly recent: Schema.String;
+    }>]>>;
+    readonly cursor: Schema.Struct<{
+        readonly previous: Schema.optional<Schema.String>;
+        readonly next: Schema.optional<Schema.String>;
+    }>;
+}>>, HttpApiEndpoint.Json<typeof UnknownError | typeof SessionNotFoundError | typeof InvalidCursorError>, never, never>, false>;

package/dist/groups/message.js

@@ -0,0 +1,37 @@
+import { Session } from "@opencode-ai/schema/session";
+import { SessionMessage } from "@opencode-ai/schema/session-message";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { InvalidCursorError, SessionNotFoundError, UnknownError } from "../errors.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.",
+    })),
+}).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.Message),
+        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.session.messages",
+    summary: "Get session messages",
+    description: "Retrieve projected messages for a session. Items keep the requested order across pages; use cursor.next or cursor.previous to move through the ordered timeline.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "messages",
+    description: "Experimental message routes.",
+}));

package/dist/groups/model.d.ts

@@ -0,0 +1,151 @@
+import { Model } from "@opencode-ai/schema/model";
+import { Location } from "@opencode-ai/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", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
+        readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
+            opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            openai: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            google: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            googleVertex: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            githubCopilot: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            amazonBedrock: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            azure: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            openrouter: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+        };
+        readonly family: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Family">>>, Schema.optionalKey<Schema.brand<Schema.String, "Family">>, never, never>;
+        readonly name: Schema.String;
+        readonly api: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"aisdk">;
+            readonly package: Schema.String;
+            readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+            readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+            readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly settings: Schema.$Record<Schema.String, Schema.Unknown>;
+            readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
+        }>]>;
+        readonly capabilities: Schema.Struct<{
+            readonly tools: Schema.Boolean;
+            readonly input: Schema.$Array<Schema.String>;
+            readonly output: Schema.$Array<Schema.String>;
+        }>;
+        readonly request: Schema.Struct<{
+            readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly headers: Schema.$Record<Schema.String, Schema.String>;
+            readonly body: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>;
+        readonly variants: Schema.$Array<Schema.Struct<{
+            readonly headers: Schema.$Record<Schema.String, Schema.String>;
+            readonly body: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly id: Schema.brand<Schema.String, "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.Literal<"context">;
+                readonly size: Schema.Int;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly type: Schema.Literal<"context">;
+                readonly size: Schema.Int;
+            }>>, never, never>;
+            readonly input: Schema.Finite;
+            readonly output: Schema.Finite;
+            readonly cache: Schema.Struct<{
+                readonly read: Schema.Finite;
+                readonly write: Schema.Finite;
+            }>;
+        }>>;
+        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;
+        }>;
+    }> & {
+        empty: (providerID: import("@opencode-ai/schema/provider").ID, modelID: Model.ID) => {
+            readonly id: string & import("effect/Brand").Brand<"ModelV2.ID">;
+            readonly providerID: string & import("effect/Brand").Brand<"ProviderV2.ID">;
+            readonly name: string;
+            readonly api: {
+                readonly type: "aisdk";
+                readonly package: string;
+                readonly id: string & import("effect/Brand").Brand<"ModelV2.ID">;
+                readonly url?: string | undefined;
+                readonly settings?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "native";
+                readonly settings: {
+                    readonly [x: string]: unknown;
+                };
+                readonly id: string & import("effect/Brand").Brand<"ModelV2.ID">;
+                readonly url?: string | undefined;
+            };
+            readonly capabilities: {
+                readonly tools: boolean;
+                readonly input: readonly string[];
+                readonly output: readonly string[];
+            };
+            readonly request: {
+                readonly headers: {
+                    readonly [x: string]: string;
+                };
+                readonly body: {
+                    readonly [x: string]: Schema.Json;
+                };
+                readonly variant?: string | undefined;
+            };
+            readonly variants: readonly {
+                readonly headers: {
+                    readonly [x: string]: string;
+                };
+                readonly body: {
+                    readonly [x: string]: Schema.Json;
+                };
+                readonly id: string & import("effect/Brand").Brand<"VariantID">;
+            }[];
+            readonly time: {
+                readonly released: number;
+            };
+            readonly cost: readonly {
+                readonly input: number;
+                readonly output: number;
+                readonly cache: {
+                    readonly read: number;
+                    readonly write: number;
+                };
+                readonly tier?: {
+                    readonly type: "context";
+                    readonly size: number;
+                } | undefined;
+            }[];
+            readonly status: "alpha" | "beta" | "deprecated" | "active";
+            readonly enabled: boolean;
+            readonly limit: {
+                readonly context: number;
+                readonly output: number;
+                readonly input?: number | undefined;
+            };
+            readonly family?: (string & import("effect/Brand").Brand<"Family">) | undefined;
+        };
+    }>;
+}>>, HttpApiEndpoint.Json<typeof ServiceUnavailableError>, never, never>, false>;

package/dist/groups/model.js

@@ -0,0 +1,22 @@
+import { Model } from "@opencode-ai/schema/model";
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { ServiceUnavailableError } from "../errors.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 available models ordered by release date.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "models",
+    description: "Experimental model routes.",
+}));