@opencode-ai/core 0.0.0-beta-18593 → 0.0.0-beta-18684

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

@@ -1,8 +1,9 @@
 export * as SessionModelRequest from "./model-request.js";
 import { LLM, LLMRequest, Message, SystemPart } from "@opencode-ai/ai";
 import type { StreamOptions } from "@opencode-ai/ai/route";
+import type { Agent } from "@opencode-ai/schema/agent";
+import type { Model } from "@opencode-ai/schema/model";
 import { Context, Effect, Layer } from "effect";
-import { Model } from "../model.js";
 import { Permission } from "../permission.js";
 import { PluginHooks } from "../plugin/hooks.js";
 import { QuestionTool } from "../tool/plugin/question.js";
@@ -11,12 +12,12 @@ import { SessionModelTransport } from "./model-transport.js";
 import { SessionRunnerModel } from "./runner/model.js";
 import { SessionSchema } from "./schema.js";
 import type { SessionMessage } from "./message.js";
-import type { Agent } from "../agent.js";
 /** Failures a prepared execution can surface: infrastructure errors plus user declines resurfaced from the defect tunnel. */
 export type ExecuteError = Tool.Error | Permission.DeclinedError | QuestionTool.CancelledError;
 export interface Prepared {
     readonly request: LLMRequest;
     readonly options: StreamOptions;
+    readonly retry: (event: PluginHooks.Domains["session"]["retry"]) => Effect.Effect<void>;
     /**
      * One request-scoped execution operation. Unknown and hook-removed calls
      * fail individually through the same seam.

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/runner/model.d.ts

@@ -1,8 +1,8 @@
 export * as SessionRunnerModel from "./model.js";
 import { LanguageModel } from "@opencode-ai/ai";
+import { Model } from "@opencode-ai/schema/model";
 import { Context, Effect, Schema } from "effect";
 import { ModelResolver } from "../../model-resolver.js";
-import { Capabilities, Info, VariantID } from "../../model.js";
 import { SessionSchema } from "../schema.js";
 declare const ModelNotSelectedError_base: Schema.Class<ModelNotSelectedError, Schema.TaggedStruct<"SessionRunnerModel.ModelNotSelectedError", {
     readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
@@ -42,16 +42,16 @@ export type Error = ModelNotSelectedError | ModelUnavailableError | ModelResolve
 export type Resolved = ModelResolver.Resolved;
 export interface Interface {
     /** Availability is sampled lazily for each explicitly selected model resolution. */
-    readonly resolve: (session: SessionSchema.Info, available: () => Effect.Effect<ReadonlyArray<Info>>) => Effect.Effect<Resolved, Error>;
+    readonly resolve: (session: SessionSchema.Info, available: () => Effect.Effect<ReadonlyArray<Model.Info>>) => Effect.Effect<Resolved, Error>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionRunnerModel", Interface>;
 export declare class Service extends Service_base {
 }
 /** Builds a Resolved whose catalog identity mirrors the route model. Test or embedding seam. */
 export declare const resolved: (model: LanguageModel, options: {
-    readonly capabilities: Capabilities;
-    readonly variant?: VariantID;
-    readonly cost: Info["cost"];
-    readonly limit: Info["limit"];
+    readonly capabilities: Model.Capabilities;
+    readonly variant?: Model.VariantID;
+    readonly cost: Model.Info["cost"];
+    readonly limit: Model.Info["limit"];
 }) => Resolved;
 export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

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

@@ -1,14 +1,14 @@
 import { type LLMEvent } from "@opencode-ai/ai";
+import type { Agent } from "@opencode-ai/schema/agent";
+import type { Model } from "@opencode-ai/schema/model";
+import type { RelativePath } from "@opencode-ai/schema/schema";
+import type { Snapshot } from "@opencode-ai/schema/snapshot";
 import { Effect } from "effect";
 import { Bus } from "../../bus.js";
-import { Model } from "../../model.js";
 import { SessionMessage } from "../message.js";
 import { SessionSchema } from "../schema.js";
 import { SessionError } from "@opencode-ai/schema/session-error";
 import { Money } from "@opencode-ai/schema/money";
-import { Agent } from "../../agent.js";
-import { Snapshot } from "../../snapshot.js";
-import { RelativePath } from "../../schema.js";
 import { SessionUsage } from "../usage.js";
 import { Tool } from "@opencode-ai/schema/tool";
 type Input = {
@@ -44,7 +44,9 @@ export interface StepRecord {
  * concurrently without a lock. Two rules keep that safe, and every method must preserve
  * them. (1) Commit state marks synchronously before the first await: never a yield
  * between a check (`tool.settled`, `stepStarted`, ...) and its mark, so check-and-mark
- * stays atomic under cooperative scheduling. (2) Never require a cross-source event
+ * stays atomic under cooperative scheduling. Provider-event publication remains
+ * uninterruptible through its writes so cancellation cannot strand a mark without
+ * its durable event. (2) Never require a cross-source event
  * order: each publishing fiber is sequential, so per-source order holds by construction,
  * and consumers fold by id/ordinal rather than global position.
  */

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

@@ -1,14 +1,38 @@
 export * as SessionRunnerRetry from "./retry.js";
 import { AIError } from "@opencode-ai/ai";
+import { Agent } from "@opencode-ai/schema/agent";
+import { Model } from "@opencode-ai/schema/model";
 import { SessionError } from "@opencode-ai/schema/session-error";
-import { Duration, Schedule } from "effect";
+import { Effect } from "effect";
 import { Bus } from "../../bus.js";
+import type { PluginHooks } from "../../plugin/hooks.js";
 import { SessionMessage } from "../message.js";
 import { SessionSchema } from "../schema.js";
-export interface Input {
+interface Input {
     readonly cause: AIError;
     readonly error: SessionError.Error;
-    readonly assistantMessageID: SessionMessage.ID;
+    readonly agent: Agent.ID;
+    readonly model: Model.Ref;
+    readonly hook: (event: PluginHooks.Domains["session"]["retry"]) => Effect.Effect<void>;
+    readonly retry: boolean;
+}
+export interface Decision {
+    readonly retry: true;
+    readonly attempt: number;
+    readonly delay: number;
 }
 export declare function isRetryable(error: AIError): boolean;
-export declare const schedule: (bus: Bus.Interface, sessionID: SessionSchema.ID) => Schedule.Schedule<Duration.Duration, Input, never, never>;
+export declare const make: (bus: Bus.Interface, sessionID: SessionSchema.ID) => Effect.Effect<{
+    decide: (input: Input) => Effect.Effect<{
+        retry: false;
+    } | {
+        retry: true;
+        attempt: number;
+        delay: number;
+    }, never, never>;
+    wait: (input: {
+        readonly decision: Decision;
+        readonly assistantMessageID: SessionMessage.ID;
+        readonly error: SessionError.Error;
+    }) => Effect.Effect<void, never, never>;
+}, never, never>;

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

@@ -1,8 +1,8 @@
 export * as SessionStep from "./step.js";
 import { AIError } from "@opencode-ai/ai";
+import type { Agent } from "@opencode-ai/schema/agent";
 import { Data, Effect } from "effect";
 import { SessionError } from "@opencode-ai/schema/session-error";
-import { Agent } from "../../agent.js";
 import { Bus } from "../../bus.js";
 import { Snapshot } from "../../snapshot.js";
 import { ToolOutput } from "../../tool-output.js";
@@ -11,17 +11,18 @@ import { SessionMessage } from "../message.js";
 import { SessionModelRequest } from "../model-request.js";
 import { SessionSchema } from "../schema.js";
 import { SessionRunnerModel } from "./model.js";
+import { SessionRunnerRetry } from "./retry.js";
 export type Outcome = Data.TaggedEnum<{
     Completed: {
         readonly needsContinuation: boolean;
     };
     Retry: {
-        readonly cause: AIError;
         readonly error: SessionError.Error;
+        readonly decision: SessionRunnerRetry.Decision;
     };
     Continue: {
-        readonly cause: AIError;
         readonly error: SessionError.Error;
+        readonly decision: SessionRunnerRetry.Decision;
     };
     RecoverFull: {};
     Compacted: {};
@@ -29,8 +30,8 @@ export type Outcome = Data.TaggedEnum<{
 export declare const Outcome: {
     readonly Retry: Data.TaggedEnum.ConstructorFrom<{
         readonly _tag: "Retry";
-        readonly cause: AIError;
         readonly error: SessionError.Error;
+        readonly decision: SessionRunnerRetry.Decision;
     }, "_tag">;
     readonly Completed: Data.TaggedEnum.ConstructorFrom<{
         readonly _tag: "Completed";
@@ -38,8 +39,8 @@ export declare const Outcome: {
     }, "_tag">;
     readonly Continue: Data.TaggedEnum.ConstructorFrom<{
         readonly _tag: "Continue";
-        readonly cause: AIError;
         readonly error: SessionError.Error;
+        readonly decision: SessionRunnerRetry.Decision;
     }, "_tag">;
     readonly RecoverFull: Data.TaggedEnum.ConstructorFrom<{
         readonly _tag: "RecoverFull";
@@ -49,8 +50,8 @@ export declare const Outcome: {
     }, "_tag">;
     readonly $is: <Tag extends "Retry" | "Completed" | "Continue" | "RecoverFull" | "Compacted">(tag: Tag) => (u: unknown) => u is Extract<{
         readonly _tag: "Retry";
-        readonly cause: AIError;
         readonly error: SessionError.Error;
+        readonly decision: SessionRunnerRetry.Decision;
     }, {
         readonly _tag: Tag;
     }> | Extract<{
@@ -60,8 +61,8 @@ export declare const Outcome: {
         readonly _tag: Tag;
     }> | Extract<{
         readonly _tag: "Continue";
-        readonly cause: AIError;
         readonly error: SessionError.Error;
+        readonly decision: SessionRunnerRetry.Decision;
     }, {
         readonly _tag: Tag;
     }> | Extract<{
@@ -77,8 +78,8 @@ export declare const Outcome: {
         <Cases extends {
             readonly Retry: (args: {
                 readonly _tag: "Retry";
-                readonly cause: AIError;
                 readonly error: SessionError.Error;
+                readonly decision: SessionRunnerRetry.Decision;
             }) => any;
             readonly Completed: (args: {
                 readonly _tag: "Completed";
@@ -86,8 +87,8 @@ export declare const Outcome: {
             }) => any;
             readonly Continue: (args: {
                 readonly _tag: "Continue";
-                readonly cause: AIError;
                 readonly error: SessionError.Error;
+                readonly decision: SessionRunnerRetry.Decision;
             }) => any;
             readonly RecoverFull: (args: {
                 readonly _tag: "RecoverFull";
@@ -97,15 +98,15 @@ export declare const Outcome: {
             }) => any;
         }>(cases: Cases): (value: {
             readonly _tag: "Retry";
-            readonly cause: AIError;
             readonly error: SessionError.Error;
+            readonly decision: SessionRunnerRetry.Decision;
         } | {
             readonly _tag: "Completed";
             readonly needsContinuation: boolean;
         } | {
             readonly _tag: "Continue";
-            readonly cause: AIError;
             readonly error: SessionError.Error;
+            readonly decision: SessionRunnerRetry.Decision;
         } | {
             readonly _tag: "RecoverFull";
         } | {
@@ -114,8 +115,8 @@ export declare const Outcome: {
         <Cases extends {
             readonly Retry: (args: {
                 readonly _tag: "Retry";
-                readonly cause: AIError;
                 readonly error: SessionError.Error;
+                readonly decision: SessionRunnerRetry.Decision;
             }) => any;
             readonly Completed: (args: {
                 readonly _tag: "Completed";
@@ -123,8 +124,8 @@ export declare const Outcome: {
             }) => any;
             readonly Continue: (args: {
                 readonly _tag: "Continue";
-                readonly cause: AIError;
                 readonly error: SessionError.Error;
+                readonly decision: SessionRunnerRetry.Decision;
             }) => any;
             readonly RecoverFull: (args: {
                 readonly _tag: "RecoverFull";
@@ -134,15 +135,15 @@ export declare const Outcome: {
             }) => any;
         }>(value: {
             readonly _tag: "Retry";
-            readonly cause: AIError;
             readonly error: SessionError.Error;
+            readonly decision: SessionRunnerRetry.Decision;
         } | {
             readonly _tag: "Completed";
             readonly needsContinuation: boolean;
         } | {
             readonly _tag: "Continue";
-            readonly cause: AIError;
             readonly error: SessionError.Error;
+            readonly decision: SessionRunnerRetry.Decision;
         } | {
             readonly _tag: "RecoverFull";
         } | {
@@ -156,6 +157,9 @@ interface Input {
     readonly agent: Agent.ID;
     readonly model: SessionRunnerModel.Resolved;
     readonly prepared: SessionModelRequest.Prepared;
+    readonly retry: (cause: AIError, error: SessionError.Error, retry: boolean) => Effect.Effect<{
+        readonly retry: false;
+    } | SessionRunnerRetry.Decision>;
     readonly recoverContinuation: boolean;
     /** The runner owns compaction policy; the attempt invokes it only before durable output. */
     readonly recoverOverflow: Effect.Effect<boolean>;
@@ -164,15 +168,15 @@ interface Input {
 export declare const make: Effect.Effect<{
     attempt: (input: Input) => Effect.Effect<{
         readonly _tag: "Retry";
-        readonly cause: AIError;
         readonly error: SessionError.Error;
+        readonly decision: SessionRunnerRetry.Decision;
     } | {
         readonly _tag: "Completed";
         readonly needsContinuation: boolean;
     } | {
         readonly _tag: "Continue";
-        readonly cause: AIError;
         readonly error: SessionError.Error;
+        readonly decision: SessionRunnerRetry.Decision;
     } | {
         readonly _tag: "RecoverFull";
     } | {

package/dist/types/session/runner/to-llm-message.d.ts

@@ -1,5 +1,5 @@
 import { Message } from "@opencode-ai/ai";
-import type { Model } from "../../model.js";
+import type { Model } from "@opencode-ai/schema/model";
 import { SessionMessage } from "../message.js";
 /** Translate projected Session history into canonical @opencode-ai/ai context. */
 export declare const toLLMMessages: (messages: readonly SessionMessage.Info[], model: Model.Ref, providerMetadataKey?: string) => Message[];