@opencode-ai/core 0.0.0-dev-18673 → 0.0.0-dev-18680

package/dist/types/session/prompt-node.d.ts

@@ -0,0 +1,3 @@
+export * as SessionPromptNode from "./prompt-node.js";
+import { SessionPrompt } from "./prompt.js";
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<SessionPrompt.Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/session/prompt.d.ts

@@ -0,0 +1,126 @@
+export * as SessionPrompt from "./prompt.js";
+import { PromptInput } from "@opencode-ai/schema/prompt-input";
+import { SessionInbox } from "@opencode-ai/schema/session-inbox";
+import type { Session } from "@opencode-ai/schema/session";
+import type { SessionMessage } from "@opencode-ai/schema/session-message";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Context, Effect, Layer } from "effect";
+import { Image } from "../image.js";
+import { PluginHooks } from "../plugin/hooks.js";
+import { PluginSupervisor } from "../plugin/supervisor-service.js";
+import { Skill } from "../skill.js";
+import { AttachmentError, SkillNotFoundError } from "./error.js";
+export type Input = {
+    text: string;
+    files?: PromptInput.Prompt["files"];
+    agents?: PromptInput.Prompt["agents"];
+    skills?: PromptInput.Prompt["skills"];
+    metadata?: Record<string, unknown>;
+    delivery?: SessionInbox.Delivery;
+};
+export declare const make: () => Effect.Effect<{
+    prepare: (request: {
+        sessionID: Session.ID;
+        messageID: SessionMessage.ID;
+        input: Input;
+    }) => Effect.Effect<{
+        type: "user";
+        payload: {
+            readonly text: string;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly files?: readonly {
+                readonly source: {
+                    readonly type: "inline";
+                } | {
+                    readonly type: "uri";
+                    readonly uri: string;
+                };
+                readonly data: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+                readonly description?: string | undefined;
+                readonly mention?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            }[] | undefined;
+            readonly agents?: readonly {
+                readonly name: string;
+                readonly mention?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            }[] | undefined;
+            readonly skills?: readonly {
+                readonly name: string & import("effect/Brand").Brand<"Skill.Name">;
+                readonly id: string & import("effect/Brand").Brand<"Skill.ID">;
+                readonly text?: string | undefined;
+                readonly mention?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            }[] | undefined;
+        };
+        delivery: "steer" | "queue";
+    }, AttachmentError | SkillNotFoundError, never>;
+}, never, FSUtil.Service | Image.Service | PluginSupervisor.Service | PluginHooks.Service | Skill.Service>;
+export type Interface = Effect.Success<ReturnType<typeof make>>;
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionPrompt", {
+    prepare: (request: {
+        sessionID: Session.ID;
+        messageID: SessionMessage.ID;
+        input: Input;
+    }) => Effect.Effect<{
+        type: "user";
+        payload: {
+            readonly text: string;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly files?: readonly {
+                readonly source: {
+                    readonly type: "inline";
+                } | {
+                    readonly type: "uri";
+                    readonly uri: string;
+                };
+                readonly data: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+                readonly description?: string | undefined;
+                readonly mention?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            }[] | undefined;
+            readonly agents?: readonly {
+                readonly name: string;
+                readonly mention?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            }[] | undefined;
+            readonly skills?: readonly {
+                readonly name: string & import("effect/Brand").Brand<"Skill.Name">;
+                readonly id: string & import("effect/Brand").Brand<"Skill.ID">;
+                readonly text?: string | undefined;
+                readonly mention?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            }[] | undefined;
+        };
+        delivery: "steer" | "queue";
+    }, AttachmentError | SkillNotFoundError, never>;
+}>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, FSUtil.Service | Image.Service | PluginSupervisor.Service | PluginHooks.Service | Skill.Service>;

package/dist/types/session/revert-node.d.ts

@@ -0,0 +1,3 @@
+export * as SessionRevertNode from "./revert-node.js";
+import { SessionRevert } from "./revert.js";
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<SessionRevert.Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

package/dist/types/session/revert.d.ts

@@ -1,36 +1,31 @@
 export * as SessionRevert from "./revert.js";
-import { Effect, Schema } from "effect";
+import { Context, Effect, Layer } from "effect";
 import { Database } from "../database/database.js";
 import { Bus } from "../bus.js";
+import { PluginSupervisor } from "../plugin/supervisor-service.js";
 import { Snapshot } from "../snapshot.js";
+import { MessageNotFoundError } from "./error.js";
 import { SessionMessage } from "./message.js";
 import { SessionSchema } from "./schema.js";
-declare const MessageNotFoundError_base: Schema.Class<MessageNotFoundError, Schema.TaggedStruct<"Session.MessageNotFoundError", {
-    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-        create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-    };
-    readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
-        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
-        fromEvent: (eventID: import("@opencode-ai/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
-    };
-}>, import("effect/Cause").YieldableError>;
-export declare class MessageNotFoundError extends MessageNotFoundError_base {
+export { MessageNotFoundError };
+export interface Interface {
+    readonly stage: (input: {
+        readonly session: SessionSchema.Info;
+        readonly messageID: SessionMessage.ID;
+        readonly files?: boolean;
+    }) => Effect.Effect<SessionSchema.Revert, MessageNotFoundError | Snapshot.Error>;
+    readonly clear: (session: SessionSchema.Info) => Effect.Effect<void, Snapshot.Error>;
 }
-export declare const stage: (input: {
-    readonly session: SessionSchema.Info;
-    readonly messageID: SessionMessage.ID;
-    readonly files?: boolean;
-}) => Effect.Effect<{
-    messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
-    snapshot: (string & import("effect/Brand").Brand<"Snapshot.ID">) | undefined;
-    files: readonly {
-        readonly file: string;
-        readonly patch: string;
-        readonly additions: number;
-        readonly deletions: number;
-        readonly status: "added" | "deleted" | "modified";
-    }[];
-}, Snapshot.Error | MessageNotFoundError, Database.Service | Bus.Service | Snapshot.Service>;
-export declare const clear: (session: SessionSchema.Info) => Effect.Effect<void, Snapshot.Error, Bus.Service | Snapshot.Service>;
-export declare const commit: (session: SessionSchema.Info) => Effect.Effect<void, never, Bus.Service>;
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionRevert", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const make: () => Effect.Effect<{
+    stage: (input: {
+        readonly session: SessionSchema.Info;
+        readonly messageID: SessionMessage.ID;
+        readonly files?: boolean;
+    }) => Effect.Effect<SessionSchema.Revert, MessageNotFoundError | Snapshot.Error>;
+    clear: (session: SessionSchema.Info) => Effect.Effect<void, Snapshot.Error>;
+}, never, Database.Service | Bus.Service | PluginSupervisor.Service | Snapshot.Service>;
+export declare const layer: Layer.Layer<Service, never, Database.Service | Bus.Service | PluginSupervisor.Service | Snapshot.Service>;
+export declare const commit: (bus: Bus.Interface, session: SessionSchema.Info) => Effect.Effect<void, never, never>;

package/dist/types/session/run-coordinator.d.ts

@@ -5,6 +5,8 @@ import type { Promotable } from "./inbox.js";
 export interface Coordinator<Key, E, Reason = never> {
     /** Snapshots keys with an execution owned by this coordinator. */
     readonly active: Effect.Effect<ReadonlySet<Key>>;
+    /** Checks ownership for one key, including cleanup and terminal settlement. */
+    readonly isActive: (key: Key) => Effect.Effect<boolean>;
     /** Starts an execution while idle, or joins the active execution and returns its exit. */
     readonly run: (key: Key) => Effect.Effect<void, E>;
     /** Rings the doorbell: an idle key starts an execution; an active one drains again before settling. */

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

@@ -0,0 +1,232 @@
+export * as Session from "./session.js";
+import { DateTime, Effect, Layer, Scope } from "effect";
+import type { Agent } from "@opencode-ai/schema/agent";
+import type { Model } from "@opencode-ai/schema/model";
+import { Event } from "@opencode-ai/schema/event";
+import { Bus } from "../bus.js";
+import { Location } from "../location.js";
+import { PluginSupervisor } from "../plugin/supervisor-service.js";
+import { Shell } from "../shell.js";
+import { BusyError, CompactionConflictError, InboxConflictError, MessageIncompleteError, MessageNotAssistantError, MessageNotFoundError, MessageToolIncompleteError, NotFoundError, PromptConflictError, SyntheticConflictError } from "./error.js";
+import { SessionExecution } from "./execution.js";
+import { SessionInbox } from "./inbox.js";
+import { SessionMessage } from "./message.js";
+import { SessionPrompt } from "./prompt.js";
+import { SessionRevert } from "./revert.js";
+import { SessionSchema } from "./schema.js";
+import { SessionStore } from "./store.js";
+export type Services = PluginSupervisor.Service | SessionPrompt.Service | SessionRevert.Service | Shell.Service;
+type PromptRequest = SessionPrompt.Input & {
+    id?: SessionMessage.ID;
+    resume?: boolean;
+};
+/**
+ * Build once in the host Scope: `const sessions = yield* Session.make(servicesFor)`.
+ * Use `sessions.forSession(id)` for handles that share host services and reload current state.
+ */
+export declare const make: (servicesFor: (ref: Location.Ref) => Layer.Layer<Services>) => Effect.Effect<{
+    forSession: (sessionID: SessionSchema.ID) => {
+        id: string & import("effect/Brand").Brand<"SessionID">;
+        get: () => Effect.Effect<SessionSchema.Info, NotFoundError, never>;
+        message: (messageID: string & import("effect/Brand").Brand<"Session.Message.ID">) => Effect.Effect<SessionMessage.Info | undefined, never, never>;
+        updateMessage: (input: {
+            readonly messageID: SessionMessage.ID;
+            readonly content: readonly SessionMessage.AssistantContent[];
+        }) => Effect.Effect<SessionMessage.Assistant, NotFoundError | MessageNotFoundError | MessageNotAssistantError | MessageIncompleteError | MessageToolIncompleteError | BusyError, never>;
+        view: (input: {
+            idle: number;
+        }) => Effect.Effect<void, NotFoundError, never>;
+        rename: (input: {
+            title: string;
+        }) => Effect.Effect<void, NotFoundError, never>;
+        switchAgent: (input: {
+            agent: Agent.ID;
+        }) => Effect.Effect<void, NotFoundError, never>;
+        switchModel: (input: {
+            model: Model.Ref;
+        }) => Effect.Effect<void, NotFoundError, never>;
+        inbox: () => Effect.Effect<({
+            readonly type: "user";
+            readonly payload: {
+                readonly text: string;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+                readonly files?: readonly {
+                    readonly source: {
+                        readonly type: "inline";
+                    } | {
+                        readonly type: "uri";
+                        readonly uri: string;
+                    };
+                    readonly data: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                    readonly description?: string | undefined;
+                    readonly mention?: {
+                        readonly start: number;
+                        readonly end: number;
+                        readonly text: string;
+                    } | undefined;
+                }[] | undefined;
+                readonly agents?: readonly {
+                    readonly name: string;
+                    readonly mention?: {
+                        readonly start: number;
+                        readonly end: number;
+                        readonly text: string;
+                    } | undefined;
+                }[] | undefined;
+                readonly skills?: readonly {
+                    readonly name: string & import("effect/Brand").Brand<"Skill.Name">;
+                    readonly id: string & import("effect/Brand").Brand<"Skill.ID">;
+                    readonly text?: string | undefined;
+                    readonly mention?: {
+                        readonly start: number;
+                        readonly end: number;
+                        readonly text: string;
+                    } | undefined;
+                }[] | undefined;
+            };
+            readonly delivery: "steer" | "queue";
+            readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+            readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+            readonly timeCreated: DateTime.Utc;
+        } | {
+            readonly type: "synthetic";
+            readonly payload: {
+                readonly text: string;
+                readonly description?: string | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            };
+            readonly delivery: "steer" | "queue";
+            readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+            readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+            readonly timeCreated: DateTime.Utc;
+        } | {
+            readonly type: "compaction";
+            readonly payload: {};
+            readonly delivery: "steer" | "queue";
+            readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+            readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+            readonly timeCreated: DateTime.Utc;
+        } | {
+            readonly type: "move";
+            readonly payload: {
+                readonly location: {
+                    readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+                    readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+                };
+                readonly projectID: string & import("effect/Brand").Brand<"Project.ID">;
+                readonly subpath?: (string & import("effect/Brand").Brand<"RelativePath">) | undefined;
+            };
+            readonly delivery: "steer" | "queue";
+            readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+            readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+            readonly timeCreated: DateTime.Utc;
+        })[], NotFoundError, never>;
+        prompt: (input: PromptRequest) => Effect.Effect<{
+            readonly type: "user";
+            readonly payload: {
+                readonly text: string;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+                readonly files?: readonly {
+                    readonly source: {
+                        readonly type: "inline";
+                    } | {
+                        readonly type: "uri";
+                        readonly uri: string;
+                    };
+                    readonly data: string;
+                    readonly mime: string;
+                    readonly name?: string | undefined;
+                    readonly description?: string | undefined;
+                    readonly mention?: {
+                        readonly start: number;
+                        readonly end: number;
+                        readonly text: string;
+                    } | undefined;
+                }[] | undefined;
+                readonly agents?: readonly {
+                    readonly name: string;
+                    readonly mention?: {
+                        readonly start: number;
+                        readonly end: number;
+                        readonly text: string;
+                    } | undefined;
+                }[] | undefined;
+                readonly skills?: readonly {
+                    readonly name: string & import("effect/Brand").Brand<"Skill.Name">;
+                    readonly id: string & import("effect/Brand").Brand<"Skill.ID">;
+                    readonly text?: string | undefined;
+                    readonly mention?: {
+                        readonly start: number;
+                        readonly end: number;
+                        readonly text: string;
+                    } | undefined;
+                }[] | undefined;
+            };
+            readonly delivery: "steer" | "queue";
+            readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+            readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+            readonly timeCreated: DateTime.Utc;
+        }, NotFoundError | PromptConflictError | import("./error.js").AttachmentError | import("./error.js").SkillNotFoundError, never>;
+        synthetic: (input: {
+            id?: SessionMessage.ID;
+            text: string;
+            description?: string;
+            metadata?: Record<string, unknown>;
+            delivery?: SessionInbox.Delivery;
+            resume?: boolean;
+        }) => Effect.Effect<{
+            readonly type: "synthetic";
+            readonly payload: {
+                readonly text: string;
+                readonly description?: string | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            };
+            readonly delivery: "steer" | "queue";
+            readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+            readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+            readonly timeCreated: DateTime.Utc;
+        }, NotFoundError | SyntheticConflictError, never>;
+        shell: (input: {
+            id?: Event.ID;
+            command: string;
+        }) => Effect.Effect<void, NotFoundError, never>;
+        compact: (input: {
+            id?: SessionMessage.ID;
+            delivery?: SessionInbox.Delivery;
+        }) => Effect.Effect<{
+            readonly type: "compaction";
+            readonly payload: {};
+            readonly delivery: "steer" | "queue";
+            readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
+            readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
+            readonly timeCreated: DateTime.Utc;
+        }, NotFoundError | CompactionConflictError, never>;
+        wait: () => Effect.Effect<void, NotFoundError, never>;
+        resume: () => Effect.Effect<void, NotFoundError | import("./runner/index.js").RunError, never>;
+        interrupt: (options?: {
+            readonly continue?: boolean;
+        } | undefined) => Effect.Effect<boolean, never, never>;
+        cancelInbox: (inboxID: string & import("effect/Brand").Brand<"Session.Message.ID">) => Effect.Effect<void, NotFoundError | InboxConflictError, never>;
+        steerInbox: (inboxID: string & import("effect/Brand").Brand<"Session.Message.ID">) => Effect.Effect<void, NotFoundError | InboxConflictError, never>;
+        queueInbox: (inboxID: string & import("effect/Brand").Brand<"Session.Message.ID">) => Effect.Effect<void, NotFoundError | InboxConflictError, never>;
+        revert: {
+            stage: (input: {
+                messageID: SessionMessage.ID;
+                files?: boolean;
+            }) => Effect.Effect<SessionSchema.Revert, NotFoundError | MessageNotFoundError | BusyError | import("../snapshot.js").Error, never>;
+            clear: () => Effect.Effect<void, NotFoundError | BusyError | import("../snapshot.js").Error, never>;
+            commit: () => Effect.Effect<void, NotFoundError | BusyError, never>;
+        };
+    };
+}, never, Scope.Scope | Bus.Service | SessionInbox.Service | SessionStore.Service | SessionExecution.Service>;
+export type Handle = ReturnType<Effect.Success<ReturnType<typeof make>>["forSession"]>;