@opencode-ai/core 0.0.0-next-17293

package/dist/types/session/revert.d.ts

@@ -0,0 +1,36 @@
+export * as SessionRevert from "./revert.js";
+import { Effect, Schema } from "effect";
+import { Database } from "../database/database.js";
+import { Bus } from "../bus.js";
+import { Snapshot } from "../snapshot.js";
+import { SessionMessage } from "./message.js";
+import { SessionSchema } from "./schema.js";
+declare const MessageNotFoundError_base: Schema.Class<MessageNotFoundError, Schema.TaggedStruct<"Session.MessageNotFoundError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class MessageNotFoundError extends MessageNotFoundError_base {
+}
+export declare const stage: (input: {
+    readonly session: SessionSchema.Info;
+    readonly messageID: SessionMessage.ID;
+    readonly files?: boolean;
+}) => Effect.Effect<{
+    messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
+    snapshot: (string & import("effect/Brand").Brand<"Snapshot.ID">) | undefined;
+    files: readonly {
+        readonly file: string;
+        readonly patch: string;
+        readonly additions: number;
+        readonly deletions: number;
+        readonly status: "added" | "deleted" | "modified";
+    }[];
+}, Snapshot.Error | MessageNotFoundError, Database.Service | Bus.Service | Snapshot.Service>;
+export declare const clear: (session: import("@opencode-ai/schema/session").Info) => Effect.Effect<void, Snapshot.Error, Bus.Service | Snapshot.Service>;
+export declare const commit: (session: import("@opencode-ai/schema/session").Info) => Effect.Effect<void, never, Bus.Service>;

package/dist/types/session/run-coordinator.d.ts

@@ -0,0 +1,36 @@
+export * as SessionRunCoordinator from "./run-coordinator.js";
+import { Effect, Exit, Scope } from "effect";
+/** Serializes execution for each key while allowing different keys to run concurrently. */
+export interface Coordinator<Key, E, Reason = never> {
+    /** Snapshots keys with an execution owned by this coordinator. */
+    readonly active: Effect.Effect<ReadonlySet<Key>>;
+    /** Starts an execution while idle, or joins the active execution and returns its exit. */
+    readonly run: (key: Key) => Effect.Effect<void, E>;
+    /** Rings the doorbell: an idle key starts an execution; an active one drains again before settling. */
+    readonly wake: (key: Key) => Effect.Effect<void>;
+    /** Stops the active execution, clears its doorbell, and waits for cleanup. No-op when idle. */
+    readonly interrupt: (key: Key, reason?: Reason) => Effect.Effect<void>;
+    /** Resolves once no execution is active for the key. Returns immediately when already idle and never starts work. */
+    readonly awaitIdle: (key: Key) => Effect.Effect<void>;
+}
+/**
+ * ```text
+ *              wake | run
+ *      idle ──────────────▶ execution (one fiber)
+ *                             drain ⟲ doorbell rung mid-drain
+ *                             │ exit (settled hook runs)
+ *      doorbell quiet ◀───────┴───────▶ doorbell rung
+ *      idle, waiters get exit          successor execution,
+ *                                      waiters get this exit
+ * ```
+ */
+export declare const make: <Key, E, Reason = never>(options: {
+    readonly drain: (key: Key, force: boolean) => Effect.Effect<void, E>;
+    /** Runs once when a process-local busy period begins, before its first drain. */
+    readonly started?: (key: Key) => Effect.Effect<void>;
+    /**
+     * Runs in the execution fiber for every exit, including interruption, after the final
+     * drain and before the execution settles (waiters resolve after it completes).
+     */
+    readonly settled?: (key: Key, exit: Exit.Exit<void, E>, reason?: Reason) => Effect.Effect<void>;
+}) => Effect.Effect<Coordinator<Key, E, Reason>, never, Scope.Scope>;

package/dist/types/session/runner/index.d.ts

@@ -0,0 +1,19 @@
+export * as SessionRunner from "./index.js";
+import type { AIError } from "@opencode-ai/ai";
+import { Context, Effect } from "effect";
+import { SessionSchema } from "../schema.js";
+import type { AgentNotFoundError, MessageDecodeError, StepFailedError, UserInterruptedError } from "../error.js";
+import { SessionRunnerModel } from "./model.js";
+import type { Instructions } from "../../instructions/index.js";
+export type RunError = AIError | SessionRunnerModel.Error | MessageDecodeError | AgentNotFoundError | StepFailedError | UserInterruptedError | Instructions.InitializationBlocked;
+/** Runs one local continuation from already-recorded Session history. */
+export interface Interface {
+    /** Drains eligible durable work. Explicit runs make one model call even when no work is eligible. */
+    readonly drain: (input: {
+        readonly sessionID: SessionSchema.ID;
+        readonly force: boolean;
+    }) => Effect.Effect<void, RunError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionRunner", Interface>;
+export declare class Service extends Service_base {
+}

package/dist/types/session/runner/llm.d.ts

@@ -0,0 +1,3 @@
+export * as SessionRunnerLLM from "./llm.js";
+import { Service } from "./index.js";
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/session/runner/max-steps.d.ts

@@ -0,0 +1 @@
+export declare const MAX_STEPS_PROMPT = "CRITICAL - MAXIMUM STEPS REACHED\n\nThe maximum number of steps allowed for this task has been reached. Tools are disabled until next user input. Respond with text only.\n\nSTRICT REQUIREMENTS:\n1. Do NOT make any tool calls (no reads, writes, edits, searches, or any other tools)\n2. MUST provide a text response summarizing work done so far\n3. This constraint overrides ALL other instructions, including any user requests for edits or tool use\n\nResponse must include:\n- Statement that maximum steps for this agent have been reached\n- Summary of what has been accomplished so far\n- List of any remaining tasks that were not completed\n- Recommendations for what should be done next\n\nAny attempt to use tools is a critical violation. Respond with text ONLY.";

package/dist/types/session/runner/model.d.ts

@@ -0,0 +1,55 @@
+export * as SessionRunnerModel from "./model.js";
+import { LanguageModel } from "@opencode-ai/ai";
+import { Context, Effect, Schema } from "effect";
+import { ModelResolver } from "../../model-resolver.js";
+import { Capabilities, Info, VariantID } from "../../model.js";
+import { SessionSchema } from "../schema.js";
+declare const ModelNotSelectedError_base: Schema.Class<ModelNotSelectedError, Schema.TaggedStruct<"SessionRunnerModel.ModelNotSelectedError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class ModelNotSelectedError extends ModelNotSelectedError_base {
+    get message(): string;
+}
+declare const ModelUnavailableError_base: Schema.Class<ModelUnavailableError, Schema.TaggedStruct<"SessionRunnerModel.ModelUnavailableError", {
+    readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    };
+    readonly modelID: Schema.brand<Schema.String, "Model.ID">;
+}>, import("effect/Cause").YieldableError>;
+export declare class ModelUnavailableError extends ModelUnavailableError_base {
+    get message(): string;
+}
+export declare const VariantUnavailableError: typeof ModelResolver.VariantUnavailableError;
+export type VariantUnavailableError = ModelResolver.VariantUnavailableError;
+export declare const UnsupportedPackageError: typeof ModelResolver.UnsupportedPackageError;
+export type UnsupportedPackageError = ModelResolver.UnsupportedPackageError;
+export declare const UnresolvedProviderVariablesError: typeof ModelResolver.UnresolvedProviderVariablesError;
+export type UnresolvedProviderVariablesError = ModelResolver.UnresolvedProviderVariablesError;
+export type Error = ModelNotSelectedError | ModelUnavailableError | ModelResolver.Error;
+export type Resolved = ModelResolver.Resolved;
+export interface Interface {
+    readonly resolve: (session: SessionSchema.Info) => Effect.Effect<Resolved, Error>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionRunnerModel", Interface>;
+export declare class Service extends Service_base {
+}
+/** Builds a Resolved whose catalog identity mirrors the route model. Test or embedding seam. */
+export declare const resolved: (model: LanguageModel, options: {
+    readonly capabilities: Capabilities;
+    readonly variant?: VariantID;
+    readonly cost: Info["cost"];
+}) => Resolved;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/session/runner/publish-llm-event.d.ts

@@ -0,0 +1,256 @@
+import { type LLMEvent } from "@opencode-ai/ai";
+import { Effect } from "effect";
+import { Bus } from "../../bus.js";
+import { Model } from "../../model.js";
+import { SessionMessage } from "../message.js";
+import { SessionSchema } from "../schema.js";
+import { SessionError } from "@opencode-ai/schema/session-error";
+import { Money } from "@opencode-ai/schema/money";
+import { Agent } from "../../agent.js";
+import { Snapshot } from "../../snapshot.js";
+import { RelativePath } from "../../schema.js";
+import { SessionUsage } from "../usage.js";
+import { Tool } from "@opencode-ai/schema/tool";
+type Input = {
+    readonly sessionID: SessionSchema.ID;
+    readonly agent: Agent.ID;
+    readonly model: Model.Ref;
+    readonly providerMetadataKey: string;
+    readonly snapshot?: Snapshot.ID;
+    readonly assistantMessageID: SessionMessage.ID;
+};
+/** Immutable fold of the durable facts a step's writer has recorded so far. */
+export interface StepRecord {
+    /** The model produced visible output this attempt, which bars transparent retries and overflow recovery. */
+    readonly outputStarted: boolean;
+    readonly providerFailed: boolean;
+    /** The step's recorded assistant failure, if any. */
+    readonly failure?: SessionError.Error;
+    /** Present once the provider finished the step normally. */
+    readonly finish?: {
+        readonly finish: Extract<LLMEvent, {
+            type: "step-finish";
+        }>["reason"]["normalized"];
+        readonly tokens: ReturnType<typeof SessionUsage.tokens>;
+    };
+    readonly calls: ReadonlyArray<{
+        readonly id: string;
+        readonly name: string;
+        readonly called: boolean;
+        readonly settled: boolean;
+        readonly providerExecuted: boolean;
+    }>;
+}
+/**
+ * Persist one step without executing tools or starting a continuation step.
+ *
+ * Concurrency invariant: the provider loop and each owned tool fiber call these methods
+ * concurrently without a lock. Two rules keep that safe, and every method must preserve
+ * them. (1) Commit state marks synchronously before the first await: never a yield
+ * between a check (`tool.settled`, `stepStarted`, ...) and its mark, so check-and-mark
+ * stays atomic under cooperative scheduling. (2) Never require a cross-source event
+ * order: each publishing fiber is sequential, so per-source order holds by construction,
+ * and consumers fold by id/ordinal rather than global position.
+ */
+export declare const createLLMEventPublisher: (bus: Pick<Bus.Interface, "publish">, input: Input) => {
+    publish: (event: {
+        readonly type: "step-start";
+        readonly index: number;
+    } | {
+        readonly id: string;
+        readonly type: "text-start";
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "text-delta";
+        readonly text: string;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "text-end";
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "reasoning-start";
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "reasoning-delta";
+        readonly text: string;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "reasoning-end";
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly name: string;
+        readonly id: string;
+        readonly type: "tool-input-start";
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        readonly providerExecuted?: boolean | undefined;
+    } | {
+        readonly type: "tool-input-delta";
+        readonly id: string;
+        readonly name: string;
+        readonly text: string;
+    } | {
+        readonly name: string;
+        readonly id: string;
+        readonly type: "tool-input-end";
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly type: "tool-input-error";
+        readonly id: string;
+        readonly name: string;
+        readonly raw: string;
+    } | {
+        readonly name: string;
+        readonly id: string;
+        readonly type: "tool-call";
+        readonly input: unknown;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        readonly providerExecuted?: boolean | undefined;
+    } | {
+        readonly name: string;
+        readonly id: string;
+        readonly type: "tool-result";
+        readonly result: {
+            readonly type: "json";
+            readonly value: unknown;
+        } | {
+            readonly type: "text";
+            readonly value: unknown;
+        } | {
+            readonly type: "error";
+            readonly value: unknown;
+        } | {
+            readonly type: "content";
+            readonly value: readonly ({
+                readonly type: "text";
+                readonly text: string;
+            } | {
+                readonly type: "file";
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+            })[];
+        };
+        readonly output?: {
+            readonly structured: unknown;
+            readonly content: readonly ({
+                readonly type: "text";
+                readonly text: string;
+            } | {
+                readonly type: "file";
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+            })[];
+        } | undefined;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        readonly providerExecuted?: boolean | undefined;
+    } | {
+        readonly name: string;
+        readonly id: string;
+        readonly type: "tool-error";
+        readonly message: string;
+        readonly error?: unknown;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    } | {
+        readonly type: "step-finish";
+        readonly reason: {
+            readonly normalized: "length" | "error" | "stop" | "tool-calls" | "content-filter" | "unknown";
+            readonly raw?: string | undefined;
+        };
+        readonly index: number;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        readonly usage?: import("@opencode-ai/ai").Usage | undefined;
+    } | {
+        readonly type: "finish";
+        readonly reason: {
+            readonly normalized: "length" | "error" | "stop" | "tool-calls" | "content-filter" | "unknown";
+            readonly raw?: string | undefined;
+        };
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        readonly usage?: import("@opencode-ai/ai").Usage | undefined;
+    } | {
+        readonly type: "provider-error";
+        readonly message: string;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        readonly classification?: "context-overflow" | "payload-too-large" | undefined;
+    }) => Effect.Effect<undefined, never, never>;
+    progress: (id: string, update: Readonly<Record<string, any>>) => Effect.Effect<undefined, never, never>;
+    toolExecution: (id: string, name: string, result: Tool.Result<Tool.ValueSchema<any> | undefined>) => Effect.Effect<undefined, never, never>;
+    flush: () => Effect.Effect<void, never, never>;
+    failAssistant: (error: SessionError.Error) => Effect.Effect<void, never, never>;
+    failTool: (id: string, error: SessionError.Error, metadata?: Readonly<Record<string, any>> | undefined) => Effect.Effect<boolean, never, never>;
+    publishStepFailure: (details?: {
+        readonly cost?: Money.USD;
+        readonly tokens?: ReturnType<typeof SessionUsage.tokens>;
+        readonly snapshot?: Snapshot.ID;
+        readonly files?: readonly RelativePath[];
+    } | undefined) => Effect.Effect<void, never, never>;
+    failUnsettledTools: (error: SessionError.Error, scope?: "all" | "hosted" | undefined) => Effect.Effect<boolean, never, never>;
+    hasProviderError: () => boolean;
+    /** Immutable snapshot of everything recorded for this step so far. */
+    record: () => StepRecord;
+    startAssistant: () => Effect.Effect<string & import("effect/Brand").Brand<"Session.Message.ID">, never, never>;
+    assistantMessageID: (id: string) => Effect.Effect<string & import("effect/Brand").Brand<"Session.Message.ID">, never, never>;
+};
+export {};

package/dist/types/session/runner/retry.d.ts

@@ -0,0 +1,18 @@
+export * as SessionRunnerRetry from "./retry.js";
+import { AIError } from "@opencode-ai/ai";
+import { SessionError } from "@opencode-ai/schema/session-error";
+import { Duration, Schedule } from "effect";
+import { Bus } from "../../bus.js";
+import { SessionMessage } from "../message.js";
+import { SessionSchema } from "../schema.js";
+declare const RetryableFailure_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "SessionRunner.RetryableFailure";
+} & Readonly<A>;
+export declare class RetryableFailure extends RetryableFailure_base<{
+    readonly cause: AIError;
+    readonly error: SessionError.Error;
+    readonly step: number;
+}> {
+}
+export declare function isRetryable(error: AIError): boolean;
+export declare const schedule: (bus: Bus.Interface, sessionID: SessionSchema.ID, assistantMessageID: () => SessionMessage.ID) => Schedule.Schedule<Duration.Duration, RetryableFailure, never, never>;

package/dist/types/session/runner/to-llm-message.d.ts

@@ -0,0 +1,5 @@
+import { Message } from "@opencode-ai/ai";
+import type { Model } from "../../model.js";
+import { SessionMessage } from "../message.js";
+/** Translate projected Session history into canonical @opencode-ai/ai context. */
+export declare const toLLMMessages: (messages: readonly SessionMessage.Info[], model: Model.Ref, providerMetadataKey?: string) => Message[];

package/dist/types/session/schema.d.ts

@@ -0,0 +1,177 @@
+export * as SessionSchema from "./schema.js";
+import { Session } from "@opencode-ai/schema/session";
+export declare const ID: import("effect/Schema").brand<import("effect/Schema").String, "SessionID"> & {
+    create: () => string & import("effect/Brand").Brand<"SessionID">;
+    descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+};
+export type ID = typeof ID.Type;
+export declare const Info: import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly parentID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    }>, never, never>;
+    readonly fork: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly sessionID: import("effect/Schema").brand<import("effect/Schema").String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly boundary: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"before">;
+            readonly messageID: import("effect/Schema").brand<import("effect/Schema").String, "Session.Message.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+                fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            };
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"through">;
+            readonly messageID: import("effect/Schema").brand<import("effect/Schema").String, "Session.Message.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+                fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            };
+        }>]>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly sessionID: import("effect/Schema").brand<import("effect/Schema").String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly boundary: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"before">;
+            readonly messageID: import("effect/Schema").brand<import("effect/Schema").String, "Session.Message.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+                fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            };
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"through">;
+            readonly messageID: import("effect/Schema").brand<import("effect/Schema").String, "Session.Message.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+                fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            };
+        }>]>;
+    }>>, never, never>;
+    readonly projectID: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly agent: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Agent.ID">>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Agent.ID">>, never, never>;
+    readonly model: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Model.ID">;
+        readonly providerID: import("effect/Schema").brand<import("effect/Schema").String, "Provider.ID"> & {
+            opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+            anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+            openai: string & import("effect/Brand").Brand<"Provider.ID">;
+            google: string & import("effect/Brand").Brand<"Provider.ID">;
+            googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+            githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+            amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+            azure: string & import("effect/Brand").Brand<"Provider.ID">;
+            openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+            mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+            gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+        };
+        readonly variant: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Model.VariantID">>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Model.VariantID">>, never, never>;
+    }> & {
+        parse: (input: string) => {
+            readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+            readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+            readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
+        };
+    }>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Model.ID">;
+        readonly providerID: import("effect/Schema").brand<import("effect/Schema").String, "Provider.ID"> & {
+            opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+            anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+            openai: string & import("effect/Brand").Brand<"Provider.ID">;
+            google: string & import("effect/Brand").Brand<"Provider.ID">;
+            googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+            githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+            amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+            azure: string & import("effect/Brand").Brand<"Provider.ID">;
+            openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+            mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+            gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+        };
+        readonly variant: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Model.VariantID">>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Model.VariantID">>, never, never>;
+    }> & {
+        parse: (input: string) => {
+            readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+            readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+            readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
+        };
+    }>, never, never>;
+    readonly cost: import("effect/Schema").brand<import("effect/Schema").Finite, "Money.USD"> & {
+        zero: number & import("effect/Brand").Brand<"Money.USD">;
+    };
+    readonly tokens: import("effect/Schema").Struct<{
+        readonly input: import("effect/Schema").Finite;
+        readonly output: import("effect/Schema").Finite;
+        readonly reasoning: import("effect/Schema").Finite;
+        readonly cache: import("effect/Schema").Struct<{
+            readonly read: import("effect/Schema").Finite;
+            readonly write: import("effect/Schema").Finite;
+        }>;
+    }>;
+    readonly time: import("effect/Schema").Struct<{
+        readonly created: import("effect/Schema").decodeTo<import("effect/Schema").DateTimeUtc, import("effect/Schema").Finite, never, never>;
+        readonly updated: import("effect/Schema").decodeTo<import("effect/Schema").DateTimeUtc, import("effect/Schema").Finite, never, never>;
+        readonly archived: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").decodeTo<import("effect/Schema").DateTimeUtc, import("effect/Schema").Finite, never, never>>>, import("effect/Schema").optionalKey<import("effect/Schema").decodeTo<import("effect/Schema").DateTimeUtc, import("effect/Schema").Finite, never, never>>, never, never>;
+    }>;
+    readonly title: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+    readonly location: import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>;
+    readonly subpath: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "RelativePath">>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "RelativePath">>, never, never>;
+    readonly revert: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly messageID: import("effect/Schema").brand<import("effect/Schema").String, "Session.Message.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        };
+        readonly partID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+        readonly snapshot: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Snapshot.ID">>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Snapshot.ID">>, never, never>;
+        readonly files: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly file: import("effect/Schema").String;
+            readonly patch: import("effect/Schema").String;
+            readonly additions: import("effect/Schema").Int;
+            readonly deletions: import("effect/Schema").Int;
+            readonly status: import("effect/Schema").Literals<readonly ["added", "deleted", "modified"]>;
+        }>>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly file: import("effect/Schema").String;
+            readonly patch: import("effect/Schema").String;
+            readonly additions: import("effect/Schema").Int;
+            readonly deletions: import("effect/Schema").Int;
+            readonly status: import("effect/Schema").Literals<readonly ["added", "deleted", "modified"]>;
+        }>>>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly messageID: import("effect/Schema").brand<import("effect/Schema").String, "Session.Message.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        };
+        readonly partID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+        readonly snapshot: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Snapshot.ID">>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Snapshot.ID">>, never, never>;
+        readonly files: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly file: import("effect/Schema").String;
+            readonly patch: import("effect/Schema").String;
+            readonly additions: import("effect/Schema").Int;
+            readonly deletions: import("effect/Schema").Int;
+            readonly status: import("effect/Schema").Literals<readonly ["added", "deleted", "modified"]>;
+        }>>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly file: import("effect/Schema").String;
+            readonly patch: import("effect/Schema").String;
+            readonly additions: import("effect/Schema").Int;
+            readonly deletions: import("effect/Schema").Int;
+            readonly status: import("effect/Schema").Literals<readonly ["added", "deleted", "modified"]>;
+        }>>>, never, never>;
+    }>>, never, never>;
+}>;
+export type Info = Session.Info;