@opencode/core 0.0.0-reserved → 2.0.1

package/dist/types/state.d.ts

@@ -0,0 +1,73 @@
+export * as State from "./state.js";
+import { Effect, Fiber, Scope } from "effect";
+/**
+ * A synchronous, replayable edit to the current domain state.
+ *
+ * Domain editors expose readable and writable state while preserving concise
+ * plugin/config code. Transforms synchronously rebuild derived state.
+ */
+type TransformCallback<Editor> = (editor: Editor) => void;
+export type MakeEditor<State, Editor> = (state: State) => Editor;
+export interface Registration {
+    readonly dispose: Effect.Effect<void>;
+}
+/**
+ * Registers a scoped transform. Reads rebuild by applying every registered transform in order.
+ * Closing the owning Scope removes the transform and invalidates the current value.
+ */
+export type Transform<Editor> = (transform: TransformCallback<Editor>) => Effect.Effect<Registration, never, Scope.Scope>;
+/** Invalidates the current value after captured inputs change and notifies like a registration would. */
+export type Reload = () => Effect.Effect<void>;
+export interface Transformable<Editor> {
+    readonly transform: Transform<Editor>;
+    readonly reload: Reload;
+}
+export interface Failure {
+    readonly state: string;
+    readonly cause: unknown;
+}
+type GroupedRegistration = {
+    readonly remove: () => boolean;
+    readonly notify: Effect.Effect<void>;
+};
+type RegistrationGroup = {
+    failed: boolean;
+    readonly registrations: Set<GroupedRegistration>;
+    readonly report: (failure: Failure, refresh: Effect.Effect<void>) => void;
+};
+/**
+ * Groups registrations without coupling State to plugin identity or asynchronous cleanup.
+ * A failed group is detached synchronously; its supervisor must run refresh and close its scope.
+ */
+export declare function group(report: RegistrationGroup["report"]): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, never>>;
+/** Coalesces notifications until the effect completes. Reads inside stay fresh; nothing is rolled back. */
+export declare function batch<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+/** Runs the effect as shutdown: States changed inside it close permanently and never notify again. */
+export declare function shutdown<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+/**
+ * A `notify` body that runs resource reconciliation in the owning layer's FiberSet and awaits it, so work
+ * queued behind the layer's locks is interrupted with the layer. That interruption is not a failure.
+ */
+export declare function reconcile(root: Scope.Scope, fork: (effect: Effect.Effect<void>) => Fiber.Fiber<void>, work: () => Effect.Effect<void>): Effect.Effect<void>;
+export declare const inherit: () => Effect.Effect<(<A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, never>>), never, never>;
+export interface Options<State, Editor> {
+    readonly name?: string;
+    /** Creates the empty base value for every rebuild. */
+    readonly initial: () => State;
+    /** Wraps mutable state in a domain-specific editor API. */
+    readonly editor: MakeEditor<State, Editor>;
+    /**
+     * Observes the freshly rebuilt value outside the read path. Every registration, disposal, or
+     * reload notifies once it is applied; a batch coalesces them into one notification at its end.
+     * Resource reconciliation owns its execution scope and coordination.
+     */
+    readonly notify?: (state: State) => Effect.Effect<void>;
+}
+export interface Interface<State, Editor> extends Transformable<Editor> {
+    /**
+     * Rebuilds synchronously when transforms changed since the last read. Each rebuild produces a new
+     * value and never touches earlier ones, so callers may retain what they read.
+     */
+    readonly get: () => State;
+}
+export declare function create<State, Editor>(options: Options<State, Editor>): Interface<State, Editor>;

package/dist/types/tool/html-markdown.d.ts

@@ -0,0 +1,2 @@
+export declare const MAX_MARKDOWN_BYTES: number;
+export declare function convertHTMLToMarkdown(html: string): string;

package/dist/types/tool/http-body.d.ts

@@ -0,0 +1,3 @@
+import { Effect } from "effect";
+import { HttpClientResponse } from "effect/unstable/http";
+export declare const collectBoundedResponseBody: (response: HttpClientResponse.HttpClientResponse, maximumBytes: number, tooLarge: () => Error) => Effect.Effect<Buffer<ArrayBuffer>, Error | import("effect/unstable/http/HttpClientError").HttpClientError, never>;

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

@@ -0,0 +1,20 @@
+export * as McpTool from "./mcp.js";
+import { Context, Effect, Layer } from "effect";
+import { Bus } from "../bus.js";
+import { Mcp } from "../mcp/index.js";
+import { Permission } from "../permission.js";
+import { Tool } from "../tool.js";
+/**
+ * Registry namespace and permission action names for MCP tools.
+ */
+export declare const namespace: (server: string) => string;
+export declare const name: (server: string, tool: string) => string;
+export interface Interface {
+    /** Wait for the initial MCP tool registration to settle. */
+    readonly flush: Effect.Effect<void>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/McpTool", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Bus.Service | Permission.Service | Tool.Service | Mcp.Service>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

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

@@ -0,0 +1,38 @@
+/**
+ * Model-facing exact-edit leaf. Relative paths resolve within the active
+ * Location. Absolute paths inside that Location are accepted, while explicit
+ * absolute external paths retain mutation capability through a separate
+ * external_directory approval before edit approval.
+ */
+export * as EditTool from "./edit.js";
+import type { Context } from "@opencode/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { Environment } from "../../environment/index.js";
+import { FileMutation } from "../../file-mutation.js";
+import { Formatter } from "../../formatter.js";
+import { Location } from "../../location.js";
+import { FileAccess } from "../../file-access.js";
+import { Permission } from "../../permission.js";
+export declare const name = "edit";
+export declare const Input: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly oldString: Schema.String;
+    readonly newString: Schema.String;
+    readonly replaceAll: Schema.optionalKey<Schema.Boolean>;
+}>;
+export declare const Output: Schema.Struct<{
+    readonly files: Schema.$Array<Schema.Struct<{
+        readonly file: Schema.String;
+        readonly patch: Schema.String;
+        readonly additions: Schema.Int;
+        readonly deletions: Schema.Int;
+        readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
+    }>>;
+    readonly replacements: Schema.Number;
+}>;
+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: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Location.Service | Permission.Service | Environment.Service | FileAccess.Service | FileMutation.Service | Formatter.Service>;
+};

package/dist/types/tool/plugin/file-diff.d.ts

@@ -0,0 +1,2 @@
+import { FileDiff } from "@opencode/schema/file-diff";
+export declare function fileDiff(file: string, before: string, after: string, status?: typeof FileDiff.Info.Type.status): typeof FileDiff.Info.Type;

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

@@ -0,0 +1,27 @@
+export * as GlobTool from "./glob.js";
+import type { Context } from "@opencode/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { Environment } from "../../environment/index.js";
+import { Location } from "../../location.js";
+import { FileAccess } from "../../file-access.js";
+import { Ripgrep } from "../../ripgrep.js";
+import { Permission } from "../../permission.js";
+export declare const name = "glob";
+export declare const Input: Schema.Struct<{
+    readonly pattern: Schema.String;
+    readonly path: Schema.optionalKey<Schema.brand<Schema.String, "RelativePath">>;
+    readonly hidden: Schema.optionalKey<Schema.Boolean>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+export declare const Output: Schema.$Array<Schema.Struct<{
+    readonly path: Schema.brand<Schema.String, "RelativePath">;
+    readonly type: Schema.Literals<readonly ["file", "directory"]>;
+}>>;
+type EncodedOutput = typeof Output.Encoded;
+/** Format raw search results into the concise line-oriented output models expect. */
+export declare const toModelContent: (entries: EncodedOutput, truncated?: boolean) => string;
+/** Glob leaf that defaults its filesystem root to the active Location. */
+export declare const Plugin: {
+    id: string;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Location.Service | Permission.Service | Environment.Service | Ripgrep.Service | FileAccess.Service>;
+};

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

@@ -0,0 +1,39 @@
+export * as GrepTool from "./grep.js";
+import type { Context } from "@opencode/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { Environment } from "../../environment/index.js";
+import { Location } from "../../location.js";
+import { FileAccess } from "../../file-access.js";
+import { Permission } from "../../permission.js";
+import { Ripgrep } from "../../ripgrep.js";
+export declare const name = "grep";
+export declare const Input: Schema.Struct<{
+    readonly pattern: Schema.String;
+    readonly path: Schema.optionalKey<Schema.brand<Schema.String, "RelativePath">>;
+    readonly include: Schema.optionalKey<Schema.String>;
+    readonly literal: Schema.optionalKey<Schema.Boolean>;
+    readonly caseSensitive: Schema.optionalKey<Schema.Boolean>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+export declare const Output: Schema.$Array<Schema.Struct<{
+    readonly entry: Schema.Struct<{
+        readonly path: Schema.brand<Schema.String, "RelativePath">;
+        readonly type: Schema.Literals<readonly ["file", "directory"]>;
+    }>;
+    readonly line: Schema.Int;
+    readonly offset: Schema.Int;
+    readonly text: Schema.String;
+    readonly submatches: Schema.$Array<Schema.Struct<{
+        readonly text: Schema.String;
+        readonly start: Schema.Int;
+        readonly end: Schema.Int;
+    }>>;
+}>>;
+type EncodedOutput = typeof Output.Encoded;
+/** Format raw search matches into concise model content. */
+export declare const toModelContent: (matches: EncodedOutput, truncated?: boolean) => string;
+/** Grep leaf that defaults its filesystem root to the active Location. */
+export declare const Plugin: {
+    id: string;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Location.Service | Permission.Service | Environment.Service | Ripgrep.Service | FileAccess.Service>;
+};

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

@@ -0,0 +1,21 @@
+export * as OpenCodeTools from "./opencode.js";
+import type { Context } from "@opencode/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+export declare const RenameInput: Schema.Struct<{
+    readonly sessionID: Schema.optionalKey<Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    }>;
+    readonly title: Schema.String;
+}>;
+export declare const MoveInput: Schema.Struct<{
+    readonly sessionID: Schema.optionalKey<Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    }>;
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+}>;
+export declare const Plugin: {
+    id: string;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope>;
+};

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

@@ -0,0 +1,38 @@
+export * as PatchTool from "./patch.js";
+import type { Context } from "@opencode/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { Environment } from "../../environment/index.js";
+import { Formatter } from "../../formatter.js";
+import { FileMutation } from "../../file-mutation.js";
+import { Location } from "../../location.js";
+import { FileAccess } from "../../file-access.js";
+import { Permission } from "../../permission.js";
+export declare const name = "patch";
+export declare const Input: Schema.Struct<{
+    readonly patchText: Schema.String;
+}>;
+export declare const Applied: Schema.Struct<{
+    readonly type: Schema.Literals<readonly ["add", "update", "delete"]>;
+    readonly resource: Schema.String;
+    readonly target: Schema.String;
+}>;
+export declare const Output: Schema.Struct<{
+    readonly applied: Schema.$Array<Schema.Struct<{
+        readonly type: Schema.Literals<readonly ["add", "update", "delete"]>;
+        readonly resource: Schema.String;
+        readonly target: Schema.String;
+    }>>;
+    readonly files: Schema.$Array<Schema.Struct<{
+        readonly file: Schema.String;
+        readonly patch: Schema.String;
+        readonly additions: Schema.Int;
+        readonly deletions: Schema.Int;
+        readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
+    }>>;
+}>;
+export type Output = typeof Output.Type;
+export declare const toModelContent: (output: Output) => string;
+export declare const Plugin: {
+    id: string;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Location.Service | Permission.Service | Environment.Service | FileAccess.Service | FileMutation.Service | Formatter.Service>;
+};

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

@@ -0,0 +1,32 @@
+export * as QuestionTool from "./question.js";
+import type { Context } from "@opencode/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { Form } from "../../form.js";
+import { Permission } from "../../permission.js";
+import { Question } from "@opencode/schema/question";
+export declare const name = "question";
+export declare const description = "Use this tool when you need to ask the user questions during execution. This allows you to:\n1. Gather user preferences or requirements\n2. Clarify ambiguous instructions\n3. Get decisions on implementation choices as you work\n4. Offer choices to the user about what direction to take.\n\nUsage notes:\n- A \"Type your own answer\" option is added automatically; don't include a separate option for free form answers\n- Set `multiple: true` to allow selecting more than one option\n- If you recommend a specific option, make that the first option in the list and add \"(Recommended)\" at the end of the label";
+export declare const Input: Schema.Struct<{
+    readonly questions: Schema.$Array<Schema.Struct<{
+        question: Schema.String;
+        header: Schema.String;
+        options: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.String;
+            readonly description: Schema.String;
+        }>>;
+        multiple: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }>>;
+}>;
+export declare const Output: Schema.Struct<{
+    readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
+}>;
+export type Output = typeof Output.Type;
+declare const CancelledError_base: Schema.Class<CancelledError, Schema.TaggedStruct<"QuestionTool.CancelledError", {}>, import("effect/Cause").YieldableError>;
+export declare class CancelledError extends CancelledError_base {
+    get message(): string;
+}
+export declare const toModelContent: (questions: ReadonlyArray<Question.Prompt>, answers: ReadonlyArray<Question.Answer>) => string;
+export declare const Plugin: {
+    id: string;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Form.Service | Permission.Service>;
+};

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

@@ -0,0 +1,35 @@
+export * as ReadTool from "./read.js";
+import type { Context } from "@opencode/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Location } from "../../location.js";
+import { FileAccess } from "../../file-access.js";
+import { SessionInstructions } from "../../session/instructions.js";
+import { ReadToolFileSystem } from "../read-filesystem.js";
+export declare const name = "read";
+export declare const Input: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly offset: Schema.optionalKey<Schema.Int>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+declare const Output: Schema.Union<readonly [Schema.Struct<{
+    readonly uri: Schema.String;
+    readonly name: Schema.optional<Schema.String>;
+    readonly content: Schema.String;
+    readonly encoding: Schema.Literals<readonly ["utf8", "base64"]>;
+    readonly mime: Schema.String;
+    readonly type: Schema.Literal<"file">;
+}>, typeof ReadToolFileSystem.TextPage, typeof ReadToolFileSystem.ListPage]>;
+export declare const Plugin: {
+    id: string;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | FSUtil.Service | Location.Service | FileAccess.Service | ReadToolFileSystem.Service | SessionInstructions.Service>;
+};
+export declare const toModelContent: (path: string, offset: number | undefined, output: typeof Output.Type) => string | readonly [{
+    readonly type: "text";
+    readonly text: "PDF read successfully" | "Image read successfully";
+}, {
+    readonly type: "file";
+    readonly uri: `data:${string};base64,${string}`;
+    readonly mime: string;
+    readonly name: string;
+}];

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

@@ -0,0 +1,23 @@
+export * as ShellTool from "./shell.js";
+import type { Context } from "@opencode/plugin/effect/plugin";
+import { Effect, Schema, Scope } from "effect";
+import { Config } from "../../config.js";
+import { Environment } from "../../environment/index.js";
+import { Job } from "../../job.js";
+import { FileAccess } from "../../file-access.js";
+import { Permission } from "../../permission.js";
+import { Session } from "../../session.js";
+import { Shell } from "../../shell.js";
+import { ShellSelect } from "../../shell/select.js";
+export declare const name = "shell";
+export declare const DEFAULT_TIMEOUT_MS: number;
+export declare const Input: Schema.Struct<{
+    readonly command: Schema.String;
+    readonly workdir: Schema.optionalKey<Schema.String>;
+    readonly timeout: Schema.optionalKey<Schema.Int>;
+    readonly background: Schema.optionalKey<Schema.Boolean>;
+}>;
+export declare const Plugin: {
+    id: string;
+    effect: (ctx: Context) => Effect.Effect<void, never, Scope.Scope | Config.Service | Permission.Service | Environment.Service | FileAccess.Service | ShellSelect.Service | Session.Service | Job.Service | Shell.Service>;
+};

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

@@ -0,0 +1,21 @@
+export * as SkillTool from "./skill.js";
+import type { Context } from "@opencode/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Skill } from "../../skill.js";
+import { Permission } from "../../permission.js";
+export declare const name = "skill";
+export declare const Input: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Skill.ID">;
+}>;
+export declare const Output: Schema.Struct<{
+    readonly name: Schema.brand<Schema.String, "Skill.Name">;
+    readonly directory: Schema.String;
+    readonly output: Schema.String;
+}>;
+export declare const description: string;
+export declare const toModelOutput: (skill: Skill.Info, files: ReadonlyArray<string>) => string;
+export declare const Plugin: {
+    id: string;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | FSUtil.Service | Permission.Service | Skill.Service>;
+};

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

@@ -0,0 +1,32 @@
+export * as SubagentTool from "./subagent.js";
+import type { Context } from "@opencode/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { Agent } from "../../agent.js";
+import { Config } from "../../config.js";
+import { Job } from "../../job.js";
+import { Permission } from "../../permission.js";
+import { Session } from "../../session.js";
+export declare const name = "subagent";
+export declare const Input: Schema.Struct<{
+    readonly agent: Schema.String;
+    readonly description: Schema.String;
+    readonly prompt: Schema.String;
+    readonly sessionID: Schema.optionalKey<Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    }>;
+    readonly background: Schema.optionalKey<Schema.Boolean>;
+}>;
+export declare const Output: 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 status: Schema.Literals<readonly ["completed", "running"]>;
+    readonly output: Schema.String;
+}>;
+export declare const description: string;
+export declare const Plugin: {
+    id: string;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Agent.Service | Config.Service | Permission.Service | Session.Service | Job.Service>;
+};

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

@@ -0,0 +1,22 @@
+export * as WebFetchTool from "./webfetch.js";
+import type { Context } from "@opencode/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import { Permission } from "../../permission.js";
+import { convertHTMLToMarkdown } from "../html-markdown.js";
+export declare const name = "webfetch";
+export declare const MAX_RESPONSE_BYTES: number;
+export declare const DEFAULT_TIMEOUT_SECONDS = 30;
+export declare const MAX_TIMEOUT_SECONDS = 120;
+export declare const description = "Fetch content from an HTTP or HTTPS URL and return it as text, markdown, or HTML. Markdown is the default.\n\nUse a more targeted tool when one is available. This tool is read-only. Large text results may be replaced with a preview while the complete output is retained in managed storage.";
+export declare const Input: Schema.Struct<{
+    readonly url: Schema.String;
+    readonly format: Schema.withDecodingDefaultKey<Schema.Literals<readonly ["text", "markdown", "html"]>, never>;
+    readonly timeout: Schema.optionalKey<Schema.Finite>;
+}>;
+export declare const Plugin: {
+    id: string;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | HttpClient.HttpClient | Permission.Service>;
+};
+export declare function extractTextFromHTML(html: string): string;
+export { convertHTMLToMarkdown };

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

@@ -0,0 +1,16 @@
+export * as WebSearchTool from "./websearch.js";
+import type { Context } from "@opencode/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { Form } from "../../form.js";
+import { Permission } from "../../permission.js";
+import { WebSearch } from "../../websearch.js";
+export declare const name = "websearch";
+export declare const NO_RESULTS = "No search results found. Please try a different query.";
+export declare const description: string;
+export declare const Input: Schema.Struct<{
+    readonly query: Schema.String;
+}>;
+export declare const Plugin: {
+    id: string;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Form.Service | Permission.Service | WebSearch.Service>;
+};

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

@@ -0,0 +1,32 @@
+/**
+ * Model-facing file-write leaf. Relative paths resolve within the active
+ * Location. Absolute paths inside that Location are accepted, while explicit
+ * absolute external paths retain mutation capability through a separate
+ * external_directory approval before edit approval.
+ */
+export * as WriteTool from "./write.js";
+import type { Context } from "@opencode/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { Environment } from "../../environment/index.js";
+import { FileMutation } from "../../file-mutation.js";
+import { Formatter } from "../../formatter.js";
+import { FileAccess } from "../../file-access.js";
+import { Permission } from "../../permission.js";
+export declare const name = "write";
+export declare const Input: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly content: Schema.String;
+}>;
+export declare const Output: Schema.Struct<{
+    readonly operation: Schema.Literal<"write">;
+    readonly target: Schema.String;
+    readonly resource: Schema.String;
+    readonly existed: Schema.Boolean;
+}>;
+export type Output = typeof Output.Type;
+export declare const toModelContent: (output: Output) => string;
+/** Deferred write UX integrations remain visible at the model-facing seam. */
+export declare const Plugin: {
+    id: string;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Permission.Service | Environment.Service | FileAccess.Service | FileMutation.Service | Formatter.Service>;
+};

package/dist/types/tool/read-filesystem.d.ts

@@ -0,0 +1,103 @@
+export * as ReadToolFileSystem from "./read-filesystem.js";
+import { Context, Effect, Schema } from "effect";
+import { Environment } from "../environment/index.js";
+import type { Files } from "../environment/index.js";
+import { AbsolutePath } from "../schema.js";
+export declare const MAX_READ_LINES = 2000;
+export declare const MAX_READ_BYTES: number;
+export declare const MAX_MEDIA_INGEST_BYTES: number;
+export declare const MEDIA_MIMES: Set<string>;
+declare const BinaryFileError_base: Schema.Class<BinaryFileError, Schema.TaggedStruct<"ReadTool.BinaryFileError", {
+    readonly resource: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class BinaryFileError extends BinaryFileError_base {
+    get message(): string;
+}
+declare const MediaIngestLimitError_base: Schema.Class<MediaIngestLimitError, Schema.TaggedStruct<"ReadTool.MediaIngestLimitError", {
+    readonly resource: Schema.String;
+    readonly maximumBytes: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+export declare class MediaIngestLimitError extends MediaIngestLimitError_base {
+    get message(): string;
+}
+declare const OffsetOutOfRangeError_base: Schema.Class<OffsetOutOfRangeError, Schema.TaggedStruct<"ReadTool.OffsetOutOfRangeError", {
+    readonly offset: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+export declare class OffsetOutOfRangeError extends OffsetOutOfRangeError_base {
+    get message(): string;
+}
+declare const PathKindError_base: Schema.Class<PathKindError, Schema.TaggedStruct<"ReadTool.PathKindError", {
+    readonly resource: Schema.String;
+    readonly expected: Schema.Literals<readonly ["a file", "a file or directory"]>;
+}>, import("effect/Cause").YieldableError>;
+export declare class PathKindError extends PathKindError_base {
+    get message(): string;
+}
+export type ReadError = Environment.NotFound | Environment.Failed | BinaryFileError | MediaIngestLimitError | OffsetOutOfRangeError | PathKindError;
+export declare const PageInput: Schema.Struct<{
+    readonly offset: Schema.optionalKey<Schema.Int>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+}>;
+export type PageInput = typeof PageInput.Type;
+export declare const FileContent: Schema.Struct<{
+    readonly uri: Schema.String;
+    readonly name: Schema.optional<Schema.String>;
+    readonly content: Schema.String;
+    readonly encoding: Schema.Literals<readonly ["utf8", "base64"]>;
+    readonly mime: Schema.String;
+    readonly type: Schema.Literal<"file">;
+}>;
+export type FileContent = typeof FileContent.Type;
+declare const TextPage_base: Schema.Class<TextPage, Schema.Struct<{
+    readonly type: Schema.Literal<"text-page">;
+    readonly content: Schema.String;
+    readonly mime: Schema.String;
+    readonly offset: Schema.Int;
+    readonly truncated: Schema.Boolean;
+    readonly next: Schema.optionalKey<Schema.Int>;
+}>, {}>;
+export declare class TextPage extends TextPage_base {
+}
+export interface ListEntry extends Schema.Schema.Type<typeof ListEntry> {
+}
+export declare const ListEntry: Schema.Struct<{
+    readonly path: Schema.brand<Schema.String, "RelativePath">;
+    readonly type: Schema.Literals<readonly ["file", "directory", "symlink"]>;
+}>;
+declare const ListPage_base: Schema.Class<ListPage, Schema.Struct<{
+    readonly type: Schema.Literal<"list-page">;
+    readonly entries: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.brand<Schema.String, "RelativePath">;
+        readonly type: Schema.Literals<readonly ["file", "directory", "symlink"]>;
+    }>>;
+    readonly truncated: Schema.Boolean;
+    readonly next: Schema.optionalKey<Schema.Int>;
+}>, {}>;
+export declare class ListPage extends ListPage_base {
+}
+export interface Interface {
+    readonly list: (path: AbsolutePath) => ReturnType<Files["list"]>;
+    readonly read: (path: AbsolutePath, resource: string, page?: PageInput) => Effect.Effect<FileContent | TextPage | ListPage, ReadError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/ReadToolFileSystem", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const read: (files: Environment.Files, input: string & import("effect/Brand").Brand<"AbsolutePath">, resource: string, page?: {
+    readonly limit?: number | undefined;
+    readonly offset?: number | undefined;
+} | undefined) => Effect.Effect<TextPage | ListPage | {
+    type: "file";
+    uri: string;
+    name: string;
+    content: string;
+    encoding: "base64";
+    mime: string;
+} | {
+    type: "file";
+    uri: string;
+    name: string;
+    content: string;
+    encoding: "utf8";
+    mime: string;
+}, Environment.NotFound | Environment.Failed | BinaryFileError | MediaIngestLimitError | OffsetOutOfRangeError | PathKindError, never>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

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

@@ -0,0 +1,28 @@
+import type { ToolDefinition } from "@opencode/ai";
+import { Tool } from "@opencode/schema/tool";
+import { Effect } from "effect";
+export declare const definition: (tool: Tool.Info<any, any>) => ToolDefinition;
+export declare const execute: (tool: Tool.Info<any, any>, input: unknown, context: Tool.Context) => Effect.Effect<{
+    metadata?: Readonly<Record<string, any>> | undefined;
+    output: any;
+    content: ({
+        readonly type: "text";
+        readonly text: string;
+    } | {
+        readonly type: "file";
+        readonly uri: string;
+        readonly mime: string;
+        readonly name?: string | undefined;
+    })[];
+}, Tool.Error, never>;
+export declare const normalizeContent: (value: string | ReadonlyArray<Tool.Content> | undefined, output?: unknown) => ({
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "file";
+    readonly uri: string;
+    readonly mime: string;
+    readonly name?: string | undefined;
+})[];
+export declare const normalizedName: (tool: Tool.Info) => string;
+export declare const effectiveName: (tool: Tool.Info) => string;