@opencode/core 0.0.0-dev-19787 → 0.0.0-dev-19790

package/dist/tool.js

@@ -1,29 +1,29 @@
 import {
   RegistrationError2,
-  Service41,
-  node44,
+  Service28,
+  node31,
   exports_tool,
   CallID2,
-  Content3,
-  Error3,
+  Content2,
+  Error2,
   FileContent3,
   TextContent2
-} from "./chunks/pty-9yyvrqyy.js";
+} from "./chunks/pty-5j6bqzeb.js";
 import"./chunks/pty-k3c624dm.js";
 import"./chunks/pty-m3fdjcah.js";
 import"./chunks/pty-3w5fmr99.js";
-import"./chunks/pty-3b9qt4hj.js";
+import"./chunks/pty-zg3tcem2.js";
 import"./chunks/pty-y1fvbwt7.js";
-import"./chunks/pty-k1gkpfdk.js";
+import"./chunks/pty-gs3s1a1g.js";
 import"./chunks/pty-rdw6cm16.js";
 export {
   CallID2 as CallID,
-  Content3 as Content,
-  Error3 as Error,
+  Content2 as Content,
+  Error2 as Error,
   FileContent3 as FileContent,
   RegistrationError2 as RegistrationError,
-  Service41 as Service,
+  Service28 as Service,
   TextContent2 as TextContent,
   exports_tool as Tool,
-  node44 as node
+  node31 as node
 };

package/dist/types/agent.d.ts

@@ -57,7 +57,20 @@ export declare const Info: import("effect/Schema").Struct<{
         };
     }>, never, never>;
     readonly request: import("effect/Schema").Struct<{
-        readonly settings: import("effect/Schema").withConstructorDefault<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>>;
+        readonly settings: import("effect/Schema").withConstructorDefault<import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+            readonly timeout: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Union<readonly [import("effect/Schema").Finite, import("effect/Schema").Literal<false>]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Union<readonly [import("effect/Schema").Finite, import("effect/Schema").Literal<false>]>>, never, never>;
+            readonly chunkTimeout: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Finite>>, import("effect/Schema").optionalKey<import("effect/Schema").Finite>, 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 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 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>;
+        }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>]>>;
         readonly headers: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").String>;
         readonly body: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Any>;
     }>;

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

@@ -147,9 +147,9 @@ export interface Resolved {
     /** 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"];
+    readonly compaction?: Provider.Compaction;
     /** Model transport overrides the provider transport; omitted means HTTP. */
-    readonly transport?: Info["transport"];
+    readonly transport?: Provider.Transport;
 }
 export interface Interface {
     readonly resolve: (requested?: Ref) => Effect.Effect<Resolved | undefined, Error>;

package/dist/types/model.d.ts

@@ -92,7 +92,33 @@ 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 timeout: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Union<readonly [import("effect/Schema").Finite, import("effect/Schema").Literal<false>]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Union<readonly [import("effect/Schema").Finite, import("effect/Schema").Literal<false>]>>, never, never>;
+            readonly chunkTimeout: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Finite>>, import("effect/Schema").optionalKey<import("effect/Schema").Finite>, 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 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 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>;
+        }>, 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 timeout: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Union<readonly [import("effect/Schema").Finite, import("effect/Schema").Literal<false>]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Union<readonly [import("effect/Schema").Finite, import("effect/Schema").Literal<false>]>>, never, never>;
+            readonly chunkTimeout: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Finite>>, import("effect/Schema").optionalKey<import("effect/Schema").Finite>, 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 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 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>;
+        }>, 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 +156,33 @@ 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 timeout: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Union<readonly [import("effect/Schema").Finite, import("effect/Schema").Literal<false>]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Union<readonly [import("effect/Schema").Finite, import("effect/Schema").Literal<false>]>>, never, never>;
+        readonly chunkTimeout: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Finite>>, import("effect/Schema").optionalKey<import("effect/Schema").Finite>, 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 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 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>;
+    }>, 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 timeout: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Union<readonly [import("effect/Schema").Finite, import("effect/Schema").Literal<false>]>>>, import("effect/Schema").optionalKey<import("effect/Schema").Union<readonly [import("effect/Schema").Finite, import("effect/Schema").Literal<false>]>>, never, never>;
+        readonly chunkTimeout: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Finite>>, import("effect/Schema").optionalKey<import("effect/Schema").Finite>, 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 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 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>;
+    }>, 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 +243,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">;

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

@@ -44,15 +44,75 @@ export declare function mergeHeaders(base: Readonly<Record<string, string>> | un
     [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 +157,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/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/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,21 @@ 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 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;
@@ -170,13 +179,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 +192,15 @@ 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 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;

package/dist/v1/config/agent.js

@@ -1,10 +1,10 @@
 import {
-  Info19,
-  exports_agent4
-} from "../../chunks/pty-dhwr7h25.js";
-import"../../chunks/pty-vsp1fds9.js";
+  Info11,
+  exports_agent3
+} from "../../chunks/pty-1qg96azw.js";
+import"../../chunks/pty-magykp64.js";
 import"../../chunks/pty-922hggd3.js";
 export {
-  exports_agent4 as ConfigAgentV1,
-  Info19 as Info
+  exports_agent3 as ConfigAgentV1,
+  Info11 as Info
 };

package/dist/v1/config/attachment.js

@@ -1,11 +1,11 @@
 import {
   Image2,
-  Info21,
+  Info13,
   exports_attachment
-} from "../../chunks/pty-z3pw5915.js";
+} from "../../chunks/pty-evbgk2k8.js";
 import"../../chunks/pty-922hggd3.js";
 export {
   exports_attachment as ConfigAttachmentV1,
   Image2 as Image,
-  Info21 as Info
+  Info13 as Info
 };

package/dist/v1/config/command.js

@@ -1,8 +1,8 @@
 import {
-  Info17,
+  Info14,
   exports_command5
-} from "../../chunks/pty-fm2qvscf.js";
+} from "../../chunks/pty-qa3qhgw8.js";
 export {
   exports_command5 as ConfigCommandV1,
-  Info17 as Info
+  Info14 as Info
 };

package/dist/v1/config/config.js

@@ -1,23 +1,23 @@
 import {
   WellKnown2,
-  Info16,
+  Info9,
   exports_config2
-} from "../../chunks/pty-4kyk22vj.js";
-import"../../chunks/pty-fm2qvscf.js";
-import"../../chunks/pty-7dqw4kz8.js";
-import"../../chunks/pty-gzbkpp9m.js";
-import"../../chunks/pty-dhwr7h25.js";
-import"../../chunks/pty-vsp1fds9.js";
-import"../../chunks/pty-z3pw5915.js";
-import"../../chunks/pty-p1nm93x7.js";
+} from "../../chunks/pty-8hdvkfsn.js";
+import"../../chunks/pty-rhx683sy.js";
+import"../../chunks/pty-1qg96azw.js";
+import"../../chunks/pty-607tc6va.js";
 import"../../chunks/pty-zeh9ct20.js";
-import"../../chunks/pty-qz49fwgp.js";
-import"../../chunks/pty-qq11w61w.js";
+import"../../chunks/pty-vyqn3nqs.js";
+import"../../chunks/pty-evbgk2k8.js";
+import"../../chunks/pty-qa3qhgw8.js";
+import"../../chunks/pty-magykp64.js";
+import"../../chunks/pty-af04s6ss.js";
 import"../../chunks/pty-21r38tys.js";
-import"../../chunks/pty-809q4hne.js";
+import"../../chunks/pty-510m7gjw.js";
+import"../../chunks/pty-ve4pfa0n.js";
 import"../../chunks/pty-922hggd3.js";
 export {
   exports_config2 as ConfigV1,
-  Info16 as Info,
+  Info9 as Info,
   WellKnown2 as WellKnown
 };

package/dist/v1/config/error.js

@@ -4,11 +4,11 @@ import {
   FrontmatterError2,
   DirectoryTypoError2,
   RemoteAuthError2,
-  exports_error2
-} from "../../chunks/pty-29x78va6.js";
+  exports_error
+} from "../../chunks/pty-z63w68vq.js";
 import"../../chunks/pty-2axfhc9x.js";
 export {
-  exports_error2 as ConfigErrorV1,
+  exports_error as ConfigErrorV1,
   DirectoryTypoError2 as DirectoryTypoError,
   FrontmatterError2 as FrontmatterError,
   InvalidError2 as InvalidError,

package/dist/v1/config/formatter.js

@@ -1,10 +1,10 @@
 import {
   Entry3,
-  Info18,
+  Info12,
   exports_formatter3
-} from "../../chunks/pty-gzbkpp9m.js";
+} from "../../chunks/pty-vyqn3nqs.js";
 export {
   exports_formatter3 as ConfigFormatterV1,
   Entry3 as Entry,
-  Info18 as Info
+  Info12 as Info
 };

package/dist/v1/config/lsp.js

@@ -1,16 +1,16 @@
 import {
   Disabled2,
-  Entry4,
+  Entry2,
   builtinServerIds2,
   requiresExtensionsForCustomServers2,
-  Info23,
+  Info10,
   exports_lsp
-} from "../../chunks/pty-qz49fwgp.js";
+} from "../../chunks/pty-rhx683sy.js";
 export {
   exports_lsp as ConfigLSPV1,
   Disabled2 as Disabled,
-  Entry4 as Entry,
-  Info23 as Info,
+  Entry2 as Entry,
+  Info10 as Info,
   builtinServerIds2 as builtinServerIds,
   requiresExtensionsForCustomServers2 as requiresExtensionsForCustomServers
 };