npm - @opencode-ai/schema - Versions diffs - 0.0.0-beta-18155 → 0.0.0-beta-18219 - Mend

@opencode-ai/schema 0.0.0-beta-18155 → 0.0.0-beta-18219

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

package/dist/config/provider.d.ts +2 -0
package/dist/event-manifest.d.ts +292 -0
package/dist/event-manifest.js +2 -1
package/dist/index.d.ts +1 -0
package/dist/index.js +1 -0
package/dist/model.d.ts +3 -0
package/dist/model.js +1 -0
package/dist/permission.d.ts +5 -0
package/dist/permission.js +1 -0
package/dist/persistent-pty.d.ts +530 -0
package/dist/persistent-pty.js +34 -0
package/dist/project.d.ts +22 -0
package/dist/project.js +6 -0
package/dist/tool.d.ts +2 -2
package/dist/vcs.d.ts +2 -0
package/dist/vcs.js +1 -0
package/dist/worktree.d.ts +1 -0
package/dist/worktree.js +1 -0
package/package.json +1 -1

package/dist/config/provider.d.ts CHANGED Viewed

@@ -86,10 +86,12 @@ declare const Model_base: Schema.Class<Model, Schema.Struct<{
         readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("../model.js").ReasoningField, import("../model.js").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("../model.js").ReasoningField, import("../model.js").ReasoningField, never, never>>, never, never>;
         readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
         readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
     }>>>, Schema.optionalKey<Schema.Struct<{
         readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<import("../model.js").ReasoningField, import("../model.js").ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<import("../model.js").ReasoningField, import("../model.js").ReasoningField, never, never>>, never, never>;
         readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
         readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
     }>>, never, never>;
     readonly package: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
 }>, {}>;

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

@@ -3925,6 +3925,7 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
             readonly messageID: Schema.String;
             readonly id: Schema.String;
         }>]>>, never, never>;
+        readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
             create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
         };
@@ -3951,6 +3952,7 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
             readonly messageID: Schema.String;
             readonly id: Schema.String;
         }>]>>, never, never>;
+        readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
             create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
         };
@@ -4471,6 +4473,150 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
             ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
         };
     }>;
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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<"persistent-pty.added">;
+    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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: 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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+            readonly size: Schema.Struct<{
+                readonly cols: Schema.Int;
+                readonly rows: Schema.Int;
+            }>;
+            readonly output: Schema.Struct<{
+                readonly head: Schema.Int;
+                readonly tail: Schema.Int;
+            }>;
+            readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+            readonly title: Schema.String;
+            readonly command: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+            readonly cwd: Schema.String;
+            readonly status: Schema.Literals<readonly ["running", "exited"]>;
+            readonly pid: Schema.Int;
+            readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        }>;
+    }>;
+}> & {
+    type: "persistent-pty.added";
+    durability: "ephemeral";
+    durable: undefined;
+    data: 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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+            readonly size: Schema.Struct<{
+                readonly cols: Schema.Int;
+                readonly rows: Schema.Int;
+            }>;
+            readonly output: Schema.Struct<{
+                readonly head: Schema.Int;
+                readonly tail: Schema.Int;
+            }>;
+            readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+            readonly title: Schema.String;
+            readonly command: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+            readonly cwd: Schema.String;
+            readonly status: Schema.Literals<readonly ["running", "exited"]>;
+            readonly pid: Schema.Int;
+            readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        }>;
+    }>;
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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<"persistent-pty.removed">;
+    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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: 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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+    }>;
+}> & {
+    type: "persistent-pty.removed";
+    durability: "ephemeral";
+    durable: undefined;
+    data: 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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+    }>;
 }, Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -9489,6 +9635,7 @@ export declare const Definitions: readonly [Schema.Struct<{
             readonly messageID: Schema.String;
             readonly id: Schema.String;
         }>]>>, never, never>;
+        readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
             create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
         };
@@ -9515,6 +9662,7 @@ export declare const Definitions: readonly [Schema.Struct<{
             readonly messageID: Schema.String;
             readonly id: Schema.String;
         }>]>>, never, never>;
+        readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
             create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
         };
@@ -10035,6 +10183,150 @@ export declare const Definitions: readonly [Schema.Struct<{
             ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
         };
     }>;
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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<"persistent-pty.added">;
+    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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: 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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+            readonly size: Schema.Struct<{
+                readonly cols: Schema.Int;
+                readonly rows: Schema.Int;
+            }>;
+            readonly output: Schema.Struct<{
+                readonly head: Schema.Int;
+                readonly tail: Schema.Int;
+            }>;
+            readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+            readonly title: Schema.String;
+            readonly command: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+            readonly cwd: Schema.String;
+            readonly status: Schema.Literals<readonly ["running", "exited"]>;
+            readonly pid: Schema.Int;
+            readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        }>;
+    }>;
+}> & {
+    type: "persistent-pty.added";
+    durability: "ephemeral";
+    durable: undefined;
+    data: 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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+            readonly size: Schema.Struct<{
+                readonly cols: Schema.Int;
+                readonly rows: Schema.Int;
+            }>;
+            readonly output: Schema.Struct<{
+                readonly head: Schema.Int;
+                readonly tail: Schema.Int;
+            }>;
+            readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+            readonly title: Schema.String;
+            readonly command: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+            readonly cwd: Schema.String;
+            readonly status: Schema.Literals<readonly ["running", "exited"]>;
+            readonly pid: Schema.Int;
+            readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        }>;
+    }>;
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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<"persistent-pty.removed">;
+    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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: 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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+    }>;
+}> & {
+    type: "persistent-pty.removed";
+    durability: "ephemeral";
+    durable: undefined;
+    data: 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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+    }>;
 }, Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;

package/dist/event-manifest.js CHANGED Viewed

@@ -16,6 +16,7 @@ import { LspEvent } from "./lsp-event.js";
 import { McpEvent } from "./mcp-event.js";
 import { ModelsDev } from "./models-dev.js";
 import { Permission } from "./permission.js";
+import { PersistentPty } from "./persistent-pty.js";
 import { Plugin } from "./plugin.js";
 import { Project } from "./project.js";
 import { Worktree } from "./worktree.js";
@@ -34,7 +35,7 @@ import { WorktreeEvent } from "./worktree-event.js";
 import { WebSearch } from "./websearch.js";
 const coreDefinitions = Event.inventory(...SessionEvent.Definitions);
 const foundationDefinitions = Event.inventory(...ModelsDev.Event.Definitions, ...Integration.Event.Definitions, ...Catalog.Event.Definitions, ...Agent.Event.Definitions, ...coreDefinitions);
-const featureDefinitions = Event.inventory(...FileSystem.Event.Definitions, ...Reference.Event.Definitions, ...Permission.Event.Definitions, ...Plugin.Event.Definitions, ...Worktree.Event.Definitions, ...Command.Event.Definitions, ...Config.Event.Definitions, ...Skill.Event.Definitions, ...Pty.Event.Definitions, ...Shell.Event.Definitions, ...Form.Event.Definitions, ...WebSearch.Event.Definitions);
+const featureDefinitions = Event.inventory(...FileSystem.Event.Definitions, ...Reference.Event.Definitions, ...Permission.Event.Definitions, ...Plugin.Event.Definitions, ...Worktree.Event.Definitions, ...Command.Event.Definitions, ...Config.Event.Definitions, ...Skill.Event.Definitions, ...Pty.Event.Definitions, ...PersistentPty.Event.Definitions, ...Shell.Event.Definitions, ...Form.Event.Definitions, ...WebSearch.Event.Definitions);
 export const ServerDefinitions = Event.inventory(...foundationDefinitions, ...featureDefinitions,
 // Current events the TUI consumes from the public stream.
 ...SessionStatusEvent.Definitions, ...TuiEvent.Definitions, ...InstallationEvent.Definitions, ...VcsEvent.Definitions, McpEvent.StatusChanged, McpEvent.ResourcesChanged);

package/dist/index.d.ts CHANGED Viewed

@@ -31,6 +31,7 @@ export { Shell } from "./shell.js";
 export { Skill } from "./skill.js";
 export { TokenUsage } from "./token-usage.js";
 export { Pty } from "./pty.js";
+export { PersistentPty } from "./persistent-pty.js";
 export { PtyTicket } from "./pty-ticket.js";
 export { Question } from "./question.js";
 export { Workspace } from "./workspace.js";

package/dist/index.js CHANGED Viewed

@@ -31,6 +31,7 @@ export { Shell } from "./shell.js";
 export { Skill } from "./skill.js";
 export { TokenUsage } from "./token-usage.js";
 export { Pty } from "./pty.js";
+export { PersistentPty } from "./persistent-pty.js";
 export { PtyTicket } from "./pty-ticket.js";
 export { Question } from "./question.js";
 export { Workspace } from "./workspace.js";

package/dist/model.d.ts CHANGED Viewed

@@ -42,6 +42,7 @@ export declare const Compatibility: Schema.Struct<{
     readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<ReasoningField, ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<ReasoningField, ReasoningField, never, never>>, never, never>;
     readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
     readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
 }>;
 export interface Capabilities extends Schema.Schema.Type<typeof Capabilities> {
 }
@@ -156,10 +157,12 @@ export declare const Info: Schema.Struct<{
         readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<ReasoningField, ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<ReasoningField, ReasoningField, never, never>>, never, never>;
         readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
         readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
     }>>>, Schema.optionalKey<Schema.Struct<{
         readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<ReasoningField, ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<ReasoningField, ReasoningField, never, never>>, never, never>;
         readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
         readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
     }>>, never, never>;
     readonly package: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
 }> & {

package/dist/model.js CHANGED Viewed

@@ -41,6 +41,7 @@ export const Compatibility = Schema.Struct({
     reasoningField: ReasoningField.pipe(optional),
     maxTokensField: MaxTokensField.pipe(optional),
     requireFinishReason: Schema.Boolean.pipe(optional),
+    requireAssistantAfterTool: Schema.Boolean.pipe(optional),
 }).annotate({ identifier: "Model.Compatibility" });
 export const Capabilities = Schema.Struct({
     tools: Schema.Boolean,

package/dist/permission.d.ts CHANGED Viewed

@@ -28,6 +28,7 @@ export declare const Request: Schema.Struct<{
         readonly messageID: Schema.String;
         readonly id: Schema.String;
     }>]>>, never, never>;
+    readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
         create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
     };
@@ -81,6 +82,7 @@ export declare const Event: {
                 readonly messageID: Schema.String;
                 readonly id: Schema.String;
             }>]>>, never, never>;
+            readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
             readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
                 create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
             };
@@ -107,6 +109,7 @@ export declare const Event: {
                 readonly messageID: Schema.String;
                 readonly id: Schema.String;
             }>]>>, never, never>;
+            readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
             readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
                 create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
             };
@@ -207,6 +210,7 @@ export declare const Event: {
                 readonly messageID: Schema.String;
                 readonly id: Schema.String;
             }>]>>, never, never>;
+            readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
             readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
                 create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
             };
@@ -233,6 +237,7 @@ export declare const Event: {
                 readonly messageID: Schema.String;
                 readonly id: Schema.String;
             }>]>>, never, never>;
+            readonly message: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
             readonly id: Schema.brand<Schema.String, "Permission.ID"> & {
                 create: (id?: string) => string & import("effect/Brand").Brand<"Permission.ID">;
             };

package/dist/permission.js CHANGED Viewed

@@ -20,6 +20,7 @@ const RequestFields = {
     save: Schema.Array(Schema.String).pipe(optional),
     metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
     source: Source.pipe(optional),
+    message: Schema.String.pipe(optional),
 };
 export const Request = Schema.Struct({
     id: ID,

package/dist/persistent-pty.d.ts ADDED Viewed

@@ -0,0 +1,530 @@
+export * as PersistentPty from "./persistent-pty.js";
+import { Schema } from "effect";
+export declare const Info: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+    readonly size: Schema.Struct<{
+        readonly cols: Schema.Int;
+        readonly rows: Schema.Int;
+    }>;
+    readonly output: Schema.Struct<{
+        readonly head: Schema.Int;
+        readonly tail: Schema.Int;
+    }>;
+    readonly id: Schema.brand<Schema.String, "PtyID"> & {
+        create: () => string & import("effect/Brand").Brand<"PtyID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+    };
+    readonly title: Schema.String;
+    readonly command: Schema.String;
+    readonly args: Schema.$Array<Schema.String>;
+    readonly cwd: Schema.String;
+    readonly status: Schema.Literals<readonly ["running", "exited"]>;
+    readonly pid: Schema.Int;
+    readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+}>;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const CreateInput: Schema.Struct<{
+    readonly command: Schema.String;
+    readonly args: Schema.$Array<Schema.String>;
+    readonly cwd: Schema.String;
+    readonly title: Schema.String;
+    readonly env: Schema.$Record<Schema.String, Schema.String>;
+    readonly size: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly cols: Schema.Int;
+        readonly rows: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly cols: Schema.Int;
+        readonly rows: Schema.Int;
+    }>>, never, never>;
+}>;
+export interface CreateInput extends Schema.Schema.Type<typeof CreateInput> {
+}
+export declare const UpdateInput: Schema.Struct<{
+    readonly attachmentID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly size: Schema.Struct<{
+        readonly cols: Schema.Int;
+        readonly rows: Schema.Int;
+    }>;
+}>;
+export interface UpdateInput extends Schema.Schema.Type<typeof UpdateInput> {
+}
+export declare const Snapshot: Schema.Struct<{
+    readonly info: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+        readonly size: Schema.Struct<{
+            readonly cols: Schema.Int;
+            readonly rows: Schema.Int;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly head: Schema.Int;
+            readonly tail: Schema.Int;
+        }>;
+        readonly id: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+        readonly title: Schema.String;
+        readonly command: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+        readonly cwd: Schema.String;
+        readonly status: Schema.Literals<readonly ["running", "exited"]>;
+        readonly pid: Schema.Int;
+        readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>;
+    readonly text: Schema.String;
+    readonly checkpoint: Schema.Uint8Array;
+    readonly cursor: Schema.Struct<{
+        readonly x: Schema.Int;
+        readonly y: Schema.Int;
+    }>;
+}>;
+export interface Snapshot extends Schema.Schema.Type<typeof Snapshot> {
+}
+export declare const Added: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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<"persistent-pty.added">;
+    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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: 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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+            readonly size: Schema.Struct<{
+                readonly cols: Schema.Int;
+                readonly rows: Schema.Int;
+            }>;
+            readonly output: Schema.Struct<{
+                readonly head: Schema.Int;
+                readonly tail: Schema.Int;
+            }>;
+            readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+            readonly title: Schema.String;
+            readonly command: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+            readonly cwd: Schema.String;
+            readonly status: Schema.Literals<readonly ["running", "exited"]>;
+            readonly pid: Schema.Int;
+            readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        }>;
+    }>;
+}> & {
+    type: "persistent-pty.added";
+    durability: "ephemeral";
+    durable: undefined;
+    data: 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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+            readonly size: Schema.Struct<{
+                readonly cols: Schema.Int;
+                readonly rows: Schema.Int;
+            }>;
+            readonly output: Schema.Struct<{
+                readonly head: Schema.Int;
+                readonly tail: Schema.Int;
+            }>;
+            readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+            readonly title: Schema.String;
+            readonly command: Schema.String;
+            readonly args: Schema.$Array<Schema.String>;
+            readonly cwd: Schema.String;
+            readonly status: Schema.Literals<readonly ["running", "exited"]>;
+            readonly pid: Schema.Int;
+            readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        }>;
+    }>;
+};
+export declare const Removed: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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<"persistent-pty.removed">;
+    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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: 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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+    }>;
+}> & {
+    type: "persistent-pty.removed";
+    durability: "ephemeral";
+    durable: undefined;
+    data: 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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+    }>;
+};
+export declare const Event: {
+    Added: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        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<"persistent-pty.added">;
+        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, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: 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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+                readonly size: Schema.Struct<{
+                    readonly cols: Schema.Int;
+                    readonly rows: Schema.Int;
+                }>;
+                readonly output: Schema.Struct<{
+                    readonly head: Schema.Int;
+                    readonly tail: Schema.Int;
+                }>;
+                readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                    create: () => string & import("effect/Brand").Brand<"PtyID">;
+                    ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+                };
+                readonly title: Schema.String;
+                readonly command: Schema.String;
+                readonly args: Schema.$Array<Schema.String>;
+                readonly cwd: Schema.String;
+                readonly status: Schema.Literals<readonly ["running", "exited"]>;
+                readonly pid: Schema.Int;
+                readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            }>;
+        }>;
+    }> & {
+        type: "persistent-pty.added";
+        durability: "ephemeral";
+        durable: undefined;
+        data: 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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+                readonly size: Schema.Struct<{
+                    readonly cols: Schema.Int;
+                    readonly rows: Schema.Int;
+                }>;
+                readonly output: Schema.Struct<{
+                    readonly head: Schema.Int;
+                    readonly tail: Schema.Int;
+                }>;
+                readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                    create: () => string & import("effect/Brand").Brand<"PtyID">;
+                    ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+                };
+                readonly title: Schema.String;
+                readonly command: Schema.String;
+                readonly args: Schema.$Array<Schema.String>;
+                readonly cwd: Schema.String;
+                readonly status: Schema.Literals<readonly ["running", "exited"]>;
+                readonly pid: Schema.Int;
+                readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            }>;
+        }>;
+    };
+    Removed: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        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<"persistent-pty.removed">;
+        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, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: 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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+        }>;
+    }> & {
+        type: "persistent-pty.removed";
+        durability: "ephemeral";
+        durable: undefined;
+        data: 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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+        }>;
+    };
+    Definitions: readonly [Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        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<"persistent-pty.added">;
+        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, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: 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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+                readonly size: Schema.Struct<{
+                    readonly cols: Schema.Int;
+                    readonly rows: Schema.Int;
+                }>;
+                readonly output: Schema.Struct<{
+                    readonly head: Schema.Int;
+                    readonly tail: Schema.Int;
+                }>;
+                readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                    create: () => string & import("effect/Brand").Brand<"PtyID">;
+                    ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+                };
+                readonly title: Schema.String;
+                readonly command: Schema.String;
+                readonly args: Schema.$Array<Schema.String>;
+                readonly cwd: Schema.String;
+                readonly status: Schema.Literals<readonly ["running", "exited"]>;
+                readonly pid: Schema.Int;
+                readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            }>;
+        }>;
+    }> & {
+        type: "persistent-pty.added";
+        durability: "ephemeral";
+        durable: undefined;
+        data: 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 terminal: 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 foregroundProcess: Schema.NullOr<Schema.String>;
+                readonly size: Schema.Struct<{
+                    readonly cols: Schema.Int;
+                    readonly rows: Schema.Int;
+                }>;
+                readonly output: Schema.Struct<{
+                    readonly head: Schema.Int;
+                    readonly tail: Schema.Int;
+                }>;
+                readonly id: Schema.brand<Schema.String, "PtyID"> & {
+                    create: () => string & import("effect/Brand").Brand<"PtyID">;
+                    ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+                };
+                readonly title: Schema.String;
+                readonly command: Schema.String;
+                readonly args: Schema.$Array<Schema.String>;
+                readonly cwd: Schema.String;
+                readonly status: Schema.Literals<readonly ["running", "exited"]>;
+                readonly pid: Schema.Int;
+                readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            }>;
+        }>;
+    }, Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        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<"persistent-pty.removed">;
+        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, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: 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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+        }>;
+    }> & {
+        type: "persistent-pty.removed";
+        durability: "ephemeral";
+        durable: undefined;
+        data: 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 ptyID: Schema.brand<Schema.String, "PtyID"> & {
+                create: () => string & import("effect/Brand").Brand<"PtyID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+            };
+        }>;
+    }];
+};

package/dist/persistent-pty.js ADDED Viewed

@@ -0,0 +1,34 @@
+export * as PersistentPty from "./persistent-pty.js";
+import { Schema } from "effect";
+import { ephemeral, inventory } from "./event.js";
+import { Pty } from "./pty.js";
+import { NonNegativeInt, PositiveInt, optional } from "./schema.js";
+import { Session } from "./session.js";
+export const Info = Schema.Struct({
+    ...Pty.Info.fields,
+    sessionID: Session.ID,
+    foregroundProcess: Schema.NullOr(Schema.String),
+    size: Schema.Struct({ cols: PositiveInt, rows: PositiveInt }),
+    output: Schema.Struct({ head: NonNegativeInt, tail: NonNegativeInt }),
+}).annotate({ identifier: "PersistentPty.Info" });
+export const CreateInput = Schema.Struct({
+    command: Schema.String,
+    args: Schema.Array(Schema.String),
+    cwd: Schema.String,
+    title: Schema.String,
+    env: Schema.Record(Schema.String, Schema.String),
+    size: optional(Schema.Struct({ cols: PositiveInt, rows: PositiveInt })),
+}).annotate({ identifier: "PersistentPty.CreateInput" });
+export const UpdateInput = Schema.Struct({
+    attachmentID: optional(Schema.String),
+    size: Schema.Struct({ cols: PositiveInt, rows: PositiveInt }),
+}).annotate({ identifier: "PersistentPty.UpdateInput" });
+export const Snapshot = Schema.Struct({
+    info: Info,
+    text: Schema.String,
+    checkpoint: Schema.Uint8Array,
+    cursor: Schema.Struct({ x: NonNegativeInt, y: NonNegativeInt }),
+}).annotate({ identifier: "PersistentPty.Snapshot" });
+export const Added = ephemeral({ type: "persistent-pty.added", schema: { sessionID: Session.ID, terminal: Info } });
+export const Removed = ephemeral({ type: "persistent-pty.removed", schema: { sessionID: Session.ID, ptyID: Pty.ID } });
+export const Event = { Added, Removed, Definitions: inventory(Added, Removed) };

package/dist/project.d.ts CHANGED Viewed

@@ -63,6 +63,28 @@ export declare const Info: Schema.Struct<{
 }>;
 export interface Info extends Schema.Schema.Type<typeof Info> {
 }
+export declare const UpdateInput: Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly icon: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly override: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly override: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>, never, never>;
+    readonly commands: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>, never, never>;
+}>;
+export interface UpdateInput extends Schema.Schema.Type<typeof UpdateInput> {
+}
 export declare const Event: {
     Updated: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {

package/dist/project.js CHANGED Viewed

@@ -33,5 +33,11 @@ export const Info = Schema.Struct({
     time: Time,
     sandboxes: Schema.Array(Schema.String),
 }).annotate({ identifier: "Project" });
+export const UpdateInput = Schema.Struct({
+    projectID: ID,
+    name: optional(Schema.String),
+    icon: optional(Icon),
+    commands: optional(Commands),
+}).annotate({ identifier: "Project.UpdateInput" });
 const Updated = ephemeral({ type: "project.updated", schema: Info.fields });
 export const Event = { Updated, Definitions: inventory(Updated) };

package/dist/tool.d.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 export * as Tool from "./tool.js";
 import { Effect, JsonSchema, Schema } from "effect";
-import type { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { Agent } from "./agent.js";
 import type { Session } from "./session.js";
 import type { SessionMessage } from "./session-message.js";
@@ -25,7 +25,7 @@ export type Options = BaseOptions & ({
     readonly codemode: boolean;
     readonly pinned?: never;
 });
-export type ValueSchema<A = unknown> = Schema.Codec<A, any> | (StandardSchemaV1<any, A> & StandardJSONSchemaV1<any, A>) | JsonSchema.JsonSchema;
+export type ValueSchema<A = unknown> = Schema.Codec<A, any> | StandardSchemaV1<any, A> | JsonSchema.JsonSchema;
 type InputValue<S> = 0 extends 1 & S ? any : S extends Schema.Codec<infer A, any> ? A : S extends StandardSchemaV1<any, infer A> ? A : unknown;
 type OutputValue<S> = S extends undefined ? never : S extends Schema.Codec<infer A, any> ? A : S extends StandardSchemaV1<infer A, any> ? A : any;
 declare const Error_base: Schema.Class<Error, Schema.TaggedStruct<"Tool.Error", {

package/dist/vcs.d.ts CHANGED Viewed

@@ -14,6 +14,8 @@ export declare const Info: Schema.Struct<{
 }>;
 export interface Info extends Schema.Schema.Type<typeof Info> {
 }
+export declare const BranchList: Schema.$Array<Schema.String>;
+export type BranchList = typeof BranchList.Type;
 export declare const Mode: Schema.Literals<readonly ["working", "branch"]>;
 export type Mode = typeof Mode.Type;
 export declare const FileStatus: Schema.Struct<{

package/dist/vcs.js CHANGED Viewed

@@ -8,6 +8,7 @@ export const Branch = Schema.Struct({
 export const Info = Schema.Struct({
     branch: Branch,
 }).annotate({ identifier: "Vcs.Info" });
+export const BranchList = Schema.Array(Schema.String).annotate({ identifier: "Vcs.BranchList" });
 export const Mode = Schema.Literals(["working", "branch"]).annotate({ identifier: "Vcs.Mode" });
 export const FileStatus = Schema.Struct({
     file: Schema.String,

package/dist/worktree.d.ts CHANGED Viewed

@@ -8,6 +8,7 @@ export declare const CreateInput: Schema.Struct<{
     };
     readonly strategy: Schema.brand<Schema.Trim, "Worktree.StrategyID">;
     readonly from: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "AbsolutePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "AbsolutePath">>, never, never>;
+    readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Trim>>, Schema.optionalKey<Schema.Trim>, never, never>;
     readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
     readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
 }>;

package/dist/worktree.js CHANGED Viewed

@@ -9,6 +9,7 @@ export const CreateInput = Schema.Struct({
     projectID: ProjectID,
     strategy: StrategyID,
     from: optional(AbsolutePath),
+    branch: optional(Schema.Trim.pipe(Schema.check(Schema.isNonEmpty()))),
     directory: AbsolutePath,
     name: optional(Schema.String),
 }).annotate({ identifier: "Worktree.CreateInput" });

package/package.json CHANGED Viewed

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