@opencode/core 2.0.7 → 2.0.9

package/dist/types/instance.d.ts

@@ -51,7 +51,7 @@ 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 | ReadToolFileSystem.Service | SessionInstructions.Service | Shell.Service | Skill.Service | InstructionDiscovery.Service | SessionCompaction.Service | Snapshot.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, 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 interface Options {

package/dist/types/job.d.ts

@@ -98,6 +98,9 @@ export declare class Service extends Service_base {
 /**
  * Makes one scoped, process-local registry. Explicitly recoverable background
  * work also owns a durable notification marker until its notification is admitted.
+ * Unconsumed results survive the start-to-wait handoff. Foreground block/cancel
+ * and non-recoverable wait results enter a 25-entry consumed history. Recoverable
+ * wait results stay available for background registration and acknowledgment.
  */
 export declare const make: Effect.Effect<Interface, never, Scope.Scope | KV.Service>;
 export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;

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

@@ -5,6 +5,7 @@ import { AISDK } from "./aisdk.js";
 import { Credential } from "./credential.js";
 import { Integration } from "./integration.js";
 import { Capabilities, Info, Model, Ref, VariantID } from "./model.js";
+import type { RuntimeInfo } from "./model.js";
 import { Npm } from "@opencode/util/npm";
 import { Provider } from "./provider.js";
 declare const VariantUnavailableError_base: Schema.Class<VariantUnavailableError, Schema.TaggedStruct<"SessionRunnerModel.VariantUnavailableError", {
@@ -146,10 +147,10 @@ export interface Resolved {
     readonly cost: Info["cost"];
     /** Catalog token limits used by Core for context management. */
     readonly limit: Info["limit"];
-    /** Model policy overrides the provider policy; omitted means local compaction. */
-    readonly compaction?: Info["compaction"];
-    /** Model transport overrides the provider transport; omitted means HTTP. */
-    readonly transport?: Info["transport"];
+    /** Model policy overrides the provider policy; omitted means summary compaction. */
+    readonly compaction?: Provider.Compaction;
+    /** Provider transport policy; omitted means HTTP. */
+    readonly transport?: Provider.Transport;
 }
 export interface Interface {
     readonly resolve: (requested?: Ref) => Effect.Effect<Resolved | undefined, Error>;
@@ -161,9 +162,9 @@ export declare class Service extends Service_base {
 export declare const withVariant: (model: Info, variantID: VariantID | undefined) => Effect.Effect<Info, VariantUnavailableError>;
 export interface Dependencies {
     readonly loadPackage?: (specifier: string) => Effect.Effect<Provider.ProviderPackage, Provider.LoadError>;
-    readonly loadAISDK?: (model: Info) => Effect.Effect<LanguageModel, AISDK.InitError>;
+    readonly loadAISDK?: (model: RuntimeInfo) => Effect.Effect<LanguageModel, AISDK.InitError>;
 }
-export declare const fromCatalogModel: (model: Info, credential?: Credential.Value, dependencies?: Dependencies) => Effect.Effect<LanguageModel, UnsupportedPackageError | ModelConfigurationError | ModelInitializationError | UnresolvedProviderVariablesError | UnsupportedCompactionError>;
+export declare const fromCatalogModel: (model: RuntimeInfo, credential?: Credential.Value, dependencies?: Dependencies) => Effect.Effect<LanguageModel, UnsupportedPackageError | ModelConfigurationError | ModelInitializationError | UnresolvedProviderVariablesError | UnsupportedCompactionError>;
 export declare const resolveModel: (model: Info, variant: VariantID | undefined, credential?: Credential.Value, dependencies?: Dependencies) => Effect.Effect<LanguageModel<{
     readonly [x: string]: unknown;
 }, import("@opencode/ai/route").CompactionOperations | undefined>, VariantUnavailableError | UnsupportedPackageError | ModelConfigurationError | ModelInitializationError | UnresolvedProviderVariablesError | UnsupportedCompactionError, never>;

package/dist/types/model.d.ts

@@ -92,7 +92,27 @@ export declare const Info: import("effect/Schema").Struct<{
         };
     };
     readonly variants: import("effect/Schema").$Array<import("effect/Schema").Struct<{
-        readonly settings: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>>, never, never>;
+        readonly settings: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+            readonly compaction: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                readonly type: import("effect/Schema").Literal<"summary">;
+            }>, import("effect/Schema").Struct<{
+                readonly type: import("effect/Schema").Literal<"native">;
+            }>]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                readonly type: import("effect/Schema").Literal<"summary">;
+            }>, import("effect/Schema").Struct<{
+                readonly type: import("effect/Schema").Literal<"native">;
+            }>]>>, never, never>;
+        }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>]>>>, import("effect/Schema").optionalKey<import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+            readonly compaction: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                readonly type: import("effect/Schema").Literal<"summary">;
+            }>, import("effect/Schema").Struct<{
+                readonly type: import("effect/Schema").Literal<"native">;
+            }>]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                readonly type: import("effect/Schema").Literal<"summary">;
+            }>, import("effect/Schema").Struct<{
+                readonly type: import("effect/Schema").Literal<"native">;
+            }>]>>, never, never>;
+        }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>]>>, never, never>;
         readonly headers: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>, never, never>;
         readonly body: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>>, never, never>;
         readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Model.VariantID">;
@@ -130,7 +150,27 @@ export declare const Info: import("effect/Schema").Struct<{
         readonly input: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Int>>, import("effect/Schema").optionalKey<import("effect/Schema").Int>, never, never>;
         readonly output: import("effect/Schema").Int;
     }>;
-    readonly settings: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>>, never, never>;
+    readonly settings: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+        readonly compaction: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"summary">;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"native">;
+        }>]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"summary">;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"native">;
+        }>]>>, never, never>;
+    }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>]>>>, import("effect/Schema").optionalKey<import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+        readonly compaction: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"summary">;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"native">;
+        }>]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"summary">;
+        }>, import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"native">;
+        }>]>>, never, never>;
+    }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>]>>, never, never>;
     readonly headers: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>>, never, never>;
     readonly body: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>>, never, never>;
     readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Model.ID">;
@@ -191,18 +231,6 @@ export declare const Info: import("effect/Schema").Struct<{
         readonly supportsPromptCacheKey: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
     }>>, never, never>;
     readonly package: 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 compaction: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
-        readonly mode: import("effect/Schema").Literal<"local">;
-    }>, import("effect/Schema").Struct<{
-        readonly mode: import("effect/Schema").Literal<"provider">;
-        readonly threshold: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Int>>, import("effect/Schema").optionalKey<import("effect/Schema").Int>, never, never>;
-    }>]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
-        readonly mode: import("effect/Schema").Literal<"local">;
-    }>, import("effect/Schema").Struct<{
-        readonly mode: import("effect/Schema").Literal<"provider">;
-        readonly threshold: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Int>>, import("effect/Schema").optionalKey<import("effect/Schema").Int>, never, never>;
-    }>]>>, never, never>;
-    readonly transport: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Literals<readonly ["http", "websocket"]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Literals<readonly ["http", "websocket"]>>, never, never>;
 }> & {
     default: (providerID: import("@opencode/schema/provider").ID, id: Model.ID) => {
         id: string & import("effect/Brand").Brand<"Model.ID">;
@@ -228,6 +256,10 @@ export declare const Info: import("effect/Schema").Struct<{
     };
 };
 export type Info = Model.Info;
+/** Effective provider and model settings used only while constructing a runtime model. */
+export type RuntimeInfo = Omit<Info, "settings"> & {
+    readonly settings?: Provider.Settings;
+};
 export type MutableInfo = DeepMutable<Info>;
 export { Event } from "@opencode/schema/model";
 export interface Editor {

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

@@ -0,0 +1,3 @@
+export * as NativeCompactionPlugin from "./compaction.js";
+import { SessionCompaction } from "../session/compaction.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | import("@opencode/ai").LLMClientService | SessionCompaction.Service>;

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

@@ -48,9 +48,9 @@ import { ReadToolFileSystem } from "../tool/read-filesystem.js";
 import { Tool } from "../tool.js";
 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 Location.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];
+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 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 | 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 | ReadToolFileSystem.Service | SessionInstructions.Service | Session.Service | Job.Service | Shell.Service | Skill.Service | LocationWatcherPolicy.Service | InstructionDiscovery.Service | SessionCompaction.Service | Snapshot.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 | 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 type InternalPlugin = Plugin<Requirements | Scope.Scope>;
 export declare const list: () => Effect.Effect<{
     pre: Plugin<Scope.Scope>[];

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

@@ -1,9 +1,5 @@
 import { Effect } from "effect";
 import type { Entry } from "@opencode/schema/config";
 import { Provider } from "../../provider.js";
-export declare const configuredSettings: (id: string & import("effect/Brand").Brand<"Provider.ID">) => Effect.Effect<{
-    readonly [x: string]: any;
-} | undefined, never, Provider.Service>;
-export declare function foldSettings(entries: readonly Entry[], id: string, initial: Provider.Settings | undefined): {
-    readonly [x: string]: any;
-} | undefined;
+export declare const configuredSettings: (id: string & import("effect/Brand").Brand<"Provider.ID">) => Effect.Effect<Record<string, import("effect/Schema").Json> | undefined, never, Provider.Service>;
+export declare function foldSettings(entries: readonly Entry[], id: string, initial: Provider.Settings | undefined): Record<string, import("effect/Schema").Json> | undefined;

package/dist/types/plugin/tool-input-repair.d.ts

@@ -0,0 +1,2 @@
+export * as ToolInputRepairPlugin from "./tool-input-repair.js";
+export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>;

package/dist/types/provider.d.ts

@@ -39,20 +39,83 @@ export declare const loadPackage: (input: string, npm?: Npm.Interface | undefine
     readonly [x: string]: unknown;
 }, import("@opencode/ai/route").CompactionOperations | undefined>, LoadError, never>;
 export declare function nativeSettings(settings: Settings): Settings;
+export declare function modelSettings(settings: Settings | undefined): {
+    readonly [x: string]: any;
+} | undefined;
 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;
 } | undefined;
 export declare const Request: Schema.Struct<{
-    readonly settings: Schema.withConstructorDefault<Schema.$Record<Schema.String, Schema.Any>>;
+    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 compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>, never, never>;
+        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>]>>;
     readonly headers: Schema.$Record<Schema.String, Schema.String>;
     readonly body: Schema.$Record<Schema.String, Schema.Any>;
 }>;
 export type Request = Provider.Request;
-export declare const Settings: Schema.$Record<Schema.String, Schema.Any>;
+export declare const Compaction: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"summary">;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"native">;
+}>]>;
+export type Compaction = Provider.Compaction;
+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 compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"summary">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"native">;
+    }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"summary">;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"native">;
+    }>]>>, never, never>;
+    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>]>;
 export type Settings = Provider.Settings;
 export declare const Info: Schema.Struct<{
-    readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+    readonly 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 compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>, never, never>;
+        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 compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"summary">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"native">;
+        }>]>>, never, never>;
+        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>]>>, never, never>;
     readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
     readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
     readonly id: Schema.brand<Schema.String, "Provider.ID"> & {
@@ -97,18 +160,6 @@ export declare const Info: Schema.Struct<{
     readonly name: Schema.String;
     readonly activation: Schema.Literals<readonly ["auto", "enabled", "disabled"]>;
     readonly package: Schema.String;
-    readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
-        readonly mode: Schema.Literal<"local">;
-    }>, Schema.Struct<{
-        readonly mode: Schema.Literal<"provider">;
-        readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
-    }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
-        readonly mode: Schema.Literal<"local">;
-    }>, Schema.Struct<{
-        readonly mode: Schema.Literal<"provider">;
-        readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
-    }>]>>, never, never>;
-    readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
 }> & {
     empty: (id: Provider.ID) => Provider.Info;
 };

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

@@ -1,5 +1,6 @@
 export * as SessionCompaction from "./compaction.js";
-import { Message } from "@opencode/ai";
+import { AIError, LLMRequest, Message, type Usage } from "@opencode/ai";
+import type { StreamOptions } from "@opencode/ai/route";
 import { Context, Effect, Layer } from "effect";
 import { Bus } from "../bus.js";
 import { Database } from "../database/database.js";
@@ -16,8 +17,22 @@ export type Settings = {
     buffer: number;
     tokens: number;
 };
+export type NativeInput = {
+    readonly request: LLMRequest;
+    readonly options: StreamOptions;
+    /** Whole, real user messages within the retained-token allowance, for checkpoint-only mechanisms. */
+    readonly retained: Effect.Effect<ReadonlyArray<Message>>;
+};
+export type NativeResult = {
+    readonly replacement: ReadonlyArray<Message>;
+    readonly usage?: Usage;
+};
+/** Returns the provider's replacement window, or `undefined` when this strategy has no mechanism for the route. */
+export type NativeStrategy = (input: NativeInput) => Effect.Effect<NativeResult, AIError> | undefined;
 export type Editor = {
     configure: (settings: Partial<Settings>) => void;
+    /** Later registrations take precedence. */
+    native: (strategy: NativeStrategy) => void;
 };
 export type AutoInput = {
     readonly context: SessionContext.Loaded;

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

@@ -44,5 +44,5 @@ declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionRest
  */
 export declare class Service extends Service_base {
 }
-export declare const layer: (options?: Options) => Layer.Layer<Service, never, Bus.Service | SessionStore.Service | Session.Service | Job.Service | SessionExecution.Service>;
+export declare const layer: (options?: Options) => Layer.Layer<Service, never, Bus.Service | SessionStore.Service | Job.Service | Session.Service | SessionExecution.Service>;
 export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;

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

@@ -324,8 +324,8 @@ export declare const decodeMessageRow: (row: typeof SessionMessageTable.$inferSe
     readonly time: {
         readonly created: import("effect/DateTime").Utc;
     };
-    readonly reason: "auto" | "manual";
     readonly summary: string;
+    readonly reason: "auto" | "manual";
     readonly recent: string;
     readonly metadata?: {
         readonly [x: string]: unknown;
@@ -337,8 +337,8 @@ export declare const decodeMessageRow: (row: typeof SessionMessageTable.$inferSe
     readonly time: {
         readonly created: import("effect/DateTime").Utc;
     };
-    readonly reason: "auto" | "manual";
     readonly summary: string;
+    readonly reason: "auto" | "manual";
     readonly recent: string;
     readonly metadata?: {
         readonly [x: string]: unknown;
@@ -722,8 +722,8 @@ export declare const load: (db: import("../database/drizzle.js").EffectSQLiteDat
     readonly time: {
         readonly created: import("effect/DateTime").Utc;
     };
-    readonly reason: "auto" | "manual";
     readonly summary: string;
+    readonly reason: "auto" | "manual";
     readonly recent: string;
     readonly metadata?: {
         readonly [x: string]: unknown;
@@ -735,8 +735,8 @@ export declare const load: (db: import("../database/drizzle.js").EffectSQLiteDat
     readonly time: {
         readonly created: import("effect/DateTime").Utc;
     };
-    readonly reason: "auto" | "manual";
     readonly summary: string;
+    readonly reason: "auto" | "manual";
     readonly recent: string;
     readonly metadata?: {
         readonly [x: string]: unknown;
@@ -1124,8 +1124,8 @@ export declare const entriesForRunner: (db: import("../database/drizzle.js").Eff
             readonly time: {
                 readonly created: import("effect/DateTime").Utc;
             };
-            readonly reason: "auto" | "manual";
             readonly summary: string;
+            readonly reason: "auto" | "manual";
             readonly recent: string;
             readonly metadata?: {
                 readonly [x: string]: unknown;
@@ -1137,8 +1137,8 @@ export declare const entriesForRunner: (db: import("../database/drizzle.js").Eff
             readonly time: {
                 readonly created: import("effect/DateTime").Utc;
             };
-            readonly reason: "auto" | "manual";
             readonly summary: string;
+            readonly reason: "auto" | "manual";
             readonly recent: string;
             readonly metadata?: {
                 readonly [x: string]: unknown;
@@ -1526,8 +1526,8 @@ export declare const preview: (db: import("../database/drizzle.js").EffectSQLite
         readonly time: {
             readonly created: import("effect/DateTime").Utc;
         };
-        readonly reason: "auto" | "manual";
         readonly summary: string;
+        readonly reason: "auto" | "manual";
         readonly recent: string;
         readonly metadata?: {
             readonly [x: string]: unknown;
@@ -1539,8 +1539,8 @@ export declare const preview: (db: import("../database/drizzle.js").EffectSQLite
         readonly time: {
             readonly created: import("effect/DateTime").Utc;
         };
-        readonly reason: "auto" | "manual";
         readonly summary: string;
+        readonly reason: "auto" | "manual";
         readonly recent: string;
         readonly metadata?: {
             readonly [x: string]: unknown;

package/dist/types/tool/plugin/shell.d.ts

@@ -19,5 +19,5 @@ export declare const Input: Schema.Struct<{
 }>;
 export declare const Plugin: {
     id: string;
-    effect: (ctx: Context) => Effect.Effect<void, never, Scope.Scope | Config.Service | Permission.Service | Environment.Service | FileAccess.Service | ShellSelect.Service | Session.Service | Job.Service | Shell.Service>;
+    effect: (ctx: Context) => Effect.Effect<void, never, Scope.Scope | Config.Service | Permission.Service | Environment.Service | FileAccess.Service | ShellSelect.Service | Job.Service | Session.Service | Shell.Service>;
 };

package/dist/types/tool/plugin/subagent.d.ts

@@ -30,5 +30,5 @@ export declare const Output: Schema.Struct<{
 export declare const description: string;
 export declare const Plugin: {
     id: string;
-    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Agent.Service | Model.Service | Config.Service | Permission.Service | Session.Service | Job.Service>;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Agent.Service | Model.Service | Config.Service | Permission.Service | Job.Service | Session.Service>;
 };

package/dist/types/tool.d.ts

@@ -29,6 +29,9 @@ export interface Editor {
     readonly remove: (id: string) => void;
 }
 export interface Interface extends State.Transformable<Editor> {
+    readonly list: () => Effect.Effect<ReadonlyArray<Tool.Info & {
+        readonly id: string;
+    }>>;
     readonly snapshot: (permissions?: Permission.Ruleset) => Effect.Effect<Snapshot>;
 }
 /** A local execution result after hooks and content normalization. */

package/dist/types/v1/config/migrate.d.ts

@@ -116,14 +116,14 @@ export declare function migrate(info: typeof ConfigV1.Info.Type): {
                     readonly auth_server_metadata_url?: string | undefined;
                 } | undefined;
                 readonly disabled?: boolean | undefined;
-                readonly headers?: {
-                    readonly [x: string]: string;
-                } | undefined;
                 readonly timeout?: {
                     readonly startup?: number | undefined;
                     readonly catalog?: number | undefined;
                     readonly execution?: number | undefined;
                 } | undefined;
+                readonly headers?: {
+                    readonly [x: string]: string;
+                } | undefined;
                 readonly protocol?: "auto" | "legacy" | "2026-07-28" | undefined;
                 readonly codemode?: boolean | undefined;
             };
@@ -141,7 +141,15 @@ export declare function migrate(info: typeof ConfigV1.Info.Type): {
             readonly canonical?: string | undefined;
             readonly env?: readonly string[] | undefined;
             readonly settings?: {
-                readonly [x: string]: Schema.Json;
+                readonly [x: string]: Schema.Json | undefined;
+                readonly timeout?: number | false | undefined;
+                readonly chunkTimeout?: number | undefined;
+                readonly compaction?: {
+                    readonly type: "summary";
+                } | {
+                    readonly type: "native";
+                } | undefined;
+                readonly transport?: "http" | "websocket" | undefined;
             } | undefined;
             readonly headers?: {
                 readonly [x: string]: string;
@@ -149,20 +157,18 @@ export declare function migrate(info: typeof ConfigV1.Info.Type): {
             readonly body?: {
                 readonly [x: string]: Schema.Json;
             } | undefined;
-            readonly compaction?: {
-                readonly mode: "local";
-            } | {
-                readonly mode: "provider";
-                readonly threshold?: number | undefined;
-            } | undefined;
-            readonly transport?: "http" | "websocket" | undefined;
             readonly package?: string | undefined;
             readonly models?: {
                 readonly [x: string]: {
                     readonly name?: string | undefined;
                     readonly disabled?: boolean | undefined;
                     readonly settings?: {
-                        readonly [x: string]: Schema.Json;
+                        readonly [x: string]: Schema.Json | undefined;
+                        readonly compaction?: {
+                            readonly type: "summary";
+                        } | {
+                            readonly type: "native";
+                        } | undefined;
                     } | undefined;
                     readonly headers?: {
                         readonly [x: string]: string;
@@ -170,13 +176,6 @@ export declare function migrate(info: typeof ConfigV1.Info.Type): {
                     readonly body?: {
                         readonly [x: string]: Schema.Json;
                     } | undefined;
-                    readonly compaction?: {
-                        readonly mode: "local";
-                    } | {
-                        readonly mode: "provider";
-                        readonly threshold?: number | undefined;
-                    } | undefined;
-                    readonly transport?: "http" | "websocket" | undefined;
                     readonly package?: string | undefined;
                     readonly family?: string | undefined;
                     readonly compatibility?: {
@@ -190,7 +189,12 @@ export declare function migrate(info: typeof ConfigV1.Info.Type): {
                     readonly variants?: readonly {
                         readonly id: string;
                         readonly settings?: {
-                            readonly [x: string]: Schema.Json;
+                            readonly [x: string]: Schema.Json | undefined;
+                            readonly compaction?: {
+                                readonly type: "summary";
+                            } | {
+                                readonly type: "native";
+                            } | undefined;
                         } | undefined;
                         readonly headers?: {
                             readonly [x: string]: string;

package/dist/util/error-summary.js

@@ -1,7 +1,7 @@
 import {
   from2,
   exports_error_summary
-} from "../chunks/integration-0q0f95c6.js";
+} from "../chunks/tool-0q0f95c6.js";
 export {
   exports_error_summary as ErrorSummary,
   from2 as from

package/dist/util/error.js

@@ -1,6 +1,6 @@
 import {
   NamedError2
-} from "../chunks/integration-2axfhc9x.js";
+} from "../chunks/tool-2axfhc9x.js";
 export {
   NamedError2 as NamedError
 };

package/dist/util/git-executable.js

@@ -1,8 +1,8 @@
 import {
   resolveGitExecutable2,
   gitExecutable2
-} from "../chunks/integration-ef5x83kb.js";
-import"../chunks/integration-qaymkmh1.js";
+} from "../chunks/tool-ef5x83kb.js";
+import"../chunks/tool-qaymkmh1.js";
 export {
   gitExecutable2 as gitExecutable,
   resolveGitExecutable2 as resolveGitExecutable

package/dist/util/iife.js

@@ -1,6 +1,6 @@
 import {
   iife2
-} from "../chunks/integration-1kg9ymc8.js";
+} from "../chunks/tool-1kg9ymc8.js";
 export {
   iife2 as iife
 };

package/dist/util/lazy.js

@@ -1,6 +1,6 @@
 import {
   lazy2
-} from "../chunks/integration-88xbtdfr.js";
+} from "../chunks/tool-88xbtdfr.js";
 export {
   lazy2 as lazy
 };

package/dist/util/slug.js

@@ -1,6 +1,6 @@
 import {
   Slug2
-} from "../chunks/integration-gebd4c9n.js";
+} from "../chunks/tool-gebd4c9n.js";
 export {
   Slug2 as Slug
 };

package/dist/util/token.js

@@ -1,7 +1,7 @@
 import {
   estimate2,
   exports_token
-} from "../chunks/integration-h6vf3j39.js";
+} from "../chunks/tool-h6vf3j39.js";
 export {
   exports_token as Token,
   estimate2 as estimate