@opencode-ai/core 0.0.0-next-17293

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 | 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

@@ -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 as PluginContext } from "@opencode-ai/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 { LocationMutation } from "../../location-mutation.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: PluginContext) => Effect.Effect<void, never, import("effect/Scope").Scope | Location.Service | Environment.Service | FileMutation.Service | Formatter.Service | LocationMutation.Service | Permission.Service>;
+};

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

@@ -0,0 +1,2 @@
+import { FileDiff } from "@opencode-ai/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,26 @@
+export * as GlobTool from "./glob.js";
+import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { Environment } from "../../environment/index.js";
+import { Location } from "../../location.js";
+import { LocationMutation } from "../../location-mutation.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 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: PluginContext) => Effect.Effect<void, never, import("effect/Scope").Scope | Location.Service | Environment.Service | Ripgrep.Service | LocationMutation.Service | Permission.Service>;
+};

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

@@ -0,0 +1,37 @@
+export * as GrepTool from "./grep.js";
+import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { Environment } from "../../environment/index.js";
+import { Location } from "../../location.js";
+import { LocationMutation } from "../../location-mutation.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 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: PluginContext) => Effect.Effect<void, never, import("effect/Scope").Scope | Location.Service | Environment.Service | Ripgrep.Service | LocationMutation.Service | Permission.Service>;
+};

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

@@ -0,0 +1,37 @@
+export * as PatchTool from "./patch.js";
+import type { Context as PluginContext } from "@opencode-ai/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 { 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 toModelOutput: (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>;
+};

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

@@ -0,0 +1,32 @@
+export * as QuestionTool from "./question.js";
+import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { Form } from "../../form.js";
+import { Permission } from "../../permission.js";
+import { Question } from "../../question.js";
+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 toModelOutput: (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>;
+};

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

@@ -0,0 +1,36 @@
+export * as ReadTool from "./read.js";
+import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Location } from "../../location.js";
+import { LocationMutation } from "../../location-mutation.js";
+import { Permission } from "../../permission.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: PluginContext) => Effect.Effect<void, never, import("effect/Scope").Scope | FSUtil.Service | Location.Service | LocationMutation.Service | Permission.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,21 @@
+export * as ShellTool from "./shell.js";
+import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Schema, Scope } from "effect";
+import { Config } from "../../config.js";
+import { Environment } from "../../environment/index.js";
+import { LocationMutation } from "../../location-mutation.js";
+import { Permission } from "../../permission.js";
+import { PluginRuntime } from "../../plugin/runtime.js";
+import { Shell } from "../../shell.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: PluginContext) => Effect.Effect<void, never, Scope.Scope | Config.Service | Environment.Service | LocationMutation.Service | Permission.Service | PluginRuntime.Service | Shell.Service>;
+};

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

@@ -0,0 +1,21 @@
+export * as SkillTool from "./skill.js";
+import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { FSUtil } from "@opencode-ai/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: PluginContext) => 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,27 @@
+export * as SubagentTool from "./subagent.js";
+import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Schema, Scope } from "effect";
+import { Agent } from "../../agent.js";
+import { Config } from "../../config.js";
+import { PluginRuntime } from "../../plugin/runtime.js";
+import { Permission } from "../../permission.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 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: PluginContext) => Effect.Effect<void, never, Scope.Scope | Agent.Service | Config.Service | Permission.Service | PluginRuntime.Service>;
+};

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

@@ -0,0 +1,21 @@
+export * as WebFetchTool from "./webfetch.js";
+import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import { Permission } from "../../permission.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: PluginContext) => Effect.Effect<void, never, import("effect/Scope").Scope | HttpClient.HttpClient | Permission.Service>;
+};
+export declare function extractTextFromHTML(html: string): string;
+export declare function convertHTMLToMarkdown(html: string): string;

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

@@ -0,0 +1,17 @@
+export * as WebSearchTool from "./websearch.js";
+import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { Form } from "../../form.js";
+import { KV } from "../../kv.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: PluginContext) => Effect.Effect<void, never, import("effect/Scope").Scope | Form.Service | KV.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 as PluginContext } from "@opencode-ai/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 { LocationMutation } from "../../location-mutation.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 toModelOutput: (output: Output) => string;
+/** Deferred write 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 | Environment.Service | FileMutation.Service | Formatter.Service | LocationMutation.Service | Permission.Service>;
+};

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

@@ -0,0 +1,100 @@
+export * as ReadToolFileSystem from "./read-filesystem.js";
+import { Context, Effect, Schema } from "effect";
+import { Environment } 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;
+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 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-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"location">>;

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

@@ -0,0 +1,26 @@
+import type { ToolDefinition } from "@opencode-ai/ai";
+import { Tool } from "@opencode-ai/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;
+})[];

package/dist/types/tool-output.d.ts

@@ -0,0 +1,16 @@
+export * as ToolOutput from "./tool-output.js";
+import type { Tool } from "@opencode-ai/schema/tool";
+import { Context, Duration, Effect } from "effect";
+export declare const MAX_LINES = 2000;
+export declare const MAX_BYTES: number;
+export declare const RETENTION: Duration.Duration;
+export declare const DIRECTORY = "tool-output";
+type Result = Tool.Result;
+export interface Interface {
+    readonly truncate: (result: Result) => Effect.Effect<Result>;
+    readonly cleanup: () => Effect.Effect<void>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/ToolOutput", Interface>;
+export declare class Service extends Service_base {
+}
+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.d.ts

@@ -0,0 +1,40 @@
+export * as Tool from "./tool.js";
+export { CallID, Content, Error, FileContent, TextContent } from "@opencode-ai/schema/tool";
+export type { Context, Metadata, Options, Result } from "@opencode-ai/schema/tool";
+import type { ToolCall, ToolDefinition } from "@opencode-ai/ai";
+import { Tool } from "@opencode-ai/schema/tool";
+import { Context, Effect, Schema, Scope } from "effect";
+import type { Agent } from "./agent.js";
+import { CodeModeCatalog } from "./codemode/catalog.js";
+import { Permission } from "./permission.js";
+import { SessionMessage } from "./session/message.js";
+import { SessionSchema } from "./session/schema.js";
+declare const RegistrationError_base: Schema.Class<RegistrationError, Schema.TaggedStruct<"Tool.RegistrationError", {
+    readonly name: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class RegistrationError extends RegistrationError_base {
+}
+export interface Interface {
+    readonly transform: (callback: (draft: {
+        readonly add: (tool: Tool.Info) => void;
+    }) => void) => Effect.Effect<void, RegistrationError, Scope.Scope>;
+    readonly snapshot: (permissions?: Permission.Ruleset) => Effect.Effect<Snapshot>;
+}
+export interface Snapshot {
+    readonly definitions: ReadonlyArray<ToolDefinition>;
+    readonly codeModeCatalog?: ReadonlyArray<CodeModeCatalog.Entry>;
+    readonly execute: (input: {
+        readonly sessionID: SessionSchema.ID;
+        readonly agent: Agent.ID;
+        readonly messageID: SessionMessage.ID;
+        readonly call: ToolCall;
+        readonly progress?: (update: Tool.Metadata) => Effect.Effect<void>;
+    }) => Effect.Effect<Tool.Result & {
+        readonly content: ReadonlyArray<Tool.Content>;
+    }, Tool.Error>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Tool", Interface>;
+export declare class Service extends Service_base {
+}
+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/util/array.d.ts

@@ -0,0 +1 @@
+export declare function findLast<T>(items: readonly T[], predicate: (item: T, index: number, items: readonly T[]) => boolean): T | undefined;

package/dist/types/util/binary.d.ts

@@ -0,0 +1,7 @@
+export declare namespace Binary {
+    function search<T>(array: T[], id: string, compare: (item: T) => string): {
+        found: boolean;
+        index: number;
+    };
+    function insert<T>(array: T[], item: T, compare: (item: T) => string): T[];
+}

package/dist/types/util/encode.d.ts

@@ -0,0 +1,5 @@
+export declare function base64Encode(value: string): string;
+export declare function base64Decode(value: string): string;
+export declare function hash(content: string, algorithm?: string): Promise<string>;
+export declare function checksum(content: string): string | undefined;
+export declare function sampledChecksum(content: string, limit?: number): string | undefined;