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

package/dist/types/schema.d.ts

@@ -25,7 +25,7 @@ export type DeepMutable<T> = T extends string | number | boolean | bigint | symb
 } : T;
 /**
  * Nominal wrapper for scalar types. The class itself is a valid schema —
- * pass it directly to `Schema.decode`, `Schema.decodeEffect`, etc.
+ * pass it directly to `Schema.decodeUnknownSync`, `Schema.decodeEffect`, etc.
  *
  * The runtime value remains an unwrapped primitive. `Schema.brand` supplies
  * the primitive schema behavior and constructor validation, while the class

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

@@ -108,6 +108,88 @@ export declare const find: (db: import("../database/drizzle.js").EffectSQLiteDat
     readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
     readonly timeCreated: DateTime.Utc;
 } | undefined, never, never>;
+/** Reconciles pending or delivered work without preparing a new admission payload. */
+export declare const reconcile: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+}, request: {
+    readonly id: SessionMessage.ID;
+    readonly sessionID: SessionSchema.ID;
+    readonly delivery: Delivery;
+}) => 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: "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;
+} | undefined, never, never>;
 export declare const admit: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
     $client: import("effect/unstable/sql/SqlClient").SqlClient;
 }, bus: Bus.Interface, request: {

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

@@ -1,3 +1,3 @@
 import { SessionSchema } from "./schema.js";
-import { SessionTable } from "./sql.js";
+import type { SessionTable } from "./sql.js";
 export declare function fromRow(row: typeof SessionTable.$inferSelect): SessionSchema.Info;

package/dist/types/session/message-updater.d.ts

@@ -2,17 +2,17 @@ import { Effect } from "effect";
 import { SessionEvent } from "./event.js";
 import { SessionMessage } from "./message.js";
 export interface Adapter {
-    readonly getAgent: () => Effect.Effect<SessionMessage.AgentSelected["agent"] | undefined, never, never>;
-    readonly getModel: () => Effect.Effect<SessionMessage.ModelSelected["model"] | undefined, never, never>;
-    readonly getLocation: () => Effect.Effect<SessionMessage.LocationSwitched["previous"], never, never>;
-    readonly getCurrentAssistant: () => Effect.Effect<SessionMessage.Assistant | undefined, never, never>;
-    readonly getAssistant: (messageID: SessionMessage.ID) => Effect.Effect<SessionMessage.Assistant | undefined, never, never>;
-    readonly getShell: (shellID: SessionMessage.Shell["shellID"]) => Effect.Effect<SessionMessage.Shell | undefined, never, never>;
-    readonly getCompaction: () => Effect.Effect<SessionMessage.Compaction | undefined, never, never>;
-    readonly updateAssistant: (assistant: SessionMessage.Assistant) => Effect.Effect<void, never, never>;
-    readonly updateShell: (shell: SessionMessage.Shell) => Effect.Effect<void, never, never>;
-    readonly updateCompaction: (compaction: SessionMessage.Compaction) => Effect.Effect<void, never, never>;
-    readonly appendMessage: (message: SessionMessage.Info) => Effect.Effect<void, never, never>;
+    readonly getAgent: () => Effect.Effect<SessionMessage.AgentSelected["agent"] | undefined>;
+    readonly getModel: () => Effect.Effect<SessionMessage.ModelSelected["model"] | undefined>;
+    readonly getLocation: () => Effect.Effect<SessionMessage.LocationSwitched["previous"]>;
+    readonly getCurrentAssistant: () => Effect.Effect<SessionMessage.Assistant | undefined>;
+    readonly getAssistant: (messageID: SessionMessage.ID) => Effect.Effect<SessionMessage.Assistant | undefined>;
+    readonly getShell: (shellID: SessionMessage.Shell["shellID"]) => Effect.Effect<SessionMessage.Shell | undefined>;
+    readonly getCompaction: () => Effect.Effect<SessionMessage.Compaction | undefined>;
+    readonly updateAssistant: (assistant: SessionMessage.Assistant) => Effect.Effect<void>;
+    readonly updateShell: (shell: SessionMessage.Shell) => Effect.Effect<void>;
+    readonly updateCompaction: (compaction: SessionMessage.Compaction) => Effect.Effect<void>;
+    readonly appendMessage: (message: SessionMessage.Info) => Effect.Effect<void>;
 }
 export declare function update(adapter: Adapter, event: SessionEvent.DurableEvent): Effect.Effect<void, never, never>;
 export * as SessionMessageUpdater from "./message-updater.js";

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

@@ -49,189 +49,7 @@ export interface StepRecord {
  * and consumers fold by id/ordinal rather than global position.
  */
 export declare const createLLMEventPublisher: (bus: Pick<Bus.Interface, "publish">, input: Input) => {
-    publish: (event: {
-        readonly type: "step-start";
-        readonly index: number;
-    } | {
-        readonly id: string;
-        readonly type: "text-start";
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
-    } | {
-        readonly id: string;
-        readonly type: "text-delta";
-        readonly text: string;
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
-    } | {
-        readonly id: string;
-        readonly type: "text-end";
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
-    } | {
-        readonly id: string;
-        readonly type: "reasoning-start";
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
-    } | {
-        readonly id: string;
-        readonly type: "reasoning-delta";
-        readonly text: string;
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
-    } | {
-        readonly id: string;
-        readonly type: "reasoning-end";
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
-    } | {
-        readonly name: string;
-        readonly id: string;
-        readonly type: "tool-input-start";
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
-        readonly providerExecuted?: boolean | undefined;
-    } | {
-        readonly name: string;
-        readonly id: string;
-        readonly type: "tool-input-delta";
-        readonly text: string;
-        readonly input?: unknown;
-    } | {
-        readonly name: string;
-        readonly id: string;
-        readonly type: "tool-input-end";
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
-    } | {
-        readonly type: "tool-input-error";
-        readonly id: string;
-        readonly name: string;
-        readonly raw: string;
-    } | {
-        readonly name: string;
-        readonly id: string;
-        readonly type: "tool-call";
-        readonly input: unknown;
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
-        readonly providerExecuted?: boolean | undefined;
-    } | {
-        readonly name: string;
-        readonly id: string;
-        readonly type: "tool-result";
-        readonly result: {
-            readonly type: "json";
-            readonly value: unknown;
-        } | {
-            readonly type: "text";
-            readonly value: unknown;
-        } | {
-            readonly type: "error";
-            readonly value: unknown;
-        } | {
-            readonly type: "content";
-            readonly value: readonly ({
-                readonly type: "text";
-                readonly text: string;
-            } | {
-                readonly type: "file";
-                readonly uri: string;
-                readonly mime: string;
-                readonly name?: string | undefined;
-            })[];
-        };
-        readonly output?: {
-            readonly structured: unknown;
-            readonly content: readonly ({
-                readonly type: "text";
-                readonly text: string;
-            } | {
-                readonly type: "file";
-                readonly uri: string;
-                readonly mime: string;
-                readonly name?: string | undefined;
-            })[];
-        } | undefined;
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
-        readonly providerExecuted?: boolean | undefined;
-    } | {
-        readonly name: string;
-        readonly id: string;
-        readonly type: "tool-error";
-        readonly message: string;
-        readonly error?: unknown;
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
-    } | {
-        readonly type: "step-finish";
-        readonly reason: {
-            readonly normalized: "length" | "error" | "stop" | "tool-calls" | "content-filter" | "unknown";
-            readonly raw?: string | undefined;
-        };
-        readonly index: number;
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
-        readonly usage?: import("@opencode-ai/ai").Usage | undefined;
-    } | {
-        readonly type: "finish";
-        readonly reason: {
-            readonly normalized: "length" | "error" | "stop" | "tool-calls" | "content-filter" | "unknown";
-            readonly raw?: string | undefined;
-        };
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
-        readonly usage?: import("@opencode-ai/ai").Usage | undefined;
-    } | {
-        readonly type: "provider-error";
-        readonly message: string;
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
-        readonly classification?: "context-overflow" | "payload-too-large" | undefined;
-    }) => Effect.Effect<undefined, never, never>;
+    publish: (event: LLMEvent) => Effect.Effect<undefined, never, never>;
     progress: (id: string, update: Readonly<Record<string, any>>) => Effect.Effect<undefined, never, never>;
     toolExecution: (id: string, name: string, result: Tool.Result<Tool.ValueSchema<any> | undefined>) => Effect.Effect<undefined, never, never>;
     flush: () => Effect.Effect<void, never, never>;

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

@@ -26,13 +26,136 @@ export type Outcome = Data.TaggedEnum<{
     RecoverFull: {};
     Compacted: {};
 }>;
+export declare const Outcome: {
+    readonly Retry: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Retry";
+        readonly cause: AIError;
+        readonly error: SessionError.Error;
+    }, "_tag">;
+    readonly Completed: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Completed";
+        readonly needsContinuation: boolean;
+    }, "_tag">;
+    readonly Continue: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Continue";
+        readonly cause: AIError;
+        readonly error: SessionError.Error;
+    }, "_tag">;
+    readonly RecoverFull: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "RecoverFull";
+    }, "_tag">;
+    readonly Compacted: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Compacted";
+    }, "_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 _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "Completed";
+        readonly needsContinuation: boolean;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "Continue";
+        readonly cause: AIError;
+        readonly error: SessionError.Error;
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "RecoverFull";
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
+        readonly _tag: "Compacted";
+    }, {
+        readonly _tag: Tag;
+    }>;
+    readonly $match: {
+        <Cases extends {
+            readonly Retry: (args: {
+                readonly _tag: "Retry";
+                readonly cause: AIError;
+                readonly error: SessionError.Error;
+            }) => any;
+            readonly Completed: (args: {
+                readonly _tag: "Completed";
+                readonly needsContinuation: boolean;
+            }) => any;
+            readonly Continue: (args: {
+                readonly _tag: "Continue";
+                readonly cause: AIError;
+                readonly error: SessionError.Error;
+            }) => any;
+            readonly RecoverFull: (args: {
+                readonly _tag: "RecoverFull";
+            }) => any;
+            readonly Compacted: (args: {
+                readonly _tag: "Compacted";
+            }) => any;
+        }>(cases: Cases): (value: {
+            readonly _tag: "Retry";
+            readonly cause: AIError;
+            readonly error: SessionError.Error;
+        } | {
+            readonly _tag: "Completed";
+            readonly needsContinuation: boolean;
+        } | {
+            readonly _tag: "Continue";
+            readonly cause: AIError;
+            readonly error: SessionError.Error;
+        } | {
+            readonly _tag: "RecoverFull";
+        } | {
+            readonly _tag: "Compacted";
+        }) => import("effect/Unify").Unify<ReturnType<Cases["Retry" | "Completed" | "Continue" | "RecoverFull" | "Compacted"]>>;
+        <Cases extends {
+            readonly Retry: (args: {
+                readonly _tag: "Retry";
+                readonly cause: AIError;
+                readonly error: SessionError.Error;
+            }) => any;
+            readonly Completed: (args: {
+                readonly _tag: "Completed";
+                readonly needsContinuation: boolean;
+            }) => any;
+            readonly Continue: (args: {
+                readonly _tag: "Continue";
+                readonly cause: AIError;
+                readonly error: SessionError.Error;
+            }) => any;
+            readonly RecoverFull: (args: {
+                readonly _tag: "RecoverFull";
+            }) => any;
+            readonly Compacted: (args: {
+                readonly _tag: "Compacted";
+            }) => any;
+        }>(value: {
+            readonly _tag: "Retry";
+            readonly cause: AIError;
+            readonly error: SessionError.Error;
+        } | {
+            readonly _tag: "Completed";
+            readonly needsContinuation: boolean;
+        } | {
+            readonly _tag: "Continue";
+            readonly cause: AIError;
+            readonly error: SessionError.Error;
+        } | {
+            readonly _tag: "RecoverFull";
+        } | {
+            readonly _tag: "Compacted";
+        }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Retry" | "Completed" | "Continue" | "RecoverFull" | "Compacted"]>>;
+    };
+};
 interface Input {
     readonly sessionID: SessionSchema.ID;
     readonly assistantMessageID: SessionMessage.ID;
     readonly agent: Agent.ID;
     readonly model: SessionRunnerModel.Resolved;
     readonly prepared: SessionModelRequest.Prepared;
-    readonly toolsDisabled: boolean;
     readonly recoverContinuation: boolean;
     /** The runner owns compaction policy; the attempt invokes it only before durable output. */
     readonly recoverOverflow: Effect.Effect<boolean>;

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

@@ -135,6 +135,7 @@ export declare const Info: import("effect/Schema").Struct<{
         }>, never, never>;
     }>;
     readonly subpath: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "RelativePath">>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "RelativePath">>, never, never>;
+    readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>, never, never>;
     readonly revert: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
         readonly messageID: import("effect/Schema").brand<import("effect/Schema").String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;

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

@@ -420,7 +420,9 @@ export declare const SessionTable: import("drizzle-orm/sqlite-core").SQLiteTable
             name: string;
             tableName: "session_v2";
             dataType: "object json";
-            data: Record<string, unknown>;
+            data: {
+                readonly [x: string]: Schema.Json;
+            };
             driverParam: string;
             notNull: false;
             hasDefault: false;

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

@@ -135,6 +135,7 @@ export declare const Data: Schema.Struct<{
             }>, never, never>;
         }>;
         readonly subpath: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "RelativePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "RelativePath">>, never, never>;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
         readonly revert: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
                 create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -767,7 +768,7 @@ export interface Interface {
     readonly import: (input: {
         data: Data;
         location: Location.Ref;
-    }) => Effect.Effect<Session.Info, ImportConflictError>;
+    }) => Effect.Effect<Session.Info, ImportConflictError | Session.NotFoundError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionTransfer", Interface>;
 export declare class Service extends Service_base {

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

@@ -2,7 +2,7 @@ export * as SessionUsage from "./usage.js";
 import type { Usage } from "@opencode-ai/ai";
 import { Money } from "@opencode-ai/schema/money";
 import type { TokenUsage } from "@opencode-ai/schema/token-usage";
-import type { Model } from "../model.js";
+import type { Model } from "@opencode-ai/schema/model";
 export declare const tokens: (usage: Usage | undefined) => TokenUsage.Info;
 export declare function calculateCost(costs: Model.Info["cost"], usage: TokenUsage.Info): number & import("effect/Brand").Brand<"Money.USD">;
 export type Recorded = {

package/dist/types/session.d.ts

@@ -2,13 +2,13 @@ export * as Session from "./session.js";
 export * from "./session/schema.js";
 import { Cause, Effect, Schema, Context, Stream } from "effect";
 import { ListAnchor } from "@opencode-ai/schema/session";
-import { Model } from "./model.js";
+import { Model } from "@opencode-ai/schema/model";
 import { Location } from "./location.js";
 import { SessionMessage } from "./session/message.js";
 import { PromptInput } from "@opencode-ai/schema/prompt-input";
 import { SessionSchema } from "./session/schema.js";
 import { AbsolutePath } from "./schema.js";
-import { Agent } from "./agent.js";
+import { Agent } from "@opencode-ai/schema/agent";
 import { SessionRunner } from "./session/runner/index.js";
 import { ForkEmptyError, MessageDecodeError, NotFoundError } from "./session/error.js";
 import { SessionEvent } from "./session/event.js";
@@ -95,6 +95,7 @@ type CreateBaseInput = {
     title?: string;
     agent?: Agent.ID;
     model?: Model.Ref;
+    metadata?: SessionSchema.Metadata;
 };
 type CreateInput = CreateBaseInput & ({
     location: Location.Ref;

package/dist/types/shell/select.d.ts

@@ -27,6 +27,9 @@ export declare function name(file: string): string;
 export declare function login(file: string): boolean;
 export declare function ps(file: string): boolean;
 export declare function args(file: string, command: string): string[];
+export declare function environment(bin?: string, filter?: {
+    compatible?: boolean;
+}): string;
 export declare function resolve(input: ResolveInput, configShell?: string, options?: Options, bin?: string): string;
 export declare namespace resolve {
     var reset: () => void;

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

@@ -1,7 +1,7 @@
 export * as McpTool from "./mcp.js";
 import { Context, Effect, Layer } from "effect";
 import { Bus } from "../bus.js";
-import { MCP } from "../mcp/index.js";
+import { Mcp } from "../mcp/index.js";
 import { Permission } from "../permission.js";
 import { Tool } from "../tool.js";
 /**
@@ -16,5 +16,5 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@opencode/McpTool", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, Bus.Service | MCP.Service | Permission.Service | Tool.Service>;
+export declare const layer: Layer.Layer<Service, never, Bus.Service | Mcp.Service | Permission.Service | Tool.Service>;
 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/tool/plugin/edit.d.ts

@@ -5,7 +5,7 @@
  * external_directory approval before edit approval.
  */
 export * as EditTool from "./edit.js";
-import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin";
+import type { Context } from "@opencode-ai/plugin/effect/plugin";
 import { Effect, Schema } from "effect";
 import { Environment } from "../../environment/index.js";
 import { FileMutation } from "../../file-mutation.js";
@@ -34,5 +34,5 @@ export type Output = typeof Output.Type;
 /** Deferred edit behavior and UX integrations remain visible at the model-facing seam. */
 export declare const Plugin: {
     id: string;
-    effect: (ctx: PluginContext) => Effect.Effect<void, never, import("effect/Scope").Scope | Location.Service | Environment.Service | FileMutation.Service | Formatter.Service | Permission.Service | LocationMutation.Service>;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Location.Service | Environment.Service | FileMutation.Service | Formatter.Service | Permission.Service | LocationMutation.Service>;
 };

package/dist/types/tool/plugin/glob.d.ts

@@ -1,5 +1,5 @@
 export * as GlobTool from "./glob.js";
-import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin";
+import type { Context } from "@opencode-ai/plugin/effect/plugin";
 import { Effect, Schema } from "effect";
 import { Environment } from "../../environment/index.js";
 import { Location } from "../../location.js";
@@ -22,5 +22,5 @@ export declare const toModelContent: (entries: EncodedOutput, truncated?: boolea
 /** Glob leaf that defaults its filesystem root to the active Location. */
 export declare const Plugin: {
     id: string;
-    effect: (ctx: PluginContext) => Effect.Effect<void, never, import("effect/Scope").Scope | Location.Service | Environment.Service | Ripgrep.Service | Permission.Service | LocationMutation.Service>;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Location.Service | Environment.Service | Ripgrep.Service | Permission.Service | LocationMutation.Service>;
 };

package/dist/types/tool/plugin/grep.d.ts

@@ -1,5 +1,5 @@
 export * as GrepTool from "./grep.js";
-import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin";
+import type { Context } from "@opencode-ai/plugin/effect/plugin";
 import { Effect, Schema } from "effect";
 import { Environment } from "../../environment/index.js";
 import { Location } from "../../location.js";
@@ -33,5 +33,5 @@ export declare const toModelContent: (matches: EncodedOutput, truncated?: boolea
 /** Grep leaf that defaults its filesystem root to the active Location. */
 export declare const Plugin: {
     id: string;
-    effect: (ctx: PluginContext) => Effect.Effect<void, never, import("effect/Scope").Scope | Location.Service | Environment.Service | Ripgrep.Service | Permission.Service | LocationMutation.Service>;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Location.Service | Environment.Service | Ripgrep.Service | Permission.Service | LocationMutation.Service>;
 };

package/dist/types/tool/plugin/patch.d.ts

@@ -1,5 +1,5 @@
 export * as PatchTool from "./patch.js";
-import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin";
+import type { Context } from "@opencode-ai/plugin/effect/plugin";
 import { Effect, Schema } from "effect";
 import { Environment } from "../../environment/index.js";
 import { Formatter } from "../../formatter.js";
@@ -31,8 +31,8 @@ export declare const Output: Schema.Struct<{
     }>>;
 }>;
 export type Output = typeof Output.Type;
-export declare const toModelOutput: (output: Output) => string;
+export declare const toModelContent: (output: Output) => string;
 export declare const Plugin: {
     id: string;
-    effect: (ctx: PluginContext) => Effect.Effect<void, never, import("effect/Scope").Scope | Location.Service | Environment.Service | FileMutation.Service | Formatter.Service | Permission.Service | LocationMutation.Service>;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Location.Service | Environment.Service | FileMutation.Service | Formatter.Service | Permission.Service | LocationMutation.Service>;
 };

package/dist/types/tool/plugin/question.d.ts

@@ -1,5 +1,5 @@
 export * as QuestionTool from "./question.js";
-import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin";
+import type { Context } from "@opencode-ai/plugin/effect/plugin";
 import { Effect, Schema } from "effect";
 import { Form } from "../../form.js";
 import { Permission } from "../../permission.js";
@@ -25,8 +25,8 @@ declare const CancelledError_base: Schema.Class<CancelledError, Schema.TaggedStr
 export declare class CancelledError extends CancelledError_base {
     get message(): string;
 }
-export declare const toModelOutput: (questions: ReadonlyArray<Question.Prompt>, answers: ReadonlyArray<Question.Answer>) => string;
+export declare const toModelContent: (questions: ReadonlyArray<Question.Prompt>, answers: ReadonlyArray<Question.Answer>) => string;
 export declare const Plugin: {
     id: string;
-    effect: (ctx: PluginContext) => Effect.Effect<void, never, import("effect/Scope").Scope | Form.Service | Permission.Service>;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Form.Service | Permission.Service>;
 };