npm - @opencode-ai/schema - Versions diffs - 0.0.0-next-14692 → 0.0.0-next-14706 - Mend

@opencode-ai/schema 0.0.0-next-14692 → 0.0.0-next-14706

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/agent.d.ts +4 -0
package/dist/agent.js +1 -1
package/dist/event-manifest.d.ts +140 -0
package/dist/model.d.ts +8 -0
package/dist/model.js +1 -1
package/dist/provider.d.ts +7 -0
package/dist/provider.js +4 -2
package/dist/session-event.d.ts +212 -0
package/dist/session-event.js +9 -1
package/package.json +1 -1

package/dist/agent.d.ts CHANGED Viewed

@@ -42,6 +42,7 @@ export declare const Info: Schema.Struct<{
         readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "VariantID">>, never, never>;
     }>>, never, never>;
     readonly request: Schema.Struct<{
+        readonly settings: Schema.withConstructorDefault<Schema.$Record<Schema.String, Schema.Unknown>>;
         readonly headers: Schema.$Record<Schema.String, Schema.String>;
         readonly body: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
     }>;
@@ -60,6 +61,9 @@ export declare const Info: Schema.Struct<{
     empty: (id: ID) => {
         readonly id: string & import("effect/Brand").Brand<"AgentV2.ID">;
         readonly request: {
+            readonly settings: {
+                readonly [x: string]: unknown;
+            };
             readonly headers: {
                 readonly [x: string]: string;
             };

package/dist/agent.js CHANGED Viewed

@@ -28,7 +28,7 @@ export const Info = Schema.Struct({
     .pipe(statics((schema) => ({
     empty: (id) => schema.make({
         id,
-        request: { headers: {}, body: {} },
+        request: { settings: {}, headers: {}, body: {} },
         mode: "all",
         hidden: false,
         permissions: [

package/dist/event-manifest.d.ts CHANGED Viewed

@@ -3811,6 +3811,76 @@ export declare const ServerDefinitions: readonly [import("effect/Schema").Struct
         readonly aggregate: string;
     } | undefined;
     type: "session.next.prompt.admitted";
+}, import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+    readonly type: import("effect/Schema").Literal<"session.next.execution.settled">;
+    readonly durable: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>, never, never>;
+    readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: import("effect/Schema").Struct<{
+        readonly outcome: import("effect/Schema").Literals<readonly ["success", "failure", "interrupted"]>;
+        readonly error: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"unknown">;
+            readonly message: import("effect/Schema").String;
+        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"unknown">;
+            readonly message: import("effect/Schema").String;
+        }>>, never, never>;
+        readonly timestamp: import("effect/Schema").decodeTo<import("effect/Schema").DateTimeUtc, import("effect/Schema").Finite, never, never>;
+        readonly sessionID: import("effect/Schema").brand<import("effect/Schema").String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+}> & {
+    data: import("effect/Schema").Struct<{
+        readonly outcome: import("effect/Schema").Literals<readonly ["success", "failure", "interrupted"]>;
+        readonly error: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"unknown">;
+            readonly message: import("effect/Schema").String;
+        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"unknown">;
+            readonly message: import("effect/Schema").String;
+        }>>, never, never>;
+        readonly timestamp: import("effect/Schema").decodeTo<import("effect/Schema").DateTimeUtc, import("effect/Schema").Finite, never, never>;
+        readonly sessionID: import("effect/Schema").brand<import("effect/Schema").String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "session.next.execution.settled";
 }, import("effect/Schema").Struct<{
     readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -8080,6 +8150,76 @@ export declare const Definitions: readonly [import("effect/Schema").Struct<{
         readonly aggregate: string;
     } | undefined;
     type: "session.next.prompt.admitted";
+}) | (import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+    readonly type: import("effect/Schema").Literal<"session.next.execution.settled">;
+    readonly durable: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly aggregateID: import("effect/Schema").String;
+        readonly seq: import("effect/Schema").Int;
+        readonly version: import("effect/Schema").Int;
+    }>>, never, never>;
+    readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: import("effect/Schema").Struct<{
+        readonly outcome: import("effect/Schema").Literals<readonly ["success", "failure", "interrupted"]>;
+        readonly error: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"unknown">;
+            readonly message: import("effect/Schema").String;
+        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"unknown">;
+            readonly message: import("effect/Schema").String;
+        }>>, never, never>;
+        readonly timestamp: import("effect/Schema").decodeTo<import("effect/Schema").DateTimeUtc, import("effect/Schema").Finite, never, never>;
+        readonly sessionID: import("effect/Schema").brand<import("effect/Schema").String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+}> & {
+    data: import("effect/Schema").Struct<{
+        readonly outcome: import("effect/Schema").Literals<readonly ["success", "failure", "interrupted"]>;
+        readonly error: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"unknown">;
+            readonly message: import("effect/Schema").String;
+        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+            readonly type: import("effect/Schema").Literal<"unknown">;
+            readonly message: import("effect/Schema").String;
+        }>>, never, never>;
+        readonly timestamp: import("effect/Schema").decodeTo<import("effect/Schema").DateTimeUtc, import("effect/Schema").Finite, never, never>;
+        readonly sessionID: import("effect/Schema").brand<import("effect/Schema").String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "session.next.execution.settled";
 }) | (import("effect/Schema").Struct<{
     readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;

package/dist/model.d.ts CHANGED Viewed

@@ -101,10 +101,12 @@ export declare const Info: Schema.Struct<{
     }>;
     readonly request: Schema.Struct<{
         readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly settings: Schema.withConstructorDefault<Schema.$Record<Schema.String, Schema.Unknown>>;
         readonly headers: Schema.$Record<Schema.String, Schema.String>;
         readonly body: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
     }>;
     readonly variants: Schema.$Array<Schema.Struct<{
+        readonly settings: Schema.withConstructorDefault<Schema.$Record<Schema.String, Schema.Unknown>>;
         readonly headers: Schema.$Record<Schema.String, Schema.String>;
         readonly body: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
         readonly id: Schema.brand<Schema.String, "VariantID">;
@@ -161,6 +163,9 @@ export declare const Info: Schema.Struct<{
             readonly output: readonly string[];
         };
         readonly request: {
+            readonly settings: {
+                readonly [x: string]: unknown;
+            };
             readonly headers: {
                 readonly [x: string]: string;
             };
@@ -170,6 +175,9 @@ export declare const Info: Schema.Struct<{
             readonly variant?: string | undefined;
         };
         readonly variants: readonly {
+            readonly settings: {
+                readonly [x: string]: unknown;
+            };
             readonly headers: {
                 readonly [x: string]: string;
             };

package/dist/model.js CHANGED Viewed

@@ -75,7 +75,7 @@ export const Info = Schema.Struct({
         name: modelID,
         api: { id: modelID, type: "native", settings: {} },
         capabilities: { tools: false, input: [], output: [] },
-        request: { headers: {}, body: {} },
+        request: { settings: {}, headers: {}, body: {} },
         variants: [],
         time: { released: 0 },
         cost: [],

package/dist/provider.d.ts CHANGED Viewed

@@ -40,9 +40,12 @@ export declare const Api: Schema.Union<readonly [Schema.Struct<{
     readonly settings: Schema.$Record<Schema.String, Schema.Unknown>;
 }>]>;
 export type Api = typeof Api.Type;
+export declare const Settings: Schema.$Record<Schema.String, Schema.Unknown>;
+export type Settings = typeof Settings.Type;
 export interface Request extends Schema.Schema.Type<typeof Request> {
 }
 export declare const Request: Schema.Struct<{
+    readonly settings: Schema.withConstructorDefault<Schema.$Record<Schema.String, Schema.Unknown>>;
     readonly headers: Schema.$Record<Schema.String, Schema.String>;
     readonly body: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
 }>;
@@ -76,6 +79,7 @@ export declare const Info: Schema.Struct<{
         readonly settings: Schema.$Record<Schema.String, Schema.Unknown>;
     }>]>;
     readonly request: Schema.Struct<{
+        readonly settings: Schema.withConstructorDefault<Schema.$Record<Schema.String, Schema.Unknown>>;
         readonly headers: Schema.$Record<Schema.String, Schema.String>;
         readonly body: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
     }>;
@@ -98,6 +102,9 @@ export declare const Info: Schema.Struct<{
             readonly url?: string | undefined;
         };
         readonly request: {
+            readonly settings: {
+                readonly [x: string]: unknown;
+            };
             readonly headers: {
                 readonly [x: string]: string;
             };

package/dist/provider.js CHANGED Viewed

@@ -1,5 +1,5 @@
 export * as Provider from "./provider.js";
-import { Schema } from "effect";
+import { Effect, Schema } from "effect";
 import { optional } from "./schema.js";
 import { Integration } from "./integration.js";
 import { statics } from "./schema.js";
@@ -30,7 +30,9 @@ export const Native = Schema.Struct({
 export const Api = Schema.Union([AISDK, Native])
     .pipe(Schema.toTaggedUnion("type"))
     .annotate({ identifier: "Provider.Api" });
+export const Settings = Schema.Record(Schema.String, Schema.Unknown).annotate({ identifier: "Provider.Settings" });
 export const Request = Schema.Struct({
+    settings: Settings.pipe(Schema.withConstructorDefault(Effect.succeed({}))),
     headers: Schema.Record(Schema.String, Schema.String),
     body: Schema.Record(Schema.String, Schema.Json),
 }).annotate({ identifier: "Provider.Request" });
@@ -48,6 +50,6 @@ export const Info = Schema.Struct({
         id,
         name: id,
         api: { type: "native", settings: {} },
-        request: { headers: {}, body: {} },
+        request: { settings: {}, headers: {}, body: {} },
     }),
 })));

package/dist/session-event.d.ts CHANGED Viewed

@@ -1009,6 +1009,78 @@ export declare const PromptAdmitted: Schema.Struct<{
     type: "session.next.prompt.admitted";
 };
 export type PromptAdmitted = typeof PromptAdmitted.Type;
+export declare const ExecutionSettled: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly type: Schema.Literal<"session.next.execution.settled">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, never, never>;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly outcome: Schema.Literals<readonly ["success", "failure", "interrupted"]>;
+        readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly type: Schema.Literal<"unknown">;
+            readonly message: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly type: Schema.Literal<"unknown">;
+            readonly message: Schema.String;
+        }>>, never, never>;
+        readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly outcome: Schema.Literals<readonly ["success", "failure", "interrupted"]>;
+        readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly type: Schema.Literal<"unknown">;
+            readonly message: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly type: Schema.Literal<"unknown">;
+            readonly message: Schema.String;
+        }>>, never, never>;
+        readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "session.next.execution.settled";
+};
+export type ExecutionSettled = typeof ExecutionSettled.Type;
 export declare const ContextUpdated: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -6689,6 +6761,76 @@ export declare const Definitions: readonly [Schema.Struct<{
         readonly aggregate: string;
     } | undefined;
     type: "session.next.prompt.admitted";
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly type: Schema.Literal<"session.next.execution.settled">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, never, never>;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly outcome: Schema.Literals<readonly ["success", "failure", "interrupted"]>;
+        readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly type: Schema.Literal<"unknown">;
+            readonly message: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly type: Schema.Literal<"unknown">;
+            readonly message: Schema.String;
+        }>>, never, never>;
+        readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly outcome: Schema.Literals<readonly ["success", "failure", "interrupted"]>;
+        readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly type: Schema.Literal<"unknown">;
+            readonly message: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly type: Schema.Literal<"unknown">;
+            readonly message: Schema.String;
+        }>>, never, never>;
+        readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "session.next.execution.settled";
 }, Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -12286,6 +12428,76 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
         readonly aggregate: string;
     } | undefined;
     type: "session.next.prompt.admitted";
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly type: Schema.Literal<"session.next.execution.settled">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, never, never>;
+    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly outcome: Schema.Literals<readonly ["success", "failure", "interrupted"]>;
+        readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly type: Schema.Literal<"unknown">;
+            readonly message: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly type: Schema.Literal<"unknown">;
+            readonly message: Schema.String;
+        }>>, never, never>;
+        readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+}> & {
+    data: Schema.Struct<{
+        readonly outcome: Schema.Literals<readonly ["success", "failure", "interrupted"]>;
+        readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly type: Schema.Literal<"unknown">;
+            readonly message: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly type: Schema.Literal<"unknown">;
+            readonly message: Schema.String;
+        }>>, never, never>;
+        readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "session.next.execution.settled";
 }, Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;

package/dist/session-event.js CHANGED Viewed

@@ -96,6 +96,14 @@ export const PromptAdmitted = Event.define({
     ...options,
     schema: PromptFields,
 });
+export const ExecutionSettled = Event.define({
+    type: "session.next.execution.settled",
+    schema: {
+        ...Base,
+        outcome: Schema.Literals(["success", "failure", "interrupted"]),
+        error: UnknownError.pipe(optional),
+    },
+});
 export const ContextUpdated = Event.define({
     type: "session.next.context.updated",
     ...options,
@@ -415,7 +423,7 @@ export var RevertEvent;
     });
 })(RevertEvent || (RevertEvent = {}));
 export const DurableDefinitions = Event.inventory(AgentSwitched, ModelSwitched, Moved, Renamed, Forked, Prompted, PromptAdmitted, ContextUpdated, Synthetic, Skill.Activated, Shell.Started, Shell.Ended, Step.Started, Step.Ended, Step.Failed, Text.Started, Text.Ended, Tool.Input.Started, Tool.Input.Ended, Tool.Called, Tool.Progress, Tool.Success, Tool.Failed, Reasoning.Started, Reasoning.Ended, Retried, Compaction.Started, Compaction.Ended, RevertEvent.Staged, RevertEvent.Cleared, RevertEvent.Committed);
-export const Definitions = Event.inventory(AgentSwitched, ModelSwitched, Moved, Renamed, Forked, Prompted, PromptAdmitted, ContextUpdated, Synthetic, Skill.Activated, Shell.Started, Shell.Ended, Step.Started, Step.Ended, Step.Failed, Text.Started, Text.Delta, Text.Ended, Reasoning.Started, Reasoning.Delta, Reasoning.Ended, Tool.Input.Started, Tool.Input.Delta, Tool.Input.Ended, Tool.Called, Tool.Progress, Tool.Success, Tool.Failed, Retried, Compaction.Started, Compaction.Delta, Compaction.Ended, RevertEvent.Staged, RevertEvent.Cleared, RevertEvent.Committed);
+export const Definitions = Event.inventory(AgentSwitched, ModelSwitched, Moved, Renamed, Forked, Prompted, PromptAdmitted, ExecutionSettled, ContextUpdated, Synthetic, Skill.Activated, Shell.Started, Shell.Ended, Step.Started, Step.Ended, Step.Failed, Text.Started, Text.Delta, Text.Ended, Reasoning.Started, Reasoning.Delta, Reasoning.Ended, Tool.Input.Started, Tool.Input.Delta, Tool.Input.Ended, Tool.Called, Tool.Progress, Tool.Success, Tool.Failed, Retried, Compaction.Started, Compaction.Delta, Compaction.Ended, RevertEvent.Staged, RevertEvent.Cleared, RevertEvent.Committed);
 export const Durable = Schema.Union(DurableDefinitions, { mode: "oneOf" })
     .pipe(Schema.toTaggedUnion("type"))
     .annotate({ identifier: "SessionDurableEvent" });

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/schema",
-  "version": "0.0.0-next-14692",
+  "version": "0.0.0-next-14706",
   "type": "module",
   "license": "MIT",
   "repository": {