@opencode/schema 2.0.26 → 2.0.28

package/dist/agent.d.ts

@@ -71,6 +71,7 @@ export declare const Info: 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 encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, 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>;

package/dist/agent.js

@@ -7,7 +7,7 @@ import { Permission } from "./permission.js";
 import { Provider } from "./provider.js";
 import { PositiveInt, statics } from "./schema.js";
 const Updated = ephemeral({ type: "agent.updated", schema: {} });
-export const ID = Schema.String.pipe(Schema.brand("Agent.ID"));
+export const ID = Schema.String.pipe(Schema.brand("Agent.ID"), Schema.annotate({ identifier: "Agent.ID" }));
 export const Name = Schema.String.pipe(Schema.brand("Agent.Name"));
 export const Color = Schema.String.annotate({ identifier: "Agent.Color" });
 export const Info = Schema.Struct({

package/dist/config/agent.js

@@ -4,7 +4,7 @@ import { Permission } from "../permission.js";
 import { optional, PositiveInt } from "../schema.js";
 import { ConfigModel } from "./model.js";
 import { ConfigProvider } from "./provider.js";
-export const Color = Schema.String.check(Schema.isPattern(/^#[0-9a-fA-F]{6}$/));
+export const Color = Schema.String.check(Schema.isPattern(/^#[0-9a-fA-F]{6}$/u));
 export class Info extends Schema.Class("Config.Agent")({
     model: ConfigModel.Selection.pipe(optional),
     request: ConfigProvider.Request.pipe(optional),

package/dist/config/model.js

@@ -3,15 +3,15 @@ import { Schema, SchemaGetter } from "effect";
 import { Model } from "../model.js";
 import { Provider } from "../provider.js";
 import { optional } from "../schema.js";
-const ProviderID = Provider.ID.check(Schema.isPattern(/^[^/#]+$/));
-const ModelID = Model.ID.check(Schema.isPattern(/^[^#]+$/));
-const VariantID = Model.VariantID.check(Schema.isPattern(/^[^#]+$/));
+const ProviderID = Provider.ID.check(Schema.isPattern(/^[^/#]+$/u));
+const ModelID = Model.ID.check(Schema.isPattern(/^[^#]+$/u));
+const VariantID = Model.VariantID.check(Schema.isPattern(/^[^#]+$/u));
 const Explicit = Schema.Struct({
     providerID: ProviderID,
     model: ModelID,
     variant: VariantID.pipe(optional),
 });
-const Short = Schema.String.check(Schema.isPattern(/^[^/#]+\/[^#]+(?:#[^#]+)?$/));
+const Short = Schema.String.check(Schema.isPattern(/^[^/#]+\/[^#]+(?:#[^#]+)?$/u));
 export const Selection = Schema.Union([Short, Explicit])
     .pipe(Schema.decodeTo(Explicit, {
     decode: SchemaGetter.transform((input) => (typeof input === "string" ? parse(input) : input)),

package/dist/config/provider.d.ts

@@ -14,6 +14,7 @@ export declare const Settings: Schema.StructWithRest<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 encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
 }>, readonly [Schema.$Record<Schema.String, Schema.UndefinedOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>]>;
 export type Settings = typeof Settings.Type;
 export declare const ModelSettings: Schema.StructWithRest<Schema.Struct<{
@@ -26,6 +27,7 @@ export declare const ModelSettings: Schema.StructWithRest<Schema.Struct<{
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"native">;
     }>]>>, never, never>;
+    readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
 }>, readonly [Schema.$Record<Schema.String, Schema.UndefinedOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>]>;
 export type ModelSettings = typeof ModelSettings.Type;
 export declare const Overlays: {
@@ -43,6 +45,7 @@ export declare const Overlays: {
             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 encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
     }>, readonly [Schema.$Record<Schema.String, Schema.UndefinedOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>]>>>, 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 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>;
@@ -57,6 +60,7 @@ export declare const Overlays: {
             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 encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
     }>, readonly [Schema.$Record<Schema.String, Schema.UndefinedOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>]>>, never, never>;
     headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
     body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
@@ -127,6 +131,7 @@ declare const Model_base: Schema.Class<Model, Schema.Struct<{
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"native">;
             }>]>>, never, never>;
+            readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
         }>, readonly [Schema.$Record<Schema.String, Schema.UndefinedOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
             readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                 readonly type: Schema.Literal<"summary">;
@@ -137,6 +142,7 @@ declare const Model_base: Schema.Class<Model, Schema.Struct<{
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"native">;
             }>]>>, never, never>;
+            readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
         }>, readonly [Schema.$Record<Schema.String, Schema.UndefinedOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>]>>, 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.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
@@ -152,6 +158,7 @@ declare const Model_base: Schema.Class<Model, Schema.Struct<{
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"native">;
             }>]>>, never, never>;
+            readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
         }>, readonly [Schema.$Record<Schema.String, Schema.UndefinedOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
             readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                 readonly type: Schema.Literal<"summary">;
@@ -162,6 +169,7 @@ declare const Model_base: Schema.Class<Model, Schema.Struct<{
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"native">;
             }>]>>, never, never>;
+            readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
         }>, readonly [Schema.$Record<Schema.String, Schema.UndefinedOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>]>>, 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.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
@@ -180,6 +188,7 @@ declare const Model_base: Schema.Class<Model, Schema.Struct<{
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"native">;
         }>]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
     }>, readonly [Schema.$Record<Schema.String, Schema.UndefinedOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
         readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
             readonly type: Schema.Literal<"summary">;
@@ -190,6 +199,7 @@ declare const Model_base: Schema.Class<Model, Schema.Struct<{
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"native">;
         }>]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
     }>, readonly [Schema.$Record<Schema.String, Schema.UndefinedOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>]>>, 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.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
@@ -197,21 +207,23 @@ declare const Model_base: Schema.Class<Model, Schema.Struct<{
     readonly family: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.Family">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.Family">>, never, never>;
     readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly compatibility: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("../model.js").ReasoningField, import("../model.js").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("../model.js").ReasoningField, import("../model.js").ReasoningField, never, never>>, never, never>;
+        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("../model-compatibility.js").ReasoningField, import("../model-compatibility.js").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("../model-compatibility.js").ReasoningField, import("../model-compatibility.js").ReasoningField, never, never>>, never, never>;
         readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
         readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
         readonly supportsThinkingBlockBinding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly supportsEffortUpdates: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
     }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("../model.js").ReasoningField, import("../model.js").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("../model.js").ReasoningField, import("../model.js").ReasoningField, never, never>>, never, never>;
+        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("../model-compatibility.js").ReasoningField, import("../model-compatibility.js").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("../model-compatibility.js").ReasoningField, import("../model-compatibility.js").ReasoningField, never, never>>, never, never>;
         readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
         readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
         readonly supportsThinkingBlockBinding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly supportsEffortUpdates: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
     }>>, never, never>;
@@ -235,6 +247,7 @@ declare const Info_base: Schema.Class<Info, 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 encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
     }>, readonly [Schema.$Record<Schema.String, Schema.UndefinedOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>]>>>, 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 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>;
@@ -249,6 +262,7 @@ declare const Info_base: Schema.Class<Info, 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 encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
     }>, readonly [Schema.$Record<Schema.String, Schema.UndefinedOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>]>>, 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.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
@@ -280,6 +294,23 @@ declare const Info_base: Schema.Class<Info, Schema.Struct<{
     readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly env: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
     readonly package: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly compatibility: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("../model-compatibility.js").ReasoningField, import("../model-compatibility.js").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("../model-compatibility.js").ReasoningField, import("../model-compatibility.js").ReasoningField, never, never>>, never, never>;
+        readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+        readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("../model-compatibility.js").ReasoningField, import("../model-compatibility.js").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("../model-compatibility.js").ReasoningField, import("../model-compatibility.js").ReasoningField, never, never>>, never, never>;
+        readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+        readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+    }>>, never, never>;
 }>, {}>;
 export declare class Info extends Info_base {
 }

package/dist/config/provider.js

@@ -2,6 +2,7 @@ export * as ConfigProvider from "./provider.js";
 import { Schema } from "effect";
 import { Money } from "../money.js";
 import { Capabilities, Compatibility, Family, ID, VariantID } from "../model.js";
+import { ProviderCompatibility } from "../model-compatibility.js";
 import { Provider } from "../provider.js";
 import { optional } from "../schema.js";
 export const Settings = Schema.StructWithRest(Schema.Struct({
@@ -10,9 +11,11 @@ export const Settings = Schema.StructWithRest(Schema.Struct({
     chunkTimeout: Schema.Union([Schema.Finite, Schema.Literal(false)]).pipe(optional),
     compaction: Provider.Compaction.pipe(optional),
     transport: Provider.Transport.pipe(optional),
+    encoding: Provider.Encoding.pipe(optional),
 }), [Schema.Record(Schema.String, Schema.UndefinedOr(Schema.Json))]).annotate({ identifier: "Config.Provider.Settings" });
 export const ModelSettings = Schema.StructWithRest(Schema.Struct({
     compaction: Provider.Compaction.pipe(optional),
+    encoding: Provider.Encoding.pipe(optional),
 }), [Schema.Record(Schema.String, Schema.UndefinedOr(Schema.Json))]).annotate({ identifier: "Config.Model.Settings" });
 const JsonRecord = Schema.Record(Schema.String, Schema.Json);
 export const Overlays = {
@@ -80,6 +83,8 @@ export class Info extends Schema.Class("Config.Provider")({
     name: Schema.String.pipe(optional),
     env: Schema.String.pipe(Schema.Array, optional),
     package: Schema.String.pipe(optional),
+    // Defaults for every model of this provider; model compatibility overrides individual fields.
+    compatibility: ProviderCompatibility.pipe(optional),
     ...Overlays,
     models: Schema.Record(Schema.String, Model).pipe(optional),
 }) {

package/dist/credential.js

@@ -6,7 +6,7 @@ import { IntegrationID, IntegrationMethodID } from "./integration-id.js";
 import { ascending } from "./identifier.js";
 import { NonNegativeInt, statics } from "./schema.js";
 import { Form } from "./form.js";
-export const ID = Schema.String.pipe(Schema.brand("Credential.ID"), statics((schema) => ({ create: () => schema.make("cred_" + ascending()) })));
+export const ID = Schema.String.pipe(Schema.brand("Credential.ID"), Schema.annotate({ identifier: "Credential.ID" }), statics((schema) => ({ create: () => schema.make("cred_" + ascending()) })));
 const Updated = ephemeral({
     type: "credential.updated",
     schema: {},

package/dist/event-manifest.d.ts

@@ -4715,6 +4715,7 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
             readonly created: Schema.Int;
             readonly updated: Schema.Int;
             readonly active: Schema.Int;
+            readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
         }>;
         readonly sandboxes: Schema.$Array<Schema.String>;
     }>;
@@ -4747,6 +4748,7 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
             readonly created: Schema.Int;
             readonly updated: Schema.Int;
             readonly active: Schema.Int;
+            readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
         }>;
         readonly sandboxes: Schema.$Array<Schema.String>;
     }>;
@@ -11123,6 +11125,7 @@ export declare const Definitions: readonly [Schema.Struct<{
             readonly created: Schema.Int;
             readonly updated: Schema.Int;
             readonly active: Schema.Int;
+            readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
         }>;
         readonly sandboxes: Schema.$Array<Schema.String>;
     }>;
@@ -11155,6 +11158,7 @@ export declare const Definitions: readonly [Schema.Struct<{
             readonly created: Schema.Int;
             readonly updated: Schema.Int;
             readonly active: Schema.Int;
+            readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
         }>;
         readonly sandboxes: Schema.$Array<Schema.String>;
     }>;

package/dist/event.js

@@ -4,15 +4,15 @@ import { optional } from "./schema.js";
 import { ascending } from "./identifier.js";
 import { Location } from "./location.js";
 import { statics } from "./schema.js";
-export const ID = Schema.String.check(Schema.isStartsWith("evt_")).pipe(Schema.brand("Event.ID"), statics((schema) => ({ create: () => schema.make("evt_" + ascending()) })));
+export const ID = Schema.String.check(Schema.isStartingWith("evt_")).pipe(Schema.brand("Event.ID"), Schema.annotate({ identifier: "Event.ID" }), statics((schema) => ({ create: () => schema.make("evt_" + ascending()) })));
 /**
  * Position in one aggregate's durable log. Values originate from the durable
  * event envelope and synced markers;
  * `after` cursors accept only values that came from those sources.
  */
-export const Seq = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).pipe(Schema.brand("Event.Seq"));
+export const Seq = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).pipe(Schema.brand("Event.Seq"), Schema.annotate({ identifier: "Event.Seq" }));
 /** Durable schema version of one event type, from the event definition that committed it. */
-export const Version = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)).pipe(Schema.brand("Event.Version"));
+export const Version = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)).pipe(Schema.brand("Event.Version"), Schema.annotate({ identifier: "Event.Version" }));
 const DurableEnvelope = Schema.Struct({ aggregateID: Schema.String, seq: Seq, version: Version });
 export function durable(input) {
     const data = Schema.Struct(input.schema);

package/dist/form.js

@@ -3,7 +3,7 @@ import { Schema } from "effect";
 import { ephemeral, inventory } from "./event.js";
 import { ascending } from "./identifier.js";
 import { NonNegativeInt, optional, statics } from "./schema.js";
-const IDSchema = Schema.String.check(Schema.isStartsWith("frm_")).pipe(Schema.brand("Form.ID"));
+const IDSchema = Schema.String.check(Schema.isStartingWith("frm_")).pipe(Schema.brand("Form.ID"), Schema.annotate({ identifier: "Form.ID" }));
 export const ID = IDSchema.pipe(statics((schema) => ({ create: (id) => schema.make(id ?? "frm_" + ascending()) })));
 export const Metadata = Schema.Record(Schema.String, Schema.Unknown).annotate({ identifier: "Form.Metadata" });
 export const Option = Schema.Struct({

package/dist/instruction-entry.js

@@ -5,7 +5,7 @@ import { Schema } from "effect";
  * derives the namespaced Instructions key as `api/<key>`, keeping the
  * `api/*` namespace enforced by construction.
  */
-export const Key = Schema.String.check(Schema.isPattern(/^[a-z0-9][a-z0-9._-]*$/)).annotate({
+export const Key = Schema.String.check(Schema.isPattern(/^[a-z0-9][a-z0-9._-]*$/u)).annotate({
     identifier: "InstructionEntry.Key",
     description: "Instruction entry key (lowercase alphanumerics plus . _ -)",
 });

package/dist/instruction.js

@@ -1,7 +1,7 @@
 export * as Instruction from "./instruction.js";
 import { Schema } from "effect";
-export const Key = Schema.String.check(Schema.isPattern(/^[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._/-]*$/)).pipe(Schema.brand("Instruction.Key"));
-export const Hash = Schema.String.check(Schema.isPattern(/^[a-f0-9]{64}$/)).pipe(Schema.brand("Instruction.Hash"));
+export const Key = Schema.String.check(Schema.isPattern(/^[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._/-]*$/u)).pipe(Schema.brand("Instruction.Key"), Schema.annotate({ identifier: "Instruction.Key" }));
+export const Hash = Schema.String.check(Schema.isPattern(/^[a-f0-9]{64}$/u)).pipe(Schema.brand("Instruction.Hash"), Schema.annotate({ identifier: "Instruction.Hash" }));
 export const Values = Schema.Record(Key, Hash);
 export const Removed = Schema.Literal("removed");
 export const removed = Removed.make("removed");

package/dist/integration-id.js

@@ -1,3 +1,3 @@
 import { Schema } from "effect";
-export const IntegrationID = Schema.String.pipe(Schema.brand("Integration.ID"));
-export const IntegrationMethodID = Schema.String.pipe(Schema.brand("Integration.MethodID"));
+export const IntegrationID = Schema.String.pipe(Schema.brand("Integration.ID"), Schema.annotate({ identifier: "Integration.ID" }));
+export const IntegrationMethodID = Schema.String.pipe(Schema.brand("Integration.MethodID"), Schema.annotate({ identifier: "Integration.MethodID" }));

package/dist/integration.js

@@ -56,7 +56,7 @@ export const Info = Schema.Struct({
     methods: Schema.Array(Method),
     connections: Schema.Array(Connection.Info),
 }).annotate({ identifier: "Integration.Info" });
-export const AttemptID = Schema.String.pipe(Schema.brand("Integration.AttemptID"), statics((schema) => ({ create: () => schema.make("con_" + ascending()) })));
+export const AttemptID = Schema.String.pipe(Schema.brand("Integration.AttemptID"), Schema.annotate({ identifier: "Integration.AttemptID" }), statics((schema) => ({ create: () => schema.make("con_" + ascending()) })));
 const AttemptTime = Schema.Struct({
     created: Schema.Number,
     expires: Schema.Number,

package/dist/model-compatibility.d.ts

@@ -0,0 +1,35 @@
+import { Schema } from "effect";
+export type ReasoningField = "reasoning" | "reasoning_content" | "reasoning_text" | (string & {});
+export declare const ReasoningField: Schema.Codec<ReasoningField>;
+export declare const MaxTokensField: Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>;
+export type MaxTokensField = typeof MaxTokensField.Type;
+export declare const CacheFormat: Schema.Literals<readonly ["anthropic", "alibaba"]>;
+export type CacheFormat = typeof CacheFormat.Type;
+export interface Compatibility extends Schema.Schema.Type<typeof Compatibility> {
+}
+export declare const Compatibility: Schema.Struct<{
+    readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<ReasoningField, ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<ReasoningField, ReasoningField, never, never>>, never, never>;
+    /** Require every assistant message to include its reasoning field, even when empty. */
+    readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+    readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    /** Prompt-cache marker syntax the endpoint accepts. Overrides the route default; both send `cache_control`, and `alibaba` skips tool definitions. */
+    readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+    /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */
+    readonly supportsThinkingBlockBinding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    /** Supports per-message effort updates. Overrides model-ID detection. */
+    readonly supportsEffortUpdates: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>;
+export interface ProviderCompatibility extends Schema.Schema.Type<typeof ProviderCompatibility> {
+}
+export declare const ProviderCompatibility: Schema.Struct<{
+    readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<ReasoningField, ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<ReasoningField, ReasoningField, never, never>>, never, never>;
+    readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+    readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+}>;

package/dist/model-compatibility.js

@@ -0,0 +1,26 @@
+import { Schema, Struct } from "effect";
+import { optional } from "./schema.js";
+export const ReasoningField = Schema.Union([
+    Schema.Literals(["reasoning", "reasoning_content", "reasoning_text"]),
+    Schema.String,
+]).annotate({ identifier: "Model.ReasoningField" });
+export const MaxTokensField = Schema.Literals(["max_completion_tokens", "max_tokens"]).annotate({
+    identifier: "Model.MaxTokensField",
+});
+export const CacheFormat = Schema.Literals(["anthropic", "alibaba"]).annotate({ identifier: "Model.CacheFormat" });
+export const Compatibility = Schema.Struct({
+    reasoningField: ReasoningField.pipe(optional),
+    /** Require every assistant message to include its reasoning field, even when empty. */
+    requireReasoning: Schema.Boolean.pipe(optional),
+    maxTokensField: MaxTokensField.pipe(optional),
+    requireFinishReason: Schema.Boolean.pipe(optional),
+    requireAssistantAfterTool: Schema.Boolean.pipe(optional),
+    supportsPromptCacheKey: Schema.Boolean.pipe(optional),
+    /** Prompt-cache marker syntax the endpoint accepts. Overrides the route default; both send `cache_control`, and `alibaba` skips tool definitions. */
+    cacheFormat: CacheFormat.pipe(optional),
+    /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */
+    supportsThinkingBlockBinding: Schema.Boolean.pipe(optional),
+    /** Supports per-message effort updates. Overrides model-ID detection. */
+    supportsEffortUpdates: Schema.Boolean.pipe(optional),
+}).annotate({ identifier: "Model.Compatibility" });
+export const ProviderCompatibility = Schema.Struct(Struct.omit(Compatibility.fields, ["supportsThinkingBlockBinding", "supportsEffortUpdates"])).annotate({ identifier: "Provider.Compatibility" });

package/dist/model.d.ts

@@ -1,6 +1,7 @@
 export * as Model from "./model.js";
 import { Schema } from "effect";
 import { Provider } from "./provider.js";
+import { Compatibility, MaxTokensField, ReasoningField } from "./model-compatibility.js";
 export declare const ID: Schema.brand<Schema.String, "Model.ID">;
 export type ID = typeof ID.Type;
 export declare const Event: {
@@ -98,12 +99,9 @@ export declare const Ref: Schema.Struct<{
 };
 export interface Ref extends Schema.Schema.Type<typeof Ref> {
 }
+export { Compatibility, MaxTokensField, ReasoningField };
 export declare const Family: Schema.brand<Schema.String, "Model.Family">;
 export type Family = typeof Family.Type;
-export type ReasoningField = "reasoning" | "reasoning_content" | "reasoning_text" | (string & {});
-export declare const ReasoningField: Schema.Codec<ReasoningField>;
-export declare const MaxTokensField: Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>;
-export type MaxTokensField = typeof MaxTokensField.Type;
 export declare const Settings: Schema.StructWithRest<Schema.Struct<{
     readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.Literal<"summary">;
@@ -114,6 +112,7 @@ export declare const Settings: Schema.StructWithRest<Schema.Struct<{
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"native">;
     }>]>>, never, never>;
+    readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
 }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>;
 export type Settings = typeof Settings.Type;
 export declare const Overlays: {
@@ -127,6 +126,7 @@ export declare const Overlays: {
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"native">;
         }>]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
     }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
         readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
             readonly type: Schema.Literal<"summary">;
@@ -137,25 +137,11 @@ export declare const Overlays: {
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"native">;
         }>]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
     }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>, never, never>;
     headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
     body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
 };
-export interface Compatibility extends Schema.Schema.Type<typeof Compatibility> {
-}
-export declare const Compatibility: Schema.Struct<{
-    readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<ReasoningField, ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<ReasoningField, ReasoningField, never, never>>, never, never>;
-    /** Require every assistant message to include its reasoning field, even when empty. */
-    readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-    readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
-    readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-    readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-    readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-    /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */
-    readonly supportsThinkingBlockBinding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-    /** Supports per-message effort updates. Overrides model-ID detection. */
-    readonly supportsEffortUpdates: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-}>;
 export interface Capabilities extends Schema.Schema.Type<typeof Capabilities> {
 }
 export declare const Capabilities: Schema.Struct<{
@@ -207,6 +193,7 @@ export declare const Variant: Schema.Struct<{
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"native">;
         }>]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
     }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
         readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
             readonly type: Schema.Literal<"summary">;
@@ -217,6 +204,7 @@ export declare const Variant: Schema.Struct<{
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"native">;
         }>]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, 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>;
@@ -247,6 +235,7 @@ export declare const Info: Schema.Struct<{
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"native">;
             }>]>>, never, never>;
+            readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
         }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
             readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
                 readonly type: Schema.Literal<"summary">;
@@ -257,6 +246,7 @@ export declare const Info: Schema.Struct<{
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"native">;
             }>]>>, never, never>;
+            readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, 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>;
@@ -305,6 +295,7 @@ export declare const Info: Schema.Struct<{
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"native">;
         }>]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
     }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
         readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
             readonly type: Schema.Literal<"summary">;
@@ -315,6 +306,7 @@ export declare const Info: Schema.Struct<{
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"native">;
         }>]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, 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>;
@@ -362,27 +354,23 @@ export declare const Info: Schema.Struct<{
     readonly name: Schema.String;
     readonly compatibility: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<ReasoningField, ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<ReasoningField, ReasoningField, never, never>>, never, never>;
-        /** Require every assistant message to include its reasoning field, even when empty. */
         readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
         readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-        /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */
+        readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
         readonly supportsThinkingBlockBinding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-        /** Supports per-message effort updates. Overrides model-ID detection. */
         readonly supportsEffortUpdates: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
     }>>>, Schema.optionalKey<Schema.Struct<{
         readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<ReasoningField, ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<ReasoningField, ReasoningField, never, never>>, never, never>;
-        /** Require every assistant message to include its reasoning field, even when empty. */
         readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
         readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-        /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */
+        readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
         readonly supportsThinkingBlockBinding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-        /** Supports per-message effort updates. Overrides model-ID detection. */
         readonly supportsEffortUpdates: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
     }>>, never, never>;
     readonly package: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;

package/dist/model.js

@@ -2,6 +2,7 @@ export * as Model from "./model.js";
 import { Schema } from "effect";
 import { optional, statics } from "./schema.js";
 import { Provider } from "./provider.js";
+import { Compatibility, MaxTokensField, ReasoningField } from "./model-compatibility.js";
 import { Money } from "./money.js";
 import { ephemeral, inventory } from "./event.js";
 export const ID = Schema.String.pipe(Schema.brand("Model.ID"));
@@ -32,16 +33,11 @@ export const Ref = Schema.Struct({
         });
     },
 })));
+export { Compatibility, MaxTokensField, ReasoningField };
 export const Family = Schema.String.pipe(Schema.brand("Model.Family"));
-export const ReasoningField = Schema.Union([
-    Schema.Literals(["reasoning", "reasoning_content", "reasoning_text"]),
-    Schema.String,
-]).annotate({ identifier: "Model.ReasoningField" });
-export const MaxTokensField = Schema.Literals(["max_completion_tokens", "max_tokens"]).annotate({
-    identifier: "Model.MaxTokensField",
-});
 export const Settings = Schema.StructWithRest(Schema.Struct({
     compaction: Provider.Compaction.pipe(optional),
+    encoding: Provider.Encoding.pipe(optional),
 }), 
 // Provider packages may define arbitrary model-level options beyond OpenCode's shared compaction policy.
 [Schema.Record(Schema.String, Schema.Any)]).annotate({ identifier: "Model.Settings" });
@@ -50,19 +46,6 @@ export const Overlays = {
     headers: Schema.Record(Schema.String, Schema.String).pipe(optional),
     body: Schema.Record(Schema.String, Schema.Any).pipe(optional),
 };
-export const Compatibility = Schema.Struct({
-    reasoningField: ReasoningField.pipe(optional),
-    /** Require every assistant message to include its reasoning field, even when empty. */
-    requireReasoning: Schema.Boolean.pipe(optional),
-    maxTokensField: MaxTokensField.pipe(optional),
-    requireFinishReason: Schema.Boolean.pipe(optional),
-    requireAssistantAfterTool: Schema.Boolean.pipe(optional),
-    supportsPromptCacheKey: Schema.Boolean.pipe(optional),
-    /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */
-    supportsThinkingBlockBinding: Schema.Boolean.pipe(optional),
-    /** Supports per-message effort updates. Overrides model-ID detection. */
-    supportsEffortUpdates: Schema.Boolean.pipe(optional),
-}).annotate({ identifier: "Model.Compatibility" });
 export const Capabilities = Schema.Struct({
     tools: Schema.Boolean,
     input: Schema.Array(Schema.String),

package/dist/permission-saved.js

@@ -3,7 +3,7 @@ import { Schema } from "effect";
 import { ascending } from "./identifier.js";
 import { ProjectID } from "./project-id.js";
 import { DateTimeUtcFromMillis, statics } from "./schema.js";
-export const ID = Schema.String.pipe(Schema.brand("PermissionSaved.ID"), statics((schema) => ({ create: () => schema.make("psv_" + ascending()) })));
+export const ID = Schema.String.pipe(Schema.brand("PermissionSaved.ID"), Schema.annotate({ identifier: "PermissionSaved.ID" }), statics((schema) => ({ create: () => schema.make("psv_" + ascending()) })));
 export const Info = Schema.Struct({
     id: ID,
     projectID: ProjectID,

package/dist/permission.js

@@ -5,7 +5,7 @@ import { ephemeral, inventory } from "./event.js";
 import { ascending } from "./identifier.js";
 import { SessionID } from "./session-id.js";
 import { statics } from "./schema.js";
-export const ID = Schema.String.check(Schema.isStartsWith("per")).pipe(Schema.brand("Permission.ID"), statics((schema) => ({ create: (id) => schema.make(id ?? "per_" + ascending()) })));
+export const ID = Schema.String.check(Schema.isStartingWith("per")).pipe(Schema.brand("Permission.ID"), Schema.annotate({ identifier: "Permission.ID" }), statics((schema) => ({ create: (id) => schema.make(id ?? "per_" + ascending()) })));
 export const Source = Schema.Union([
     Schema.Struct({
         type: Schema.Literal("tool"),

package/dist/project-id.js

@@ -1,3 +1,3 @@
 import { Schema } from "effect";
 import { statics } from "./schema.js";
-export const ProjectID = Schema.String.pipe(Schema.brand("Project.ID"), statics((schema) => ({ global: schema.make("global") })));
+export const ProjectID = Schema.String.pipe(Schema.brand("Project.ID"), Schema.annotate({ identifier: "Project.ID" }), statics((schema) => ({ global: schema.make("global") })));

package/dist/project.d.ts

@@ -30,6 +30,7 @@ export declare const Time: Schema.Struct<{
     readonly created: Schema.Int;
     readonly updated: Schema.Int;
     readonly active: Schema.Int;
+    readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
 }>;
 export interface Time extends Schema.Schema.Type<typeof Time> {
 }
@@ -58,6 +59,7 @@ export declare const Info: Schema.Struct<{
         readonly created: Schema.Int;
         readonly updated: Schema.Int;
         readonly active: Schema.Int;
+        readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
     }>;
     readonly sandboxes: Schema.$Array<Schema.String>;
 }>;
@@ -138,6 +140,7 @@ export declare const Event: {
                 readonly created: Schema.Int;
                 readonly updated: Schema.Int;
                 readonly active: Schema.Int;
+                readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
             }>;
             readonly sandboxes: Schema.$Array<Schema.String>;
         }>;
@@ -170,6 +173,7 @@ export declare const Event: {
                 readonly created: Schema.Int;
                 readonly updated: Schema.Int;
                 readonly active: Schema.Int;
+                readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
             }>;
             readonly sandboxes: Schema.$Array<Schema.String>;
         }>;
@@ -225,6 +229,7 @@ export declare const Event: {
                 readonly created: Schema.Int;
                 readonly updated: Schema.Int;
                 readonly active: Schema.Int;
+                readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
             }>;
             readonly sandboxes: Schema.$Array<Schema.String>;
         }>;
@@ -257,6 +262,7 @@ export declare const Event: {
                 readonly created: Schema.Int;
                 readonly updated: Schema.Int;
                 readonly active: Schema.Int;
+                readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
             }>;
             readonly sandboxes: Schema.$Array<Schema.String>;
         }>;

package/dist/project.js

@@ -4,7 +4,7 @@ import { ephemeral, inventory } from "./event.js";
 import { AbsolutePath, NonNegativeInt, optional } from "./schema.js";
 import { ProjectID } from "./project-id.js";
 export const ID = ProjectID;
-export const Vcs = Schema.String.check(Schema.isPattern(/^[a-z][a-z0-9._-]*$/)).annotate({
+export const Vcs = Schema.String.check(Schema.isPattern(/^[a-z][a-z0-9._-]*$/u)).annotate({
     identifier: "Project.Vcs",
 });
 export const Current = Schema.Struct({
@@ -24,6 +24,7 @@ export const Time = Schema.Struct({
     created: NonNegativeInt,
     updated: NonNegativeInt,
     active: NonNegativeInt,
+    archived: optional(NonNegativeInt),
 }).annotate({ identifier: "Project.Time" });
 export const Info = Schema.Struct({
     id: ID,

package/dist/prompt.js

@@ -13,7 +13,7 @@ export const FileSource = Schema.Union([
 ])
     .pipe(Schema.toTaggedUnion("type"))
     .annotate({ identifier: "Prompt.FileSource" });
-export const Base64 = Schema.String.check(Schema.isPattern(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/)).annotate({ identifier: "Prompt.Base64" });
+export const Base64 = Schema.String.check(Schema.isPattern(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u)).annotate({ identifier: "Prompt.Base64" });
 export const FileAttachment = Schema.Struct({
     data: Base64,
     mime: Schema.String,

package/dist/provider.d.ts

@@ -95,6 +95,9 @@ export type Compaction = typeof Compaction.Type;
 /** "websocket" on a route without a WebSocket channel warns and falls back to HTTP. */
 export declare const Transport: Schema.Literals<readonly ["http", "websocket"]>;
 export type Transport = typeof Transport.Type;
+/** HTTP request body compression; only endpoints known to decode it should enable it. */
+export declare const Encoding: Schema.Literals<readonly ["zstd", "gzip", "none"]>;
+export type Encoding = typeof Encoding.Type;
 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 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>;
@@ -109,6 +112,7 @@ export declare const Settings: Schema.StructWithRest<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 encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
 }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>;
 export type Settings = typeof Settings.Type;
 export declare const Overlays: {
@@ -126,6 +130,7 @@ export declare const Overlays: {
             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 encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, 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 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>;
@@ -140,6 +145,7 @@ export declare const Overlays: {
             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 encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
     }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>, never, never>;
     headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
     body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
@@ -161,6 +167,7 @@ export declare const Request: 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 encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, 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>;
@@ -182,6 +189,7 @@ export declare const Info: 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 encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, 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 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>;
@@ -196,6 +204,7 @@ export declare const Info: 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 encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, 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>;
@@ -241,6 +250,24 @@ export declare const Info: Schema.Struct<{
     readonly name: Schema.String;
     readonly activation: Schema.Literals<readonly ["auto", "enabled", "disabled"]>;
     readonly package: Schema.String;
+    /** Inherited by every model of this provider; model compatibility overrides individual fields. */
+    readonly compatibility: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("./model-compatibility.js").ReasoningField, import("./model-compatibility.js").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("./model-compatibility.js").ReasoningField, import("./model-compatibility.js").ReasoningField, never, never>>, never, never>;
+        readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+        readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("./model-compatibility.js").ReasoningField, import("./model-compatibility.js").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("./model-compatibility.js").ReasoningField, import("./model-compatibility.js").ReasoningField, never, never>>, never, never>;
+        readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+        readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+    }>>, never, never>;
 }> & {
     empty: (id: ID) => Info;
 };

package/dist/provider.js

@@ -1,9 +1,10 @@
 export * as Provider from "./provider.js";
 import { Effect, Schema } from "effect";
 import { Integration } from "./integration.js";
+import { ProviderCompatibility } from "./model-compatibility.js";
 import { optional, statics } from "./schema.js";
 import { ephemeral, inventory } from "./event.js";
-export const ID = Schema.String.pipe(Schema.brand("Provider.ID"), statics((schema) => ({
+export const ID = Schema.String.pipe(Schema.brand("Provider.ID"), Schema.annotate({ identifier: "Provider.ID" }), statics((schema) => ({
     opencode: schema.make("opencode"),
     anthropic: schema.make("anthropic"),
     openai: schema.make("openai"),
@@ -28,12 +29,15 @@ export const Compaction = Schema.Union([
     .annotate({ identifier: "Provider.Compaction" });
 /** "websocket" on a route without a WebSocket channel warns and falls back to HTTP. */
 export const Transport = Schema.Literals(["http", "websocket"]).annotate({ identifier: "Provider.Transport" });
+/** HTTP request body compression; only endpoints known to decode it should enable it. */
+export const Encoding = Schema.Literals(["zstd", "gzip", "none"]).annotate({ identifier: "Provider.Encoding" });
 export const Settings = Schema.StructWithRest(Schema.Struct({
     timeout: Schema.Union([Schema.Finite, Schema.Literal(false)]).pipe(optional),
     headerTimeout: Schema.Union([Schema.Finite, Schema.Literal(false)]).pipe(optional),
     chunkTimeout: Schema.Union([Schema.Finite, Schema.Literal(false)]).pipe(optional),
     compaction: Compaction.pipe(optional),
     transport: Transport.pipe(optional),
+    encoding: Encoding.pipe(optional),
 }), [Schema.Record(Schema.String, Schema.Any)]).annotate({ identifier: "Provider.Settings" });
 export const Overlays = {
     settings: Settings.pipe(optional),
@@ -52,6 +56,8 @@ export const Info = Schema.Struct({
     name: Schema.String,
     activation: Activation,
     package: Package,
+    /** Inherited by every model of this provider; model compatibility overrides individual fields. */
+    compatibility: ProviderCompatibility.pipe(optional),
     ...Overlays,
 })
     .annotate({ identifier: "Provider.Info" })

package/dist/pty.js

@@ -4,7 +4,7 @@ import { optional } from "./schema.js";
 import { ephemeral, inventory } from "./event.js";
 import { ascending } from "./identifier.js";
 import { NonNegativeInt, PositiveInt, statics } from "./schema.js";
-const IDSchema = Schema.String.check(Schema.isStartsWith("pty")).pipe(Schema.brand("PtyID"));
+const IDSchema = Schema.String.check(Schema.isStartingWith("pty")).pipe(Schema.brand("PtyID"), Schema.annotate({ identifier: "Pty.ID" }));
 export const ID = IDSchema.pipe(statics((schema) => {
     const create = () => schema.make("pty_" + ascending());
     return {

package/dist/schema.d.ts

@@ -6,5 +6,6 @@ export type RelativePath = typeof RelativePath.Type;
 export declare const AbsolutePath: Schema.brand<Schema.String, "AbsolutePath">;
 export type AbsolutePath = typeof AbsolutePath.Type;
 export declare const optional: <S extends Schema.Top>(schema: S) => Schema.decodeTo<Schema.optional<Schema.toType<S>>, Schema.optionalKey<S>, never, never>;
+export declare const withStatics: <S extends object, M extends Record<string, unknown>>(schema: S, methods: M) => S & M;
 export declare const statics: <S extends object, M extends Record<string, unknown>>(methods: (schema: S) => M) => (schema: S) => S & M;
 export declare const DateTimeUtcFromMillis: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;

package/dist/schema.js

@@ -1,13 +1,16 @@
 import { DateTime, Option, Schema, SchemaGetter } from "effect";
 export const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));
 export const NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
-export const RelativePath = Schema.String.pipe(Schema.brand("RelativePath"));
-export const AbsolutePath = Schema.String.pipe(Schema.brand("AbsolutePath"));
+export const RelativePath = Schema.String.pipe(Schema.brand("RelativePath"), Schema.annotate({ identifier: "RelativePath" }));
+export const AbsolutePath = Schema.String.pipe(Schema.brand("AbsolutePath"), Schema.annotate({ identifier: "AbsolutePath" }));
 export const optional = (schema) => Schema.optionalKey(schema).pipe(Schema.decodeTo(Schema.optional(Schema.toType(schema)), {
     decode: SchemaGetter.passthrough({ strict: false }),
     encode: SchemaGetter.transformOptional(Option.filter((value) => value !== undefined)),
 }));
-export const statics = (methods) => (schema) => Object.assign(schema, methods(schema));
+// Effect schemas expose `make` through prototype getters, so `Object.assign` cannot override it.
+// Defining the properties replaces a constructor as long as the schema's own `make` has not been read.
+export const withStatics = (schema, methods) => Object.defineProperties(schema, Object.getOwnPropertyDescriptors(methods));
+export const statics = (methods) => (schema) => withStatics(schema, methods(schema));
 export const DateTimeUtcFromMillis = Schema.Finite.pipe(Schema.decodeTo(Schema.DateTimeUtc, {
     decode: SchemaGetter.transform((value) => DateTime.makeUnsafe(value)),
     encode: SchemaGetter.transform((value) => DateTime.toEpochMillis(value)),

package/dist/session-id.js

@@ -1,7 +1,7 @@
 import { Schema } from "effect";
 import { descending } from "./identifier.js";
 import { statics } from "./schema.js";
-export const SessionID = Schema.String.check(Schema.isStartsWith("ses")).pipe(Schema.brand("SessionID"), statics((schema) => {
+export const SessionID = Schema.String.check(Schema.isStartingWith("ses")).pipe(Schema.brand("SessionID"), Schema.annotate({ identifier: "Session.ID" }), statics((schema) => {
     const create = () => schema.make("ses_" + descending());
     return {
         create,

package/dist/session-message.d.ts

@@ -1366,6 +1366,25 @@ export interface Idle extends Schema.Schema.Type<typeof Idle> {
 export declare const Idle: Schema.Struct<{
     readonly type: Schema.tag<"idle">;
     readonly outcome: Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>;
+    readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly type: Schema.String;
+        readonly message: Schema.String;
+        readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly body: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly body: Schema.String;
+        }>>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly type: Schema.String;
+        readonly message: Schema.String;
+        readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly body: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly body: Schema.String;
+        }>>, never, never>;
+    }>>, never, never>;
     readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
         fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -2119,6 +2138,25 @@ export declare const Info: Schema.Union<readonly [Schema.Struct<{
 }>]>, Schema.Struct<{
     readonly type: Schema.tag<"idle">;
     readonly outcome: Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>;
+    readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly type: Schema.String;
+        readonly message: Schema.String;
+        readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly body: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly body: Schema.String;
+        }>>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly type: Schema.String;
+        readonly message: Schema.String;
+        readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly body: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly body: Schema.String;
+        }>>, never, never>;
+    }>>, never, never>;
     readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
         fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;

package/dist/session-message.js

@@ -18,7 +18,7 @@ import { Skill as SkillSchema } from "./skill.js";
 import { Money } from "./money.js";
 import { Snapshot } from "./snapshot.js";
 import { TokenUsage } from "./token-usage.js";
-export const ID = Schema.String.check(Schema.isStartsWith("msg_")).pipe(Schema.brand("Session.Message.ID"), statics((schema) => ({
+export const ID = Schema.String.check(Schema.isStartingWith("msg_")).pipe(Schema.brand("Session.Message.ID"), Schema.annotate({ identifier: "Session.Message.ID" }), statics((schema) => ({
     create: () => schema.make("msg_" + ascending()),
     fromEvent: (eventID) => schema.make(eventID.replace(/^evt_/, "msg_")),
 })));
@@ -217,6 +217,7 @@ export const Idle = Schema.Struct({
     ...Base,
     type: Schema.tag("idle"),
     outcome: Schema.Literals(["succeeded", "failed", "interrupted"]),
+    error: SessionError.Error.pipe(optional),
 }).annotate({ identifier: "Session.Message.Idle" });
 export const Info = Schema.Union([
     AgentSelected,

package/dist/session-transfer.d.ts

@@ -926,6 +926,25 @@ export declare const Data: Schema.Struct<{
     }>]>, Schema.Struct<{
         readonly type: Schema.tag<"idle">;
         readonly outcome: Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>;
+        readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly type: Schema.String;
+            readonly message: Schema.String;
+            readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly type: Schema.String;
+            readonly message: Schema.String;
+            readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>, never, never>;
+        }>>, never, never>;
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
             fromEvent: (eventID: import("./event.js").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;

package/dist/shell.js

@@ -4,7 +4,7 @@ import { optional } from "./schema.js";
 import { ephemeral, inventory } from "./event.js";
 import { ascending } from "./identifier.js";
 import { NonNegativeInt, statics } from "./schema.js";
-const IDSchema = Schema.String.check(Schema.isStartsWith("sh_")).pipe(Schema.brand("Shell.ID"));
+const IDSchema = Schema.String.check(Schema.isStartingWith("sh_")).pipe(Schema.brand("Shell.ID"), Schema.annotate({ identifier: "Shell.ID" }));
 export const ID = IDSchema.pipe(statics((schema) => {
     const create = () => schema.make("sh_" + ascending());
     return {

package/dist/skill.js

@@ -3,8 +3,8 @@ import { Schema } from "effect";
 import { optional } from "./schema.js";
 import { AbsolutePath } from "./schema.js";
 import { ephemeral, inventory } from "./event.js";
-export const ID = Schema.String.pipe(Schema.brand("Skill.ID"));
-export const Name = Schema.String.pipe(Schema.brand("Skill.Name"));
+export const ID = Schema.String.pipe(Schema.brand("Skill.ID"), Schema.annotate({ identifier: "Skill.ID" }));
+export const Name = Schema.String.pipe(Schema.brand("Skill.Name"), Schema.annotate({ identifier: "Skill.Name" }));
 export const DirectorySource = Schema.Struct({
     type: Schema.tag("directory"),
     path: AbsolutePath,

package/dist/snapshot.js

@@ -1,3 +1,3 @@
 export * as Snapshot from "./snapshot.js";
 import { Schema } from "effect";
-export const ID = Schema.String.pipe(Schema.brand("Snapshot.ID"));
+export const ID = Schema.String.pipe(Schema.brand("Snapshot.ID"), Schema.annotate({ identifier: "Snapshot.ID" }));

package/dist/v1/permission.js

@@ -5,7 +5,7 @@ import { ascending } from "../identifier.js";
 import { Project } from "../project.js";
 import { statics } from "../schema.js";
 import { SessionID } from "../session-id.js";
-export const ID = Schema.String.check(Schema.isStartsWith("per")).pipe(Schema.brand("PermissionV1.ID"), statics((schema) => ({ ascending: (id) => schema.make(id ?? "per_" + ascending()) })));
+export const ID = Schema.String.check(Schema.isStartingWith("per")).pipe(Schema.brand("PermissionV1.ID"), statics((schema) => ({ ascending: (id) => schema.make(id ?? "per_" + ascending()) })));
 export const Action = Schema.Literals(["allow", "deny", "ask"]).annotate({ identifier: "PermissionV1.Action" });
 export const Rule = Schema.Struct({ permission: Schema.String, pattern: Schema.String, action: Action }).annotate({
     identifier: "PermissionV1.Rule",

package/dist/v1/session.js

@@ -11,8 +11,8 @@ import { WorkspaceID } from "../workspace-id.js";
 import { PermissionV1 } from "./permission.js";
 import { FileDiff } from "../file-diff.js";
 const Timestamp = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0));
-export const MessageID = Schema.String.check(Schema.isStartsWith("msg")).pipe(Schema.brand("SessionV1.MessageID"), statics((schema) => ({ ascending: (id) => schema.make(id ?? "msg_" + ascending()) })));
-export const PartID = Schema.String.check(Schema.isStartsWith("prt")).pipe(Schema.brand("SessionV1.PartID"), statics((schema) => ({ ascending: (id) => schema.make(id ?? "prt_" + ascending()) })));
+export const MessageID = Schema.String.check(Schema.isStartingWith("msg")).pipe(Schema.brand("SessionV1.MessageID"), statics((schema) => ({ ascending: (id) => schema.make(id ?? "msg_" + ascending()) })));
+export const PartID = Schema.String.check(Schema.isStartingWith("prt")).pipe(Schema.brand("SessionV1.PartID"), statics((schema) => ({ ascending: (id) => schema.make(id ?? "prt_" + ascending()) })));
 const namedError = (name, fields) => {
     const schema = Schema.Struct({ name: Schema.Literal(name), data: Schema.Struct(fields) }).annotate({
         identifier: name,

package/dist/websearch.js

@@ -2,7 +2,7 @@ export * as WebSearch from "./websearch.js";
 import { Schema } from "effect";
 import { ephemeral, inventory } from "./event.js";
 import { optional } from "./schema.js";
-export const ID = Schema.String.pipe(Schema.brand("WebSearch.ID"));
+export const ID = Schema.String.pipe(Schema.brand("WebSearch.ID"), Schema.annotate({ identifier: "WebSearch.ID" }));
 export const Provider = Schema.Struct({
     id: ID,
     name: Schema.String,

package/dist/workspace-id.js

@@ -1,7 +1,7 @@
 import { Schema } from "effect";
 import { ascending } from "./identifier.js";
 import { statics } from "./schema.js";
-export const WorkspaceID = Schema.String.check(Schema.isStartsWith("wrk")).pipe(Schema.brand("Workspace.ID"), statics((schema) => {
+export const WorkspaceID = Schema.String.check(Schema.isStartingWith("wrk")).pipe(Schema.brand("Workspace.ID"), Schema.annotate({ identifier: "Workspace.ID" }), statics((schema) => {
     const create = () => schema.make("wrk_" + ascending());
     return {
         ascending: (id) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/schema",
-  "version": "2.0.26",
+  "version": "2.0.28",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -31,7 +31,7 @@
   },
   "dependencies": {
     "@standard-schema/spec": "1.1.0",
-    "effect": "4.0.0-rc.112"
+    "effect": "4.0.1"
   },
   "devDependencies": {
     "@tsconfig/bun": "1.0.9",