@opencode/schema 0.0.0-beta-19500 → 0.0.0-dev-19274

package/dist/session-event.js

@@ -24,7 +24,6 @@ import { TokenUsage } from "./token-usage.js";
 import { SessionInbox } from "./session-inbox.js";
 import { Project } from "./project.js";
 import { SessionFork } from "./session-fork.js";
-import { Permission } from "./permission.js";
 export { FileAttachment };
 export const Source = Schema.Struct({
     start: NonNegativeInt,
@@ -57,7 +56,6 @@ export const Created = Event.durable({
         model: Model.Ref.pipe(optional),
         /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
         metadata: SessionMetadata.pipe(optional),
-        permissions: Permission.Ruleset.pipe(optional),
         version: Schema.String,
     },
 });
@@ -95,14 +93,6 @@ export const Renamed = Event.durable({
         title: Schema.String,
     },
 });
-export const PermissionsUpdated = Event.durable({
-    type: "session.permissions.updated",
-    ...options,
-    schema: {
-        ...Base,
-        permissions: Permission.Ruleset,
-    },
-});
 export const Viewed = Event.durable({
     type: "session.viewed",
     ...options,
@@ -112,7 +102,6 @@ export const Viewed = Event.durable({
         idle: Schema.Finite,
     },
 });
-// Replay-only: older releases allowed replacing completed assistant content.
 export const MessageContentUpdated = Event.durable({
     type: "session.message.content.updated",
     ...options,
@@ -514,10 +503,6 @@ export var Compaction;
             providerContext: SessionMessage.CompactionCompleted.fields.providerContext,
             text: Schema.String,
             recent: Schema.String,
-            // Repeats the internal `session.usage.recorded` figures: that event never reaches clients, and it
-            // stays the accounting source for session totals and stats.
-            cost: SessionMessage.CompactionCompleted.fields.cost,
-            tokens: SessionMessage.CompactionCompleted.fields.tokens,
         },
     });
     Compaction.Failed = Event.durable({
@@ -528,8 +513,6 @@ export var Compaction;
             reason: Compaction.Started.data.fields.reason,
             error: SessionError.Error,
             inputID: SessionMessage.ID.pipe(optional),
-            cost: SessionMessage.CompactionFailed.fields.cost,
-            tokens: SessionMessage.CompactionFailed.fields.tokens,
         },
     });
 })(Compaction || (Compaction = {}));
@@ -547,9 +530,9 @@ export var RevertEvent;
         schema: { ...Base, to: SessionMessage.ID },
     });
 })(RevertEvent || (RevertEvent = {}));
-export const Definitions = Event.inventory(Created, AgentSelected, ModelSelected, Moved, Renamed, PermissionsUpdated, Viewed, UsageUpdated, Deleted, Forked, InboxDelivered, InboxEnqueued, InboxCancelled, InboxDeliveryChanged, Execution.Started, Execution.Succeeded, Execution.Failed, Execution.Interrupted, InstructionsUpdated, Synthetic, Skill.Activated, Shell.Started, Shell.Ended, Step.Started, Step.Streamed, 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, RetryScheduled, Compaction.Started, Compaction.Delta, Compaction.Ended, Compaction.Failed, RevertEvent.Staged, RevertEvent.Cleared, RevertEvent.Committed);
-// Internal and replay-only events are excluded from the public manifest.
-export const DurableDefinitions = Event.inventory(...Definitions.filter((definition) => definition.durability === "durable"), UsageRecorded, MessageContentUpdated);
+export const Definitions = Event.inventory(Created, AgentSelected, ModelSelected, Moved, Renamed, Viewed, UsageUpdated, Deleted, Forked, InboxDelivered, InboxEnqueued, InboxCancelled, InboxDeliveryChanged, Execution.Started, Execution.Succeeded, Execution.Failed, Execution.Interrupted, InstructionsUpdated, Synthetic, Skill.Activated, Shell.Started, Shell.Ended, Step.Started, Step.Streamed, 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, RetryScheduled, Compaction.Started, Compaction.Delta, Compaction.Ended, Compaction.Failed, RevertEvent.Staged, RevertEvent.Cleared, RevertEvent.Committed, MessageContentUpdated);
+// UsageRecorded is durable but internal: excluded from Definitions so it never reaches the public manifest.
+export const DurableDefinitions = Event.inventory(...Definitions.filter((definition) => definition.durability === "durable"), UsageRecorded);
 export const EphemeralDefinitions = Event.inventory(...Definitions.filter((definition) => definition.durability === "ephemeral"));
 export const Durable = Schema.Union(DurableDefinitions, { mode: "oneOf" })
     .pipe(Schema.toTaggedUnion("type"))

package/dist/session-message.d.ts

@@ -936,28 +936,6 @@ export declare const CompactionRunning: Schema.Struct<{
 export interface CompactionCompleted extends Schema.Schema.Type<typeof CompactionCompleted> {
 }
 export declare const CompactionCompleted: Schema.Struct<{
-    readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
-        zero: number & import("effect/Brand").Brand<"Money.USD">;
-    }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
-        zero: number & import("effect/Brand").Brand<"Money.USD">;
-    }>, never, never>;
-    readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly input: Schema.Finite;
-        readonly output: Schema.Finite;
-        readonly reasoning: Schema.Finite;
-        readonly cache: Schema.Struct<{
-            readonly read: Schema.Finite;
-            readonly write: Schema.Finite;
-        }>;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly input: Schema.Finite;
-        readonly output: Schema.Finite;
-        readonly reasoning: Schema.Finite;
-        readonly cache: Schema.Struct<{
-            readonly read: Schema.Finite;
-            readonly write: Schema.Finite;
-        }>;
-    }>>, never, never>;
     readonly status: Schema.tag<"completed">;
     readonly reason: Schema.Literals<readonly ["auto", "manual"]>;
     readonly model: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
@@ -1068,28 +1046,6 @@ export declare const CompactionCompleted: Schema.Struct<{
 export interface CompactionFailed extends Schema.Schema.Type<typeof CompactionFailed> {
 }
 export declare const CompactionFailed: Schema.Struct<{
-    readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
-        zero: number & import("effect/Brand").Brand<"Money.USD">;
-    }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
-        zero: number & import("effect/Brand").Brand<"Money.USD">;
-    }>, never, never>;
-    readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly input: Schema.Finite;
-        readonly output: Schema.Finite;
-        readonly reasoning: Schema.Finite;
-        readonly cache: Schema.Struct<{
-            readonly read: Schema.Finite;
-            readonly write: Schema.Finite;
-        }>;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly input: Schema.Finite;
-        readonly output: Schema.Finite;
-        readonly reasoning: Schema.Finite;
-        readonly cache: Schema.Struct<{
-            readonly read: Schema.Finite;
-            readonly write: Schema.Finite;
-        }>;
-    }>>, never, never>;
     readonly status: Schema.tag<"failed">;
     readonly reason: Schema.Literals<readonly ["auto", "manual"]>;
     readonly error: Schema.Struct<{
@@ -1122,28 +1078,6 @@ export declare const Compaction: Schema.Union<readonly [Schema.Struct<{
     }>;
     readonly type: Schema.tag<"compaction">;
 }>, Schema.Struct<{
-    readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
-        zero: number & import("effect/Brand").Brand<"Money.USD">;
-    }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
-        zero: number & import("effect/Brand").Brand<"Money.USD">;
-    }>, never, never>;
-    readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly input: Schema.Finite;
-        readonly output: Schema.Finite;
-        readonly reasoning: Schema.Finite;
-        readonly cache: Schema.Struct<{
-            readonly read: Schema.Finite;
-            readonly write: Schema.Finite;
-        }>;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly input: Schema.Finite;
-        readonly output: Schema.Finite;
-        readonly reasoning: Schema.Finite;
-        readonly cache: Schema.Struct<{
-            readonly read: Schema.Finite;
-            readonly write: Schema.Finite;
-        }>;
-    }>>, never, never>;
     readonly status: Schema.tag<"completed">;
     readonly reason: Schema.Literals<readonly ["auto", "manual"]>;
     readonly model: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
@@ -1251,28 +1185,6 @@ export declare const Compaction: Schema.Union<readonly [Schema.Struct<{
     }>;
     readonly type: Schema.tag<"compaction">;
 }>, Schema.Struct<{
-    readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
-        zero: number & import("effect/Brand").Brand<"Money.USD">;
-    }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
-        zero: number & import("effect/Brand").Brand<"Money.USD">;
-    }>, never, never>;
-    readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly input: Schema.Finite;
-        readonly output: Schema.Finite;
-        readonly reasoning: Schema.Finite;
-        readonly cache: Schema.Struct<{
-            readonly read: Schema.Finite;
-            readonly write: Schema.Finite;
-        }>;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly input: Schema.Finite;
-        readonly output: Schema.Finite;
-        readonly reasoning: Schema.Finite;
-        readonly cache: Schema.Struct<{
-            readonly read: Schema.Finite;
-            readonly write: Schema.Finite;
-        }>;
-    }>>, never, never>;
     readonly status: Schema.tag<"failed">;
     readonly reason: Schema.Literals<readonly ["auto", "manual"]>;
     readonly error: Schema.Struct<{
@@ -1835,28 +1747,6 @@ export declare const Info: Schema.Union<readonly [Schema.Struct<{
     }>;
     readonly type: Schema.tag<"compaction">;
 }>, Schema.Struct<{
-    readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
-        zero: number & import("effect/Brand").Brand<"Money.USD">;
-    }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
-        zero: number & import("effect/Brand").Brand<"Money.USD">;
-    }>, never, never>;
-    readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly input: Schema.Finite;
-        readonly output: Schema.Finite;
-        readonly reasoning: Schema.Finite;
-        readonly cache: Schema.Struct<{
-            readonly read: Schema.Finite;
-            readonly write: Schema.Finite;
-        }>;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly input: Schema.Finite;
-        readonly output: Schema.Finite;
-        readonly reasoning: Schema.Finite;
-        readonly cache: Schema.Struct<{
-            readonly read: Schema.Finite;
-            readonly write: Schema.Finite;
-        }>;
-    }>>, never, never>;
     readonly status: Schema.tag<"completed">;
     readonly reason: Schema.Literals<readonly ["auto", "manual"]>;
     readonly model: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
@@ -1964,28 +1854,6 @@ export declare const Info: Schema.Union<readonly [Schema.Struct<{
     }>;
     readonly type: Schema.tag<"compaction">;
 }>, Schema.Struct<{
-    readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
-        zero: number & import("effect/Brand").Brand<"Money.USD">;
-    }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
-        zero: number & import("effect/Brand").Brand<"Money.USD">;
-    }>, never, never>;
-    readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly input: Schema.Finite;
-        readonly output: Schema.Finite;
-        readonly reasoning: Schema.Finite;
-        readonly cache: Schema.Struct<{
-            readonly read: Schema.Finite;
-            readonly write: Schema.Finite;
-        }>;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly input: Schema.Finite;
-        readonly output: Schema.Finite;
-        readonly reasoning: Schema.Finite;
-        readonly cache: Schema.Struct<{
-            readonly read: Schema.Finite;
-            readonly write: Schema.Finite;
-        }>;
-    }>>, never, never>;
     readonly status: Schema.tag<"failed">;
     readonly reason: Schema.Literals<readonly ["auto", "manual"]>;
     readonly error: Schema.Struct<{

package/dist/session-message.js

@@ -182,11 +182,6 @@ export const Assistant = Schema.Struct({
     }),
 }).annotate({ identifier: "Session.Message.Assistant" });
 const CompactionBase = { type: Schema.tag("compaction"), ...Base };
-/** Usage of the compaction request itself, not the size of the resulting context. */
-const CompactionUsage = {
-    cost: Money.USD.pipe(optional),
-    tokens: TokenUsage.Info.pipe(optional),
-};
 export const CompactionRunning = Schema.Struct({
     ...CompactionBase,
     status: Schema.tag("running"),
@@ -203,14 +198,12 @@ export const CompactionCompleted = Schema.Struct({
     summary: Schema.String,
     recent: Schema.String,
     providerContext: SessionProviderContext.Info.pipe(optional),
-    ...CompactionUsage,
 }).annotate({ identifier: "Session.Message.Compaction.Completed" });
 export const CompactionFailed = Schema.Struct({
     ...CompactionBase,
     status: Schema.tag("failed"),
     reason: Schema.Literals(["auto", "manual"]),
     error: SessionError.Error,
-    ...CompactionUsage,
 }).annotate({ identifier: "Session.Message.Compaction.Failed" });
 export const Compaction = Schema.Union([CompactionRunning, CompactionCompleted, CompactionFailed]).pipe(Schema.toTaggedUnion("status"), Schema.annotate({ identifier: "Session.Message.Compaction" }));
 export const Info = Schema.Union([

package/dist/session-transfer.d.ts

@@ -134,15 +134,6 @@ export declare const Data: Schema.Struct<{
         }>;
         readonly subpath: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "RelativePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "RelativePath">>, never, never>;
         readonly metadata: 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>;
-        readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-            readonly action: Schema.String;
-            readonly resource: Schema.String;
-            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
-        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly action: Schema.String;
-            readonly resource: Schema.String;
-            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
-        }>>>, never, never>;
         readonly revert: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
                 create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -726,28 +717,6 @@ export declare const Data: Schema.Struct<{
         }>;
         readonly type: Schema.tag<"compaction">;
     }>, Schema.Struct<{
-        readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
-            zero: number & import("effect/Brand").Brand<"Money.USD">;
-        }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
-            zero: number & import("effect/Brand").Brand<"Money.USD">;
-        }>, never, never>;
-        readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly input: Schema.Finite;
-            readonly output: Schema.Finite;
-            readonly reasoning: Schema.Finite;
-            readonly cache: Schema.Struct<{
-                readonly read: Schema.Finite;
-                readonly write: Schema.Finite;
-            }>;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly input: Schema.Finite;
-            readonly output: Schema.Finite;
-            readonly reasoning: Schema.Finite;
-            readonly cache: Schema.Struct<{
-                readonly read: Schema.Finite;
-                readonly write: Schema.Finite;
-            }>;
-        }>>, never, never>;
         readonly status: Schema.tag<"completed">;
         readonly reason: Schema.Literals<readonly ["auto", "manual"]>;
         readonly model: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
@@ -855,28 +824,6 @@ export declare const Data: Schema.Struct<{
         }>;
         readonly type: Schema.tag<"compaction">;
     }>, Schema.Struct<{
-        readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
-            zero: number & import("effect/Brand").Brand<"Money.USD">;
-        }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
-            zero: number & import("effect/Brand").Brand<"Money.USD">;
-        }>, never, never>;
-        readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly input: Schema.Finite;
-            readonly output: Schema.Finite;
-            readonly reasoning: Schema.Finite;
-            readonly cache: Schema.Struct<{
-                readonly read: Schema.Finite;
-                readonly write: Schema.Finite;
-            }>;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly input: Schema.Finite;
-            readonly output: Schema.Finite;
-            readonly reasoning: Schema.Finite;
-            readonly cache: Schema.Struct<{
-                readonly read: Schema.Finite;
-                readonly write: Schema.Finite;
-            }>;
-        }>>, never, never>;
         readonly status: Schema.tag<"failed">;
         readonly reason: Schema.Literals<readonly ["auto", "manual"]>;
         readonly error: Schema.Struct<{

package/dist/session.d.ts

@@ -172,16 +172,6 @@ export declare const Info: Schema.Struct<{
     }>;
     readonly subpath: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "RelativePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "RelativePath">>, never, never>;
     readonly metadata: 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>;
-    /** Evaluated after the agent's rules; the last matching rule wins. */
-    readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-        readonly action: Schema.String;
-        readonly resource: Schema.String;
-        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
-    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-        readonly action: Schema.String;
-        readonly resource: Schema.String;
-        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
-    }>>>, never, never>;
     readonly revert: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;

package/dist/session.js

@@ -9,7 +9,6 @@ import { SessionEvent } from "./session-event.js";
 import { SessionID } from "./session-id.js";
 import { SessionMetadata } from "./session-metadata.js";
 import { Money } from "./money.js";
-import { Permission } from "./permission.js";
 import { TokenUsage } from "./token-usage.js";
 import { Revert } from "./session-revert.js";
 import { SessionFork } from "./session-fork.js";
@@ -44,8 +43,6 @@ export const Info = Schema.Struct({
     location: Location.Ref,
     subpath: RelativePath.pipe(optional),
     metadata: Metadata.pipe(optional),
-    /** Evaluated after the agent's rules; the last matching rule wins. */
-    permissions: Permission.Ruleset.pipe(optional),
     revert: Revert.pipe(optional),
 }).annotate({ identifier: "Session.Info" });
 export const ListAnchor = Schema.Struct({

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/schema",
-  "version": "0.0.0-beta-19500",
+  "version": "0.0.0-dev-19274",
   "type": "module",
   "license": "MIT",
   "repository": {