@opencode/schema 2.0.26 → 2.0.27

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/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/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.js

@@ -3,7 +3,7 @@ import { Effect, Schema } from "effect";
 import { Integration } from "./integration.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"),

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.27",
   "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",