@opencode-ai/schema 0.0.0-next-14659

package/dist/session-message.d.ts

@@ -0,0 +1,1318 @@
+export * as SessionMessage from "./session-message.js";
+import { Schema } from "effect";
+import { FileAttachment } from "./prompt.js";
+export declare const ID: Schema.brand<Schema.String, "Session.Message.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+};
+export type ID = typeof ID.Type;
+export interface UnknownError extends Schema.Schema.Type<typeof UnknownError> {
+}
+export declare const UnknownError: Schema.Struct<{
+    readonly type: Schema.Literal<"unknown">;
+    readonly message: Schema.String;
+}>;
+export interface AgentSwitched extends Schema.Schema.Type<typeof AgentSwitched> {
+}
+export declare const AgentSwitched: 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>;
+    }>;
+}>;
+export interface ModelSwitched extends Schema.Schema.Type<typeof ModelSwitched> {
+}
+export declare const ModelSwitched: 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>;
+    }>;
+}>;
+export interface User extends Schema.Schema.Type<typeof User> {
+}
+export declare const User: 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: 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: 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>;
+    }>;
+}>;
+export interface Synthetic extends Schema.Schema.Type<typeof Synthetic> {
+}
+export declare const Synthetic: 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>;
+    }>;
+}>;
+export interface System extends Schema.Schema.Type<typeof System> {
+}
+export declare const System: 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>;
+    }>;
+}>;
+export interface Skill extends Schema.Schema.Type<typeof Skill> {
+}
+export declare const Skill: 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>;
+    }>;
+}>;
+export interface Shell extends Schema.Schema.Type<typeof Shell> {
+}
+export declare const Shell: 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>;
+}>;
+export interface ToolStatePending extends Schema.Schema.Type<typeof ToolStatePending> {
+}
+export declare const ToolStatePending: Schema.Struct<{
+    readonly status: Schema.Literal<"pending">;
+    readonly input: Schema.String;
+}>;
+export interface ToolStateRunning extends Schema.Schema.Type<typeof ToolStateRunning> {
+}
+export declare const ToolStateRunning: 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>;
+    }>]>>;
+}>;
+export interface ToolStateCompleted extends Schema.Schema.Type<typeof ToolStateCompleted> {
+}
+export declare const ToolStateCompleted: 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: 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: 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>;
+}>;
+export interface ToolStateError extends Schema.Schema.Type<typeof ToolStateError> {
+}
+export declare const ToolStateError: 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>;
+}>;
+export declare const ToolState: 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: 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: 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>;
+}>]>;
+export type ToolState = ToolStatePending | ToolStateRunning | ToolStateCompleted | ToolStateError;
+export interface AssistantTool extends Schema.Schema.Type<typeof AssistantTool> {
+}
+export declare const AssistantTool: 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: 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: 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>;
+    }>;
+}>;
+export interface AssistantText extends Schema.Schema.Type<typeof AssistantText> {
+}
+export declare const AssistantText: Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly id: Schema.String;
+    readonly text: Schema.String;
+}>;
+export interface AssistantReasoning extends Schema.Schema.Type<typeof AssistantReasoning> {
+}
+export declare const AssistantReasoning: 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>;
+}>;
+export declare const AssistantContent: 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: 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: 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>;
+    }>;
+}>]>;
+export type AssistantContent = AssistantText | AssistantReasoning | AssistantTool;
+export interface Assistant extends Schema.Schema.Type<typeof Assistant> {
+}
+export declare const Assistant: 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: 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: 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>;
+}>;
+export interface Compaction extends Schema.Schema.Type<typeof Compaction> {
+}
+export declare const Compaction: 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;
+}>;
+export declare const Message: 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: 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: 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: 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: 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;
+}>]>;
+export type Message = AgentSwitched | ModelSwitched | User | Synthetic | System | Skill | Shell | Assistant | Compaction;
+export type Type = Message["type"];