@opencode/core 2.0.21 → 2.0.23

package/dist/types/instance.d.ts

@@ -51,12 +51,12 @@ import { ToolOutput } from "./tool-output.js";
 import { Vcs } from "./vcs.js";
 export * as Instance from "./instance.js";
 export { Service, node, type Interface } from "./instance/service.js";
-export declare const graph: LayerNode.Graph<Location.Service | Agent.Service | Form.Service | Integration.Service | Provider.Service | Model.Service | AISDK.Service | Command.Service | Config.Service | ModelResolver.Service | SessionRunnerModel.Service | PluginHooks.Service | Permission.Service | Environment.Service | FileSystemSearch.Service | FileSystem.Service | Image.Service | Tool.Service | FileAccess.Service | FileMutation.Service | Formatter.Service | Generate.Service | ShellSelect.Service | LocationLifecycle.Service | Rpc.Service | Reference.Service | WebSearch.Service | Plugin.Service | InstancePlugins.Service | WorktreeStrategies.Service | Mcp.Service | InstructionDiscovery.Service | ReadToolFileSystem.Service | SessionCompaction.Service | SessionInstructions.Service | Shell.Service | Snapshot.Service | Skill.Service | ToolOutput.Service | Pty.Service | InstructionBuiltIns.Service | SkillInstructions.Service | ReferenceInstructions.Service | InstructionEntry.Service | McpTool.Service | SessionTitle.Service | SessionContext.Service | import("./session/runner/index.js").Service | Vcs.Service | LocationWatcher.Service, import("./persistent-pty/index.js").UnavailableError, LayerNode.Tag<"location">>;
+export declare const graph: LayerNode.Graph<Location.Service | Agent.Service | Form.Service | Integration.Service | Provider.Service | Model.Service | AISDK.Service | Command.Service | Config.Service | ModelResolver.Service | SessionRunnerModel.Service | PluginHooks.Service | Permission.Service | Environment.Service | FileSystemSearch.Service | FileSystem.Service | Image.Service | Tool.Service | FileAccess.Service | FileMutation.Service | Formatter.Service | Generate.Service | ShellSelect.Service | LocationLifecycle.Service | Rpc.Service | Reference.Service | WebSearch.Service | Plugin.Service | InstancePlugins.Service | WorktreeStrategies.Service | Mcp.Service | InstructionDiscovery.Service | ReadToolFileSystem.Service | SessionCompaction.Service | SessionInstructions.Service | Shell.Service | Snapshot.Service | Skill.Service | ToolOutput.Service | Pty.Service | InstructionBuiltIns.Service | SkillInstructions.Service | ReferenceInstructions.Service | InstructionEntry.Service | McpTool.Service | SessionTitle.Service | SessionContext.Service | import("./session/runner/index.js").Service | Vcs.Service | LocationWatcher.Service, FileSystem.DirectoryNotFoundError | FileSystem.DirectoryAccessDeniedError | import("./persistent-pty/index.js").UnavailableError, LayerNode.Tag<"location">>;
 export type Services = LayerNode.Output<typeof graph>;
-export type Error = Layer.Error<ReturnType<typeof layer>>;
+export type Error = FileSystem.DirectoryNotFoundError;
 export interface Options {
     readonly plugins?: InstancePlugins.List;
     readonly discovery?: boolean;
     readonly replacements?: LayerNode.Replacements;
 }
-export declare function layer(ref: Location.Ref, options?: Options): Layer.Layer<Services>;
+export declare function layer(ref: Location.Ref, options?: Options): Layer.Layer<Services, Error>;

package/dist/types/job.d.ts

@@ -50,7 +50,7 @@ export type Info = {
     notificationID?: SessionMessage.ID;
 };
 export type StartInput = {
-    id?: string;
+    id: string;
     type: string;
     title?: string;
     metadata?: Record<string, unknown>;

package/dist/types/location-service-map.d.ts

@@ -2,12 +2,12 @@ import { Context, Effect, Layer, LayerMap } from "effect";
 import { LayerNode } from "@opencode/util/effect/layer-node";
 import { Location } from "./location.js";
 import type { Instance } from "./instance.js";
-declare const Service_base: Context.ServiceClass<Service, "@opencode/example/LocationServiceMap", LayerMap.LayerMap<Location.Ref, Instance.Services, never>>;
+declare const Service_base: Context.ServiceClass<Service, "@opencode/example/LocationServiceMap", LayerMap.LayerMap<Location.Ref, Instance.Services, import("./filesystem.js").DirectoryNotFoundError>>;
 export declare class Service extends Service_base {
-    static get(ref: Location.Ref): Layer.Layer<Instance.Services, never, Service>;
+    static get(ref: Location.Ref): Layer.Layer<Instance.Services, import("./filesystem.js").DirectoryNotFoundError, Service>;
 }
 export declare const node: LayerNode.Node<Service, never, LayerNode.Tag<"global">>;
-export declare const reload: () => Effect.Effect<undefined, never, Service>;
+export declare const reload: () => Effect.Effect<undefined, import("./filesystem.js").DirectoryNotFoundError, Service>;
 /** Normalize equivalent placements before they become resource-cache keys. */
 export declare function canonical(ref: Location.Ref): {
     readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;

package/dist/types/mcp/client.d.ts

@@ -77,7 +77,7 @@ export interface Connection {
         readonly args?: Record<string, unknown>;
         readonly sessionID?: Session.ID;
     }) => Effect.Effect<CallToolResult, Error>;
-    readonly onClose: (callback: () => void) => void;
+    readonly onClose: (callback: (reason: string) => void) => void;
     readonly onSessionExpired: (callback: () => void) => void;
     readonly onToolsChanged: (callback: () => void) => void;
     readonly onPromptsChanged: (callback: () => void) => void;
@@ -373,7 +373,7 @@ export declare const connect: (server: string, config: import("@opencode/schema/
         readonly args?: Record<string, unknown>;
         readonly sessionID?: Session.ID;
     }) => Effect.Effect<CallToolResult, Error | SessionExpiredError, never>;
-    onClose: (callback: () => void) => void;
+    onClose: (callback: (reason: string) => void) => void;
     onSessionExpired: (callback: () => void) => void;
     onToolsChanged: (callback: () => void) => void;
     onPromptsChanged: (callback: () => void) => void;

package/dist/types/model-resolver.d.ts

@@ -151,8 +151,8 @@ export interface Resolved {
     readonly compaction?: Provider.Compaction;
     /** Provider transport policy; omitted means HTTP. */
     readonly transport?: Provider.Transport;
-    /** Milliseconds without streamed data before a WebSocket exchange fails. */
-    readonly chunkTimeout?: number;
+    /** Milliseconds without streamed data before a WebSocket exchange fails; `false` disables the limit. */
+    readonly chunkTimeout?: number | false;
 }
 export interface Interface {
     readonly resolve: (requested?: Ref) => Effect.Effect<Resolved | undefined, Error>;

package/dist/types/model.d.ts

@@ -32,6 +32,12 @@ export declare const Capabilities: import("effect/Schema").Struct<{
     };
 };
 export type Capabilities = Model.Capabilities;
+/** Merges partial config capabilities onto a base model's capabilities, defaulting unset fields. */
+export declare const mergeCapabilities: (config: Partial<Capabilities>, base: Capabilities | undefined) => {
+    tools: boolean;
+    input: string[];
+    output: string[];
+};
 export declare const Cost: import("effect/Schema").Struct<{
     readonly tier: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
         readonly type: import("effect/Schema").tag<"context">;

package/dist/types/persistent-pty/binary.bun.d.ts

@@ -1 +1,2 @@
+export declare const available: boolean;
 export declare function resolveBinary(bin: string): Promise<string>;

package/dist/types/persistent-pty/binary.node.d.ts

@@ -1 +1,2 @@
+export declare const available: boolean;
 export declare function resolveBinary(): Promise<string>;

package/dist/types/persistent-pty/binary.workerd.d.ts

@@ -1 +1,2 @@
+export declare const available = false;
 export declare function resolveBinary(): Promise<string>;

package/dist/types/persistent-pty/daemon.d.ts

@@ -1,4 +1,4 @@
-import { Effect, Schema } from "effect";
+import { Cause, Effect, Schema } from "effect";
 import type { Handoff } from "@opencode/schema/persistent-pty";
 export declare const WireTerminal: Schema.Struct<{
     readonly id: Schema.Number;
@@ -236,7 +236,7 @@ export type DaemonAttachment = {
     readonly activate: () => void;
     readonly detach: () => void;
 };
-declare const DaemonError_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 & {
+declare const DaemonError_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]; }>) => Cause.YieldableError & {
     readonly _tag: "PersistentPty.DaemonError";
 } & Readonly<A>;
 export declare class DaemonError extends DaemonError_base<{
@@ -259,7 +259,7 @@ export interface DaemonTransport {
         readonly onEnd: () => void;
     }) => Effect.Effect<DaemonAttachment, DaemonError>;
 }
-export declare const makeDaemonTransport: (directory: string, binary?: (() => Promise<string>) | undefined, inherited?: Handoff | undefined) => Effect.Effect<{
+export declare const makeDaemonTransport: (root: string, initialID: string, binary?: (() => Promise<string>) | undefined, inherited?: Handoff | undefined) => Effect.Effect<{
     request: (value: object, shouldStart?: any) => Effect.Effect<{
         readonly type: "pong";
         readonly instance_id: string;
@@ -770,7 +770,7 @@ export declare const makeDaemonTransport: (directory: string, binary?: (() => Pr
         ticket: string;
         expiresAt: number;
     } | null, DaemonError, never>;
-    subscribe: (id: number, input: {
+    subscribe: (terminalID: number, input: {
         readonly cursor: number;
         readonly attachmentID: string;
         readonly role: Role;

package/dist/types/persistent-pty/index.d.ts

@@ -8,6 +8,7 @@ import { Global } from "@opencode/util/global";
 import { type Role, type StreamEvent } from "./daemon.js";
 export type { Role, StreamEvent } from "./daemon.js";
 export { Handoff } from "@opencode/schema/persistent-pty";
+export { available } from "#persistent-pty-binary";
 export declare const Options: Schema.Struct<{
     readonly handoff: Schema.optional<Schema.Struct<{
         readonly directory: Schema.String;
@@ -15,6 +16,8 @@ export declare const Options: Schema.Struct<{
         readonly ticket: Schema.String;
         readonly expiresAt: Schema.Number;
     }>>;
+    /** Parent of per-server daemon runtime directories; defaults to `<state>/pty`. */
+    readonly root: Schema.optional<Schema.String>;
 }>;
 export type Options = typeof Options.Type;
 export type Info = PersistentPty.Info;

package/dist/types/plugin/internal.d.ts

@@ -51,7 +51,7 @@ import { ToolOutput } from "../tool-output.js";
 import { WellKnown } from "../wellknown.js";
 declare const services: readonly [typeof Agent.Service, typeof AppProcess.Service, typeof Provider.Service, typeof Model.Service, typeof Command.Service, typeof Config.Service, typeof Credential.Service, typeof Bus.Service, typeof Environment.Service, typeof FileAccess.Service, typeof FileMutation.Service, typeof Formatter.Service, typeof LocationWatcherPolicy.Service, typeof FileSystem.Service, typeof FSUtil.Service, typeof Global.Service, Context.Service<HttpClient.HttpClient, HttpClient.HttpClient>, typeof Image.Service, typeof InstructionDiscovery.Service, typeof Integration.Service, typeof Job.Service, typeof KV.Service, typeof import("@opencode/ai").LLMClientService, typeof Location.Service, typeof ManagedPolicy.Service, typeof ModelsDev.Service, typeof Mcp.Service, typeof Npm.Service, typeof Permission.Service, typeof Form.Service, typeof ReadToolFileSystem.Service, typeof Reference.Service, typeof WebSearch.Service, typeof Ripgrep.Service, typeof Session.Service, typeof SessionCompaction.Service, typeof SessionInstructions.Service, typeof Shell.Service, typeof ShellSelect.Service, typeof Snapshot.Service, typeof Skill.Service, typeof SkillDiscovery.Service, typeof Tool.Service, typeof ToolOutput.Service, typeof Watcher.Service, typeof WellKnown.Service, typeof Worktree.Service, typeof WorktreeStrategies.Service];
 export type Requirements = Context.Service.Identifier<(typeof services)[number]>;
-export declare const requirements: LayerNode.Graph<Global.Service | HttpClient.HttpClient | FSUtil.Service | AppProcess.Service | Bus.Service | Location.Service | Agent.Service | import("@opencode/ai").LLMClientService | Npm.Service | Credential.Service | Form.Service | Integration.Service | Provider.Service | Model.Service | Command.Service | Watcher.Service | KV.Service | WellKnown.Service | Config.Service | Permission.Service | Environment.Service | Ripgrep.Service | FileSystem.Service | Image.Service | Tool.Service | FileAccess.Service | FileMutation.Service | Formatter.Service | ShellSelect.Service | Reference.Service | WebSearch.Service | WorktreeStrategies.Service | Mcp.Service | ModelsDev.Service | LocationWatcherPolicy.Service | InstructionDiscovery.Service | Job.Service | ManagedPolicy.Service | ReadToolFileSystem.Service | Session.Service | SessionCompaction.Service | SessionInstructions.Service | Shell.Service | Snapshot.Service | Skill.Service | SkillDiscovery.Service | ToolOutput.Service | Worktree.Service, never, LayerNode.Tag<"global"> | LayerNode.Tag<"location">>;
+export declare const requirements: LayerNode.Graph<Global.Service | HttpClient.HttpClient | FSUtil.Service | AppProcess.Service | Bus.Service | Location.Service | Agent.Service | import("@opencode/ai").LLMClientService | Npm.Service | Credential.Service | Form.Service | Integration.Service | Provider.Service | Model.Service | Command.Service | Watcher.Service | KV.Service | WellKnown.Service | Config.Service | Permission.Service | Environment.Service | Ripgrep.Service | FileSystem.Service | Image.Service | Tool.Service | FileAccess.Service | FileMutation.Service | Formatter.Service | ShellSelect.Service | Reference.Service | WebSearch.Service | WorktreeStrategies.Service | Mcp.Service | ModelsDev.Service | LocationWatcherPolicy.Service | InstructionDiscovery.Service | Job.Service | ManagedPolicy.Service | ReadToolFileSystem.Service | Session.Service | SessionCompaction.Service | SessionInstructions.Service | Shell.Service | Snapshot.Service | Skill.Service | SkillDiscovery.Service | ToolOutput.Service | Worktree.Service, FileSystem.DirectoryNotFoundError | FileSystem.DirectoryAccessDeniedError, LayerNode.Tag<"global"> | LayerNode.Tag<"location">>;
 export type InternalPlugin = Plugin<Requirements | Scope.Scope>;
 export declare const guarded: ReadonlySet<string>;
 export declare const list: () => Effect.Effect<{

package/dist/types/plugin/provider/azure.d.ts

@@ -1,4 +1,10 @@
+import { HttpClient } from "effect/unstable/http";
 import { AppProcess } from "@opencode/util/process";
 import { Bus } from "../../bus.js";
+import { Credential } from "../../credential.js";
 import { Provider } from "../../provider.js";
-export declare const AzurePlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | AppProcess.Service | Bus.Service | Provider.Service>;
+export declare function make(endpoints?: {
+    resource: (name: string) => string;
+    management: string;
+}): import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | HttpClient.HttpClient | AppProcess.Service | Bus.Service | Credential.Service | Provider.Service>;
+export declare const AzurePlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | HttpClient.HttpClient | AppProcess.Service | Bus.Service | Credential.Service | Provider.Service>;

package/dist/types/plugin/supervisor.d.ts

@@ -7,4 +7,4 @@ import { PluginInternal } from "./internal.js";
 import { SdkPlugins } from "./sdk.js";
 import { PluginUpdate } from "./update.js";
 export declare const layer: Layer.Layer<never, never, Plugin.Service | InstancePlugins.Service | SdkPlugins.Service | ConfigPluginSource.Service | PluginUpdate.Service | PluginInternal.Requirements>;
-export declare const node: import("@opencode/util/effect/layer-node").Provider<never, import("../persistent-pty/index.js").UnavailableError, import("@opencode/util/effect/layer-node").Tag<"location">>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<never, import("../filesystem.js").DirectoryNotFoundError | import("../filesystem.js").DirectoryAccessDeniedError | import("../persistent-pty/index.js").UnavailableError, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/provider.d.ts

@@ -2,7 +2,7 @@ export * as Provider from "./provider.js";
 import { Context, Effect, Schema } from "effect";
 import { Provider } from "@opencode/schema/provider";
 import { Model } from "@opencode/schema/model";
-import type { ProviderPackageDefinition } from "@opencode/ai";
+import { type ProviderPackageDefinition } from "@opencode/ai";
 import { Npm } from "@opencode/util/npm";
 import type { DeepMutable } from "./schema.js";
 import { State } from "./state.js";
@@ -42,6 +42,16 @@ export declare function nativeSettings(settings: Settings): Settings;
 export declare function modelSettings(settings: Settings | undefined): {
     readonly [x: string]: any;
 } | undefined;
+/** Applied to `headerTimeout` and `chunkTimeout` when provider settings leave them unset or invalid. */
+export declare const DEFAULT_TIMEOUT_MS = 300000;
+/** One timeout setting without a default; invalid values are dropped. */
+export declare function timeout(value: unknown): number | false | undefined;
+/** Request timeouts from provider settings, resolved for every route. `timeout` has no default. */
+export declare function timeouts(settings: Readonly<Record<string, unknown>>): {
+    timeout: number | false | undefined;
+    headerTimeout: number | false;
+    chunkTimeout: number | false;
+};
 export declare function mergeOverlay(base: Readonly<Record<string, unknown>> | undefined, overlay: Readonly<Record<string, unknown>> | undefined): Record<string, Json> | undefined;
 export declare function mergeHeaders(base: Readonly<Record<string, string>> | undefined, overlay: Readonly<Record<string, string>> | undefined): {
     [k: string]: string;
@@ -49,7 +59,8 @@ export declare function mergeHeaders(base: Readonly<Record<string, string>> | un
 export declare const Request: Schema.Struct<{
     readonly settings: Schema.withConstructorDefault<Schema.StructWithRest<Schema.Struct<{
         readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
-        readonly chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        readonly headerTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
         readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
             readonly type: Schema.Literal<"summary">;
         }>, Schema.Struct<{
@@ -75,7 +86,8 @@ export declare const Transport: Schema.Literals<readonly ["http", "websocket"]>;
 export type Transport = Provider.Transport;
 export declare const Settings: Schema.StructWithRest<Schema.Struct<{
     readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
-    readonly chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+    readonly headerTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+    readonly chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
     readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.Literal<"summary">;
     }>, Schema.Struct<{
@@ -91,7 +103,8 @@ export type Settings = Provider.Settings;
 export declare const Info: Schema.Struct<{
     readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.StructWithRest<Schema.Struct<{
         readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
-        readonly chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        readonly headerTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
         readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
             readonly type: Schema.Literal<"summary">;
         }>, Schema.Struct<{
@@ -104,7 +117,8 @@ export declare const Info: Schema.Struct<{
         readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
     }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
         readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
-        readonly chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        readonly headerTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
+        readonly chunkTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
         readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
             readonly type: Schema.Literal<"summary">;
         }>, Schema.Struct<{

package/dist/types/schema.d.ts

@@ -1,4 +1,3 @@
-import { Schema } from "effect";
 import { AbsolutePath, DateTimeUtcFromMillis, NonNegativeInt, optional, PositiveInt, RelativePath, statics } from "@opencode/schema/schema";
 export { AbsolutePath, DateTimeUtcFromMillis, NonNegativeInt, optional, PositiveInt, RelativePath, statics };
 /**
@@ -23,23 +22,3 @@ export type DeepMutable<T> = T extends string | number | boolean | bigint | symb
 } : T extends readonly (infer U)[] ? DeepMutable<U>[] : T extends object ? {
     -readonly [K in keyof T]: DeepMutable<T[K]>;
 } : T;
-/**
- * Nominal wrapper for scalar types. The class itself is a valid schema —
- * pass it directly to `Schema.decodeUnknownSync`, `Schema.decodeEffect`, etc.
- *
- * The runtime value remains an unwrapped primitive. `Schema.brand` supplies
- * the primitive schema behavior and constructor validation, while the class
- * supplies the nominal TypeScript identity.
- * Apply checks and annotations to the underlying schema before wrapping it;
- * schema rebuild operations intentionally return the underlying schema shape.
- *
- * @example
- *   class QuestionID extends Newtype<QuestionID>()("QuestionID", Schema.String) {}
- *
- *   const id = QuestionID.make("question-1")
- *   Schema.decodeUnknownEffect(QuestionID)(input)
- */
-type NewtypeSchema<Self, Tag extends string, S extends Schema.Top> = (abstract new (_: never) => {
-    readonly _newtype: Tag;
-}) & Schema.BottomWithoutNew<Self, S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], S["Rebuild"], S["~type.make.in"], Self, S["~type.parameters"], Self, S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> & Omit<S, keyof Schema.Top>;
-export declare function Newtype<Self>(): <const Tag extends string, S extends Schema.Top>(tag: Tag, schema: S) => NewtypeSchema<Self, Tag, S>;

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

@@ -13,4 +13,4 @@ export declare const execute: (input: {
     agents?: PromptInput.Prompt["agents"];
     skills?: PromptInput.Prompt["skills"];
     delivery?: SessionInbox.Delivery;
-}) => Effect.Effect<void, Command.NotFoundError | Command.ExecutionError, Instance.Service>;
+}) => Effect.Effect<void, Command.NotFoundError | Command.ExecutionError | import("../filesystem.js").DirectoryNotFoundError, Instance.Service>;

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

@@ -2,12 +2,15 @@ export * as SessionCompaction from "./compaction.js";
 import { Message } from "@opencode/ai";
 import type { SessionError } from "@opencode/schema/session-error";
 import { Context, Effect, Layer } from "effect";
+import { Agent } from "../agent.js";
 import { Bus } from "../bus.js";
 import { Database } from "../database/database.js";
+import { Model } from "../model.js";
 import { State } from "../state.js";
 import type { SessionContext } from "./context.js";
 import type { SessionMessage } from "./message.js";
 import { SessionModelRequest } from "./model-request.js";
+import { SessionRunnerModel } from "./runner/model.js";
 export type Settings = {
     auto: boolean;
     /** Tokens kept free below the model's limits before compacting. Unset keeps 10% free. */
@@ -47,7 +50,7 @@ declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionComp
 export declare class Service extends Service_base {
 }
 export declare const buildPrompt: (update: boolean, legacy?: boolean) => string;
-export declare const layer: Layer.Layer<Service, never, Database.Service | Bus.Service | import("@opencode/ai").LLMClientService | SessionModelRequest.Service>;
+export declare const layer: Layer.Layer<Service, never, Database.Service | Bus.Service | Agent.Service | import("@opencode/ai").LLMClientService | Model.Service | SessionRunnerModel.Service | SessionModelRequest.Service>;
 export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;
 /** The newest whole, real user messages within `keep` tokens: no synthetic guidance, no half of an attachment. */
 export declare const recentUserMessages: (messages: ReadonlyArray<SessionMessage.Info>, model: Pick<SessionContext.Loaded["model"], "ref" | "capabilities">, keep: number) => Message[];

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

@@ -32,11 +32,11 @@ export declare class TurnRangeError extends TurnRangeError_base {
  */
 export declare const turn: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
     $client: import("effect/unstable/sql/SqlClient").SqlClient;
-}, locations: import("effect/LayerMap").LayerMap<Location.Ref, import("../instance.js").Services, never>, input: {
+}, locations: import("effect/LayerMap").LayerMap<Location.Ref, import("../instance.js").Services, import("../filesystem.js").DirectoryNotFoundError>, input: {
     readonly session: SessionSchema.Info;
     /** The process is currently executing this Session. */
     readonly active: boolean;
     readonly from?: SessionMessage.ID;
     readonly to?: SessionMessage.ID;
     readonly context?: number;
-}) => Effect.Effect<readonly import("@opencode/schema/file-diff").Info[], MessageNotFoundError | Snapshot.Error | TurnRangeError, never>;
+}) => Effect.Effect<readonly import("@opencode/schema/file-diff").Info[], MessageNotFoundError | import("../filesystem.js").DirectoryNotFoundError | Snapshot.Error | TurnRangeError, never>;

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

@@ -1,4 +1,5 @@
 export * as SessionGenerate from "./generate.js";
+import type { FileSystem } from "../filesystem.js";
 import { type AIError } from "@opencode/ai";
 import { Effect } from "effect";
 import { Database } from "../database/database.js";
@@ -7,9 +8,9 @@ import type { Instructions } from "../instructions/index.js";
 import type { AgentNotFoundError } from "./error.js";
 import type { SessionRunnerModel } from "./runner/model.js";
 import type { SessionSchema } from "./schema.js";
-export type Error = AgentNotFoundError | Instructions.InitializationBlocked | SessionRunnerModel.Error | AIError;
+export type Error = AgentNotFoundError | Instructions.InitializationBlocked | SessionRunnerModel.Error | AIError | FileSystem.DirectoryNotFoundError;
 /** Generates text from current Session context without mutating the Session. */
 export declare const generate: (input: {
     session: SessionSchema.Info;
     prompt: string;
-}) => Effect.Effect<string, AIError | AgentNotFoundError | Instructions.InitializationBlocked | SessionRunnerModel.Error, Database.Service | import("@opencode/ai").LLMClientService | Instance.Service>;
+}) => Effect.Effect<string, AIError | AgentNotFoundError | Instructions.InitializationBlocked | SessionRunnerModel.Error | FileSystem.DirectoryNotFoundError, Database.Service | import("@opencode/ai").LLMClientService | Instance.Service>;

package/dist/types/session/model-transport.d.ts

@@ -18,7 +18,7 @@ export interface Interceptor {
     readonly receive?: (frame: string) => Effect.Effect<string>;
 }
 export interface Interface {
-    readonly bind: (sessionID: SessionSchema.ID, interceptor?: Interceptor, idleTimeout?: number) => WebSocketChannelExecutor;
+    readonly bind: (sessionID: SessionSchema.ID, interceptor?: Interceptor, idleTimeout?: number | false) => WebSocketChannelExecutor;
     readonly close: (sessionID: SessionSchema.ID) => Effect.Effect<void>;
     readonly closeAll: Effect.Effect<void>;
 }

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

@@ -63,4 +63,4 @@ export declare const prepare: (request: {
         }[] | undefined;
     };
     delivery: "steer" | "queue";
-}, AttachmentError | SkillNotFoundError, FSUtil.Service | Instance.Service>;
+}, AttachmentError | SkillNotFoundError | import("../filesystem.js").DirectoryNotFoundError, FSUtil.Service | Instance.Service>;

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

@@ -7,7 +7,6 @@ import { Snapshot } from "../snapshot.js";
 import { MessageNotFoundError } from "./error.js";
 import { SessionMessage } from "./message.js";
 import { SessionSchema } from "./schema.js";
-export { MessageNotFoundError };
 export declare const stage: (input: {
     session: SessionSchema.Info;
     messageID: SessionMessage.ID;
@@ -16,6 +15,6 @@ export declare const stage: (input: {
     messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
     snapshot: (string & import("effect/Brand").Brand<"Snapshot.ID">) | undefined;
     files: readonly import("@opencode/schema/file-diff").Info[];
-}, MessageNotFoundError | Snapshot.Error, Database.Service | Bus.Service | Instance.Service>;
-export declare const clear: (session: SessionSchema.Info) => Effect.Effect<void, Snapshot.Error, Bus.Service | Instance.Service>;
+}, MessageNotFoundError | import("../filesystem.js").DirectoryNotFoundError | Snapshot.Error, Database.Service | Bus.Service | Instance.Service>;
+export declare const clear: (session: SessionSchema.Info) => Effect.Effect<void, import("../filesystem.js").DirectoryNotFoundError | Snapshot.Error, Bus.Service | Instance.Service>;
 export declare const commit: (bus: Bus.Interface, session: SessionSchema.Info) => Effect.Effect<void, never, never>;

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

@@ -1,4 +1,5 @@
 export * as SessionRunner from "./index.js";
+import type { FileSystem } from "../../filesystem.js";
 import type { AIError } from "@opencode/ai";
 import { Context, Data, Effect } from "effect";
 import { SessionSchema } from "../schema.js";
@@ -6,7 +7,7 @@ import type { Promotable } from "../inbox.js";
 import type { AgentNotFoundError, MessageDecodeError, StepFailedError } from "../error.js";
 import { SessionRunnerModel } from "./model.js";
 import type { Instructions } from "../../instructions/index.js";
-export type RunError = AIError | SessionRunnerModel.Error | MessageDecodeError | AgentNotFoundError | StepFailedError | Instructions.InitializationBlocked;
+export type RunError = AIError | SessionRunnerModel.Error | MessageDecodeError | AgentNotFoundError | StepFailedError | Instructions.InitializationBlocked | FileSystem.DirectoryNotFoundError;
 export type Continuation = {
     readonly step: number;
 };

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

@@ -8,7 +8,7 @@ import { Bus } from "../bus.js";
 import { Database } from "../database/database.js";
 import { Instance } from "../instance/service.js";
 import type { Skill } from "../skill.js";
-import { BusyError, CompactionConflictError, InboxConflictError, MessageNotFoundError, NotFoundError, PromptConflictError, SyntheticConflictError } from "./error.js";
+import { BusyError, CompactionConflictError, InboxConflictError, NotFoundError, PromptConflictError, SyntheticConflictError } from "./error.js";
 import { SessionExecution } from "./execution.js";
 import { SessionInbox } from "./inbox.js";
 import { SessionMessage } from "./message.js";
@@ -185,7 +185,7 @@ export declare const make: () => Effect.Effect<{
             readonly time: {
                 readonly created: DateTime.Utc;
             };
-        }, NotFoundError | PromptConflictError | import("./error.js").AttachmentError | import("./error.js").SkillNotFoundError, never>;
+        }, NotFoundError | PromptConflictError | import("./error.js").AttachmentError | import("./error.js").SkillNotFoundError | import("../filesystem.js").DirectoryNotFoundError, never>;
         synthetic: (input: {
             id?: SessionMessage.ID;
             text: string;
@@ -217,7 +217,7 @@ export declare const make: () => Effect.Effect<{
             messageID?: SessionMessage.ID;
             skill: Skill.ID;
             resume?: boolean;
-        }) => Effect.Effect<void, NotFoundError | import("./error.js").SkillNotFoundError, never>;
+        }) => Effect.Effect<void, NotFoundError | import("./error.js").SkillNotFoundError | import("../filesystem.js").DirectoryNotFoundError, never>;
         compact: (input: {
             id?: SessionMessage.ID;
             delivery?: SessionInbox.Delivery;
@@ -247,8 +247,8 @@ export declare const make: () => Effect.Effect<{
                 messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
                 snapshot: (string & import("effect/Brand").Brand<"Snapshot.ID">) | undefined;
                 files: readonly import("@opencode/schema/file-diff").Info[];
-            }, NotFoundError | MessageNotFoundError | BusyError | import("../snapshot.js").Error, never>;
-            clear: () => Effect.Effect<void, NotFoundError | BusyError | import("../snapshot.js").Error, never>;
+            }, NotFoundError | import("./error.js").MessageNotFoundError | BusyError | import("../filesystem.js").DirectoryNotFoundError | import("../snapshot.js").Error, never>;
+            clear: () => Effect.Effect<void, NotFoundError | BusyError | import("../filesystem.js").DirectoryNotFoundError | import("../snapshot.js").Error, never>;
             commit: () => Effect.Effect<void, NotFoundError | BusyError, never>;
         };
     };

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

@@ -10,4 +10,4 @@ export declare const start: (input: {
     info: import("@opencode/schema/shell").Info;
     result: Effect.Effect<ShellResult.Result, never, never>;
     output: Effect.Effect<import("@opencode/schema/shell").Output, never, never>;
-}, import("@opencode/util/process").AppProcessError, Instance.Service>;
+}, import("@opencode/util/process").AppProcessError | import("../filesystem.js").DirectoryNotFoundError, Instance.Service>;

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

@@ -7,4 +7,4 @@ import { SkillNotFoundError } from "./error.js";
 export declare const get: (input: {
     session: Session.Info;
     skill: Skill.ID;
-}) => Effect.Effect<import("@opencode/schema/skill").Info, SkillNotFoundError, Instance.Service>;
+}) => Effect.Effect<import("@opencode/schema/skill").Info, SkillNotFoundError | import("../filesystem.js").DirectoryNotFoundError, Instance.Service>;

package/dist/types/session/to-session-error.d.ts

@@ -1,2 +1,4 @@
+import { type FinishReasonDetails } from "@opencode/ai";
 import { SessionError } from "@opencode/schema/session-error";
 export declare function toSessionError(cause: unknown): SessionError.Error;
+export declare function contentFilterError(summary: string, reason: FinishReasonDetails): SessionError.Error;

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

@@ -3,7 +3,6 @@ import { SessionTransfer } from "@opencode/schema/session-transfer";
 import { Context, Effect, Schema } from "effect";
 import { Location } from "../location.js";
 import { Session } from "../session.js";
-import { SessionEvent } from "./event.js";
 export declare const Data: Schema.Struct<{
     readonly info: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "SessionID"> & {
@@ -361,7 +360,7 @@ export declare const Data: Schema.Struct<{
                 readonly text: Schema.String;
             }>>, never, never>;
         }> & {
-            create: (input: SessionEvent.FileAttachment) => {
+            create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                 readonly data: string;
                 readonly source: {
                     readonly type: "inline";
@@ -399,7 +398,7 @@ export declare const Data: Schema.Struct<{
                 readonly text: Schema.String;
             }>>, never, never>;
         }> & {
-            create: (input: SessionEvent.FileAttachment) => {
+            create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                 readonly data: string;
                 readonly source: {
                     readonly type: "inline";

package/dist/types/session.d.ts

@@ -4,6 +4,7 @@ import { Effect, Schema, Context, Stream } from "effect";
 import { ListAnchor } from "@opencode/schema/session";
 import { Model } from "@opencode/schema/model";
 import { Location } from "./location.js";
+import type { FileSystem } from "./filesystem.js";
 import { SessionMessage } from "./session/message.js";
 import { PromptInput } from "@opencode/schema/prompt-input";
 import { SessionSchema } from "./session/schema.js";
@@ -150,7 +151,7 @@ export interface Interface {
         readonly from?: SessionMessage.ID;
         readonly to?: SessionMessage.ID;
         readonly context?: number;
-    }) => Effect.Effect<readonly FileDiff.Info[], NotFoundError | MessageNotFoundError | TurnRangeError | Snapshot.Error>;
+    }) => Effect.Effect<readonly FileDiff.Info[], NotFoundError | MessageNotFoundError | TurnRangeError | Snapshot.Error | FileSystem.DirectoryNotFoundError>;
     /**
      * Durable admitted session work not yet visible in projected history,
      * ordered by admission. Includes unpromoted user and synthetic inputs and
@@ -209,7 +210,7 @@ export interface Interface {
         agents?: PromptInput.Prompt["agents"];
         skills?: PromptInput.Prompt["skills"];
         delivery?: SessionInbox.Delivery;
-    }) => Effect.Effect<void, NotFoundError | Command.NotFoundError | Command.ExecutionError>;
+    }) => Effect.Effect<void, NotFoundError | Command.NotFoundError | Command.ExecutionError | FileSystem.DirectoryNotFoundError>;
     readonly shell: (input: Parameters<Session.Handle["shell"]>[0] & {
         sessionID: SessionSchema.ID;
     }) => ReturnType<Session.Handle["shell"]>;
@@ -232,8 +233,8 @@ export interface Interface {
             sessionID: SessionSchema.ID;
             messageID: SessionMessage.ID;
             files?: boolean;
-        }) => Effect.Effect<SessionSchema.Revert, NotFoundError | MessageNotFoundError | BusyError | Snapshot.Error>;
-        readonly clear: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | BusyError | Snapshot.Error>;
+        }) => Effect.Effect<SessionSchema.Revert, NotFoundError | MessageNotFoundError | BusyError | Snapshot.Error | FileSystem.DirectoryNotFoundError>;
+        readonly clear: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | BusyError | Snapshot.Error | FileSystem.DirectoryNotFoundError>;
         readonly commit: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | BusyError>;
     };
 }

package/dist/types/tool-output.d.ts

@@ -6,6 +6,7 @@ export declare const MAX_LINES = 2000;
 export declare const MAX_BYTES: number;
 export declare const RETENTION: Duration.Duration;
 export declare const DIRECTORY = "tool-output";
+export declare const fileName: (timestamp?: number) => string;
 type Result = Tool.NormalizedResult;
 type Limits = {
     maxLines: number;