npm - @opencode/core - Versions diffs - 2.1.2 → 2.1.4 - Mend

@opencode/core 2.1.2 → 2.1.4

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 (856) hide show

package/dist/types/session/inbox.d.ts CHANGED Viewed

@@ -20,7 +20,7 @@ export declare const serialized: <A, E, R>(sessionID: SessionSchema.ID, effect:
 declare const LifecycleConflict_base: Schema.Class<LifecycleConflict, Schema.TaggedStruct<"SessionInbox.LifecycleConflict", {
     readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-        fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.ID">;
     };
 }>, import("effect/Cause").YieldableError>;
 export declare class LifecycleConflict extends LifecycleConflict_base {

package/dist/types/session/model-request.d.ts CHANGED Viewed

@@ -40,7 +40,7 @@ export interface Input {
     };
 }
 /** The default output limit: the catalog limit, fitted to the room the prompt leaves in the context window. */
-export declare const outputLimit: (limit: Model.Info["limit"], kind: "primary" | "compaction", inputTokens?: Input["inputTokens"]) => number;
+export declare const outputLimit: (limit: Model.Info["limit"], inputTokens?: Input["inputTokens"]) => number;
 export declare const baseTranscript: (input: {
     readonly agent: Agent.Info;
     readonly model: SessionRunnerModel.Resolved;

package/dist/types/session/runner/model.d.ts CHANGED Viewed

@@ -8,7 +8,6 @@ import { SessionSchema } from "../schema.js";
 declare const ModelNotSelectedError_base: Schema.Class<ModelNotSelectedError, Schema.TaggedStruct<"SessionRunnerModel.ModelNotSelectedError", {
     readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     };
 }>, import("effect/Cause").YieldableError>;
 export declare class ModelNotSelectedError extends ModelNotSelectedError_base {

package/dist/types/session/runner/publish-llm-event.d.ts CHANGED Viewed

@@ -3,13 +3,13 @@ import type { Agent } from "@opencode/schema/agent";
 import type { Model } from "@opencode/schema/model";
 import type { RelativePath } from "@opencode/schema/schema";
 import type { Snapshot } from "@opencode/schema/snapshot";
+import type { TokenUsage } from "@opencode/schema/token-usage";
 import { Effect } from "effect";
 import { Bus } from "../../bus.js";
 import { SessionMessage } from "../message.js";
 import { SessionSchema } from "../schema.js";
 import { SessionError } from "@opencode/schema/session-error";
 import { Money } from "@opencode/schema/money";
-import { SessionUsage } from "../usage.js";
 import type { Tool } from "../../tool.js";
 type Input = {
     readonly sessionID: SessionSchema.ID;
@@ -35,7 +35,7 @@ export interface StepRecord {
         }>["reason"]["normalized"];
         readonly rawFinish?: string;
         readonly native?: SessionMessage.Native;
-        readonly tokens: ReturnType<typeof SessionUsage.tokens>;
+        readonly tokens: TokenUsage.Info;
     };
     readonly needsContinuation: boolean;
 }
@@ -61,7 +61,7 @@ export declare const createLLMEventPublisher: (bus: Pick<Bus.Interface, "publish
     failTool: (id: string, error: SessionError.Error, metadata?: Readonly<Record<string, any>> | undefined) => Effect.Effect<boolean, never, never>;
     publishStepFailure: (details?: {
         readonly cost?: Money.USD;
-        readonly tokens?: ReturnType<typeof SessionUsage.tokens>;
+        readonly tokens?: TokenUsage.Info;
         readonly snapshot?: Snapshot.ID;
         readonly files?: readonly RelativePath[];
     } | undefined) => Effect.Effect<void, never, never>;

package/dist/types/session/runner/step.d.ts CHANGED Viewed

@@ -202,4 +202,4 @@ export declare const make: Effect.Effect<{
         readonly error: SessionError.Error;
         readonly decision: SessionRunnerRetry.Decision;
     }, AIError | StepFailedError, never>;
-}, never, import("@opencode/ai").LLMClientService | Bus.Service | Snapshot.Service | ToolOutput.Service>;
+}, never, import("@opencode/ai").LLMClientService | Bus.Service | ToolOutput.Service | Snapshot.Service>;

package/dist/types/session/schema.d.ts CHANGED Viewed

@@ -2,55 +2,49 @@ export * as SessionSchema from "@opencode/schema/session";
 import { Session } from "@opencode/schema/session";
 export declare const ID: 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">;
 };
 export type ID = typeof ID.Type;
 export declare const Info: import("effect/Schema").Struct<{
     readonly id: 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">;
     };
     readonly parentID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<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">;
     }>>, import("effect/Schema").optionalKey<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">;
     }>, never, never>;
     readonly fork: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
         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">;
         };
         readonly boundary: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
             readonly type: import("effect/Schema").Literal<"before">;
             readonly messageID: import("effect/Schema").brand<import("effect/Schema").String, "Session.Message.ID"> & {
                 create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-                fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+                fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.ID">;
             };
         }>, import("effect/Schema").Struct<{
             readonly type: import("effect/Schema").Literal<"through">;
             readonly messageID: import("effect/Schema").brand<import("effect/Schema").String, "Session.Message.ID"> & {
                 create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-                fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+                fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.ID">;
             };
         }>]>;
     }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
         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">;
         };
         readonly boundary: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
             readonly type: import("effect/Schema").Literal<"before">;
             readonly messageID: import("effect/Schema").brand<import("effect/Schema").String, "Session.Message.ID"> & {
                 create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-                fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+                fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.ID">;
             };
         }>, import("effect/Schema").Struct<{
             readonly type: import("effect/Schema").Literal<"through">;
             readonly messageID: import("effect/Schema").brand<import("effect/Schema").String, "Session.Message.ID"> & {
                 create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-                fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+                fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.ID">;
             };
         }>]>;
     }>>, never, never>;
@@ -148,7 +142,7 @@ export declare const Info: import("effect/Schema").Struct<{
     readonly revert: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
         readonly messageID: import("effect/Schema").brand<import("effect/Schema").String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
         readonly partID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
         readonly snapshot: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Snapshot.ID">>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Snapshot.ID">>, never, never>;
@@ -168,7 +162,7 @@ export declare const Info: import("effect/Schema").Struct<{
     }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
         readonly messageID: import("effect/Schema").brand<import("effect/Schema").String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
         readonly partID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
         readonly snapshot: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Snapshot.ID">>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Snapshot.ID">>, never, never>;

package/dist/types/session/sql.d.ts CHANGED Viewed

@@ -458,7 +458,7 @@ export declare const SessionTable: import("drizzle-orm/sqlite-core").SQLiteTable
             name: string;
             tableName: "session_v2";
             dataType: "string";
-            data: string;
+            data: string & import("effect/Brand").Brand<"Agent.ID">;
             driverParam: string;
             notNull: false;
             hasDefault: false;

package/dist/types/session/stats.d.ts CHANGED Viewed

@@ -1,8 +1,9 @@
 export * as SessionStats from "./stats.js";
-import { DateTime, Effect, Schema } from "effect";
+import { DateTime, Effect, Schema, type Types } from "effect";
 import { Model } from "@opencode/schema/model";
 import { Project } from "@opencode/schema/project";
 import { ToolMode } from "@opencode/schema/session-stats";
+import { TokenUsage } from "@opencode/schema/token-usage";
 import { Database } from "../database/database.js";
 type Input = {
     readonly from?: number;
@@ -11,15 +12,7 @@ type Input = {
     readonly timezone?: string;
     readonly tools?: ToolMode;
 };
-type Tokens = {
-    input: number;
-    output: number;
-    reasoning: number;
-    cache: {
-        read: number;
-        write: number;
-    };
-};
+type Tokens = Types.DeepMutable<TokenUsage.Info>;
 declare const InvalidRangeError_base: Schema.Class<InvalidRangeError, Schema.TaggedStruct<"SessionStats.InvalidRangeError", {
     readonly from: Schema.Finite;
     readonly to: Schema.Finite;
@@ -35,7 +28,15 @@ export declare const get: (input?: Input | undefined) => Effect.Effect<{
     subagents: number;
     prompts: number;
     steps: number;
-    tokens: Tokens;
+    tokens: {
+        input: number;
+        output: number;
+        reasoning: number;
+        cache: {
+            read: number;
+            write: number;
+        };
+    };
     cost: number & import("effect/Brand").Brand<"Money.USD">;
     tools: {
         mode: "none";

package/dist/types/session/store.d.ts CHANGED Viewed

@@ -13,13 +13,11 @@ export declare const ListInput: Schema.Union<readonly [Schema.Struct<{
     readonly order: Schema.optional<Schema.Literals<readonly ["asc", "desc"]>>;
     readonly parentID: Schema.optional<Schema.NullOr<Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     }>>;
     readonly archived: Schema.optional<Schema.Boolean>;
     readonly anchor: Schema.optional<Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
         readonly time: Schema.Finite;
         readonly direction: Schema.Literals<readonly ["previous", "next"]>;
@@ -35,13 +33,11 @@ export declare const ListInput: Schema.Union<readonly [Schema.Struct<{
     readonly order: Schema.optional<Schema.Literals<readonly ["asc", "desc"]>>;
     readonly parentID: Schema.optional<Schema.NullOr<Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     }>>;
     readonly archived: Schema.optional<Schema.Boolean>;
     readonly anchor: Schema.optional<Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
         readonly time: Schema.Finite;
         readonly direction: Schema.Literals<readonly ["previous", "next"]>;
@@ -60,13 +56,11 @@ export declare const ListInput: Schema.Union<readonly [Schema.Struct<{
     order: Schema.optional<Schema.Literals<readonly ["asc", "desc"]>>;
     parentID: Schema.optional<Schema.NullOr<Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     }>>;
     archived: Schema.optional<Schema.Boolean>;
     anchor: Schema.optional<Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
         readonly time: Schema.Finite;
         readonly direction: Schema.Literals<readonly ["previous", "next"]>;

package/dist/types/session/transfer.d.ts CHANGED Viewed

@@ -7,49 +7,44 @@ export declare const Data: Schema.Struct<{
     readonly info: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
         readonly parentID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         }>>, Schema.optionalKey<Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         }>, never, never>;
         readonly fork: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
                 create: () => string & import("effect/Brand").Brand<"SessionID">;
-                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
             };
             readonly boundary: Schema.Union<readonly [Schema.Struct<{
                 readonly type: Schema.Literal<"before">;
                 readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
                     create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-                    fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+                    fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.ID">;
                 };
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"through">;
                 readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
                     create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-                    fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+                    fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.ID">;
                 };
             }>]>;
         }>>>, Schema.optionalKey<Schema.Struct<{
             readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
                 create: () => string & import("effect/Brand").Brand<"SessionID">;
-                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
             };
             readonly boundary: Schema.Union<readonly [Schema.Struct<{
                 readonly type: Schema.Literal<"before">;
                 readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
                     create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-                    fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+                    fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.ID">;
                 };
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"through">;
                 readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
                     create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-                    fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+                    fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.ID">;
                 };
             }>]>;
         }>>, never, never>;
@@ -147,7 +142,7 @@ export declare const Data: Schema.Struct<{
         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">;
-                fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+                fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.ID">;
             };
             readonly partID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
             readonly snapshot: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Snapshot.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Snapshot.ID">>, never, never>;
@@ -167,7 +162,7 @@ export declare const Data: Schema.Struct<{
         }>>>, Schema.optionalKey<Schema.Struct<{
             readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
                 create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-                fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+                fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.ID">;
             };
             readonly partID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
             readonly snapshot: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Snapshot.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Snapshot.ID">>, never, never>;
@@ -189,7 +184,7 @@ export declare const Data: Schema.Struct<{
     readonly messages: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.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 time: Schema.Struct<{
@@ -201,7 +196,7 @@ export declare const Data: Schema.Struct<{
     }>, Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.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 time: Schema.Struct<{
@@ -279,7 +274,7 @@ export declare const Data: Schema.Struct<{
     }>, Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.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 time: Schema.Struct<{
@@ -340,7 +335,7 @@ export declare const Data: Schema.Struct<{
     }>, Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.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 time: Schema.Struct<{
@@ -478,7 +473,7 @@ export declare const Data: Schema.Struct<{
     }>, Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.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 time: Schema.Struct<{
@@ -490,7 +485,7 @@ export declare const Data: Schema.Struct<{
     }>, Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.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 time: Schema.Struct<{
@@ -502,7 +497,7 @@ export declare const Data: Schema.Struct<{
     }>, Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.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 time: Schema.Struct<{
@@ -515,7 +510,7 @@ export declare const Data: Schema.Struct<{
     }>, Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.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.tag<"shell">;
@@ -544,7 +539,7 @@ export declare const Data: Schema.Struct<{
     }>, Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.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.tag<"assistant">;
@@ -744,7 +739,7 @@ export declare const Data: Schema.Struct<{
     }>, Schema.Union<readonly [Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.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 time: Schema.Struct<{
@@ -757,7 +752,7 @@ export declare const Data: Schema.Struct<{
     }>, Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.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 time: Schema.Struct<{
@@ -838,7 +833,7 @@ export declare const Data: Schema.Struct<{
     }>, Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.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 time: Schema.Struct<{
@@ -883,7 +878,7 @@ export declare const Data: Schema.Struct<{
     }>]>, Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-            fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+            fromEvent: (eventID: string) => string & import("effect/Brand").Brand<"Session.Message.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 time: Schema.Struct<{
@@ -918,7 +913,6 @@ export type Data = SessionTransfer.Data;
 declare const ImportConflictError_base: Schema.Class<ImportConflictError, Schema.TaggedStruct<"SessionTransfer.ImportConflictError", {
     readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     };
 }>, import("effect/Cause").YieldableError>;
 export declare class ImportConflictError extends ImportConflictError_base {

package/dist/types/session.d.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 export * as Session from "./session.js";
 export * from "./session/schema.js";
-import { Effect, Schema, Context, Stream } from "effect";
+import { Effect, Context, Stream } from "effect";
 import { ListAnchor, ListCursor, ListFilter } from "@opencode/schema/session";
 import { Model } from "@opencode/schema/model";
 import { Location } from "./location.js";
@@ -27,73 +27,67 @@ import type { FileDiff } from "@opencode/schema/file-diff";
 import type { Command } from "./command.js";
 import { SessionEnvironment } from "./session/environment.js";
 export { ListAnchor, ListCursor };
-export declare const ListInput: Schema.Union<readonly [Schema.Struct<{
-    readonly workspaceID: Schema.optional<Schema.brand<Schema.String, "Workspace.ID"> & {
+export declare const ListInput: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+    readonly workspaceID: import("effect/Schema").optional<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
         ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
         create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
     }>;
-    readonly search: Schema.optional<Schema.String>;
-    readonly limit: Schema.optional<Schema.Int>;
-    readonly order: Schema.optional<Schema.Literals<readonly ["asc", "desc"]>>;
-    readonly parentID: Schema.optional<Schema.NullOr<Schema.brand<Schema.String, "SessionID"> & {
+    readonly search: import("effect/Schema").optional<import("effect/Schema").String>;
+    readonly limit: import("effect/Schema").optional<import("effect/Schema").Int>;
+    readonly order: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["asc", "desc"]>>;
+    readonly parentID: import("effect/Schema").optional<import("effect/Schema").NullOr<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">;
     }>>;
-    readonly archived: Schema.optional<Schema.Boolean>;
-    readonly anchor: Schema.optional<Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "SessionID"> & {
+    readonly archived: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+    readonly anchor: import("effect/Schema").optional<import("effect/Schema").Struct<{
+        readonly id: 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">;
         };
-        readonly time: Schema.Finite;
-        readonly direction: Schema.Literals<readonly ["previous", "next"]>;
+        readonly time: import("effect/Schema").Finite;
+        readonly direction: import("effect/Schema").Literals<readonly ["previous", "next"]>;
     }>>;
-    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-}>, Schema.Struct<{
-    readonly workspaceID: Schema.optional<Schema.brand<Schema.String, "Workspace.ID"> & {
+    readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+}>, import("effect/Schema").Struct<{
+    readonly workspaceID: import("effect/Schema").optional<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
         ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
         create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
     }>;
-    readonly search: Schema.optional<Schema.String>;
-    readonly limit: Schema.optional<Schema.Int>;
-    readonly order: Schema.optional<Schema.Literals<readonly ["asc", "desc"]>>;
-    readonly parentID: Schema.optional<Schema.NullOr<Schema.brand<Schema.String, "SessionID"> & {
+    readonly search: import("effect/Schema").optional<import("effect/Schema").String>;
+    readonly limit: import("effect/Schema").optional<import("effect/Schema").Int>;
+    readonly order: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["asc", "desc"]>>;
+    readonly parentID: import("effect/Schema").optional<import("effect/Schema").NullOr<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">;
     }>>;
-    readonly archived: Schema.optional<Schema.Boolean>;
-    readonly anchor: Schema.optional<Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "SessionID"> & {
+    readonly archived: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+    readonly anchor: import("effect/Schema").optional<import("effect/Schema").Struct<{
+        readonly id: 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">;
         };
-        readonly time: Schema.Finite;
-        readonly direction: Schema.Literals<readonly ["previous", "next"]>;
+        readonly time: import("effect/Schema").Finite;
+        readonly direction: import("effect/Schema").Literals<readonly ["previous", "next"]>;
     }>>;
-    readonly project: Schema.brand<Schema.String, "Project.ID"> & {
+    readonly project: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
         global: string & import("effect/Brand").Brand<"Project.ID">;
     };
-    readonly subpath: Schema.optional<Schema.brand<Schema.String, "RelativePath">>;
-}>, Schema.Struct<{
-    workspaceID: Schema.optional<Schema.brand<Schema.String, "Workspace.ID"> & {
+    readonly subpath: import("effect/Schema").optional<import("effect/Schema").brand<import("effect/Schema").String, "RelativePath">>;
+}>, import("effect/Schema").Struct<{
+    workspaceID: import("effect/Schema").optional<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
         ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
         create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
     }>;
-    search: Schema.optional<Schema.String>;
-    limit: Schema.optional<Schema.Int>;
-    order: Schema.optional<Schema.Literals<readonly ["asc", "desc"]>>;
-    parentID: Schema.optional<Schema.NullOr<Schema.brand<Schema.String, "SessionID"> & {
+    search: import("effect/Schema").optional<import("effect/Schema").String>;
+    limit: import("effect/Schema").optional<import("effect/Schema").Int>;
+    order: import("effect/Schema").optional<import("effect/Schema").Literals<readonly ["asc", "desc"]>>;
+    parentID: import("effect/Schema").optional<import("effect/Schema").NullOr<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">;
     }>>;
-    archived: Schema.optional<Schema.Boolean>;
-    anchor: Schema.optional<Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "SessionID"> & {
+    archived: import("effect/Schema").optional<import("effect/Schema").Boolean>;
+    anchor: import("effect/Schema").optional<import("effect/Schema").Struct<{
+        readonly id: 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">;
         };
-        readonly time: Schema.Finite;
-        readonly direction: Schema.Literals<readonly ["previous", "next"]>;
+        readonly time: import("effect/Schema").Finite;
+        readonly direction: import("effect/Schema").Literals<readonly ["previous", "next"]>;
     }>>;
 }>]>;
 export type ListInput = SessionStore.ListInput;
@@ -119,7 +113,7 @@ type ForkInput = {
     sessionID: SessionSchema.ID;
     before?: SessionMessage.ID;
 };
-export { AttachmentError, BusyError, CompactionConflictError, InboxConflictError, InvalidListCursorError, MessageDecodeError, MessageNotFoundError, NotFoundError, PromptConflictError, SkillNotFoundError, SyntheticConflictError, };
+export { AttachmentError, BusyError, CompactionConflictError, ForkEmptyError, InboxConflictError, InvalidListCursorError, MessageDecodeError, MessageNotFoundError, NotFoundError, PromptConflictError, SkillNotFoundError, SyntheticConflictError, };
 type InboxItemRef = {
     readonly sessionID: SessionSchema.ID;
     readonly inboxID: SessionMessage.ID;

package/dist/types/shell/parser-wasm.bun.d.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 export declare const shellParserWasm: {
-    runtime: any;
-    bash: any;
-    powershell: any;
+    runtime: string;
+    bash: string;
+    powershell: string;
 };

package/dist/types/tool/mcp.d.ts CHANGED Viewed

@@ -4,6 +4,7 @@ import { Bus } from "../bus.js";
 import { Mcp } from "../mcp/index.js";
 import { Permission } from "../permission.js";
 import { Tool } from "../tool.js";
+import { ToolOutput } from "../tool-output.js";
 /**
  * Registry namespace and permission action names for MCP tools.
  */
@@ -16,5 +17,5 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@opencode/McpTool", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, Bus.Service | Permission.Service | Tool.Service | Mcp.Service>;
+export declare const layer: Layer.Layer<Service, never, Bus.Service | Permission.Service | Tool.Service | Mcp.Service | ToolOutput.Service>;
 export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;