@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-9fyr8pyw.js

@@ -0,0 +1,212 @@
+import {
+  exports_runtime
+} from "./location-mutation-jm193w7g.js";
+import {
+  exports_permission
+} from "./location-mutation-gjaba53s.js";
+import {
+  exports_schema
+} from "./location-mutation-y8rs54ne.js";
+import {
+  exports_agent
+} from "./location-mutation-0ms0v4tv.js";
+import {
+  exports_config
+} from "./location-mutation-qvf5nvg0.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/tool/plugin/subagent.ts
+var exports_subagent = {};
+__export(exports_subagent, {
+  name: () => name,
+  description: () => description,
+  SubagentTool: () => exports_subagent,
+  Plugin: () => Plugin,
+  Output: () => Output,
+  Input: () => Input
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { Effect, Schema, Scope } from "effect";
+var name = "subagent";
+var NO_TEXT = "Subagent completed without a text response.";
+var backgroundStarted = (sessionID) => [
+  `The subagent is working in the background (id: ${sessionID}). You will be notified automatically when it finishes.`,
+  "DO NOT sleep, poll for progress, ask the subagent for status, or duplicate this subagent's work; avoid working with the same files or topics it is using.",
+  "Work on non-overlapping tasks, or briefly tell the user what you launched and end your response."
+].join(`
+`);
+var Input = Schema.Struct({
+  agent: Schema.String.annotate({ description: "The type of specialized agent to use for this task" }),
+  description: Schema.String.annotate({ description: "A short 3-5 word label for the task, displayed to the user" }),
+  prompt: Schema.String.annotate({ description: "The task for the subagent to perform" }),
+  background: Schema.optionalKey(Schema.Boolean).annotate({
+    description: "Run the subagent in the background and return immediately. You will be notified when it completes. DO NOT sleep, poll, or proactively check on its progress."
+  })
+});
+var Output = Schema.Struct({
+  sessionID: exports_schema.ID,
+  status: Schema.Literals(["completed", "running"]),
+  output: Schema.String
+});
+var description = [
+  "Spawns an agent in a child session to work on the specified task.",
+  "Include all relevant context and instructions in the prompt because the child starts with fresh context.",
+  "Foreground (default) runs the subagent to completion and returns its final response.",
+  "Background mode (background=true) launches it asynchronously and returns immediately; you are notified when it finishes.",
+  "Use background only for independent work that can run while you continue elsewhere."
+].join(`
+`);
+var Plugin = {
+  id: "opencode.tool.subagent",
+  effect: Effect.fn("SubagentTool.Plugin")(function* (ctx) {
+    const runtime = yield* exports_runtime.Service;
+    const agents = yield* exports_agent.Service;
+    const config = yield* exports_config.Service;
+    const permission = yield* exports_permission.Service;
+    const scope = yield* Scope.Scope;
+    const latestAssistantText = Effect.fn("SubagentTool.latestAssistantText")(function* (sessionID) {
+      const messages = yield* runtime.session.messages({ sessionID, order: "desc", limit: 20 });
+      const assistant = messages.find((message) => message.type === "assistant" && message.time.completed !== undefined && message.error === undefined);
+      if (assistant === undefined || assistant.type !== "assistant")
+        return NO_TEXT;
+      const text = assistant.content.filter((part) => part.type === "text").map((part) => part.text).join("");
+      return text.length > 0 ? text : NO_TEXT;
+    });
+    const injectCompletion = Effect.fn("SubagentTool.injectCompletion")(function* (parentID, childID, agent, description2, state, text) {
+      yield* runtime.session.synthetic({
+        sessionID: parentID,
+        text: `<subagent id="${childID}" state="${state}" description="${description2}">
+${text}
+</subagent>`,
+        description: description2,
+        metadata: { source: "subagent", childID, agent, state }
+      });
+    });
+    const notifyWhenDone = Effect.fn("SubagentTool.notifyWhenDone")(function* (parentID, childID, agent, description2) {
+      yield* runtime.job.wait({ id: childID }).pipe(Effect.flatMap((result) => {
+        if (result.info?.status === "completed")
+          return injectCompletion(parentID, childID, agent, description2, "completed", result.info.output ?? NO_TEXT);
+        if (result.info?.status === "error")
+          return injectCompletion(parentID, childID, agent, description2, "error", result.info.error ?? "Subagent failed");
+        if (result.info?.status === "cancelled")
+          return injectCompletion(parentID, childID, agent, description2, "cancelled", "Subagent cancelled");
+        return Effect.void;
+      }), Effect.forkIn(scope, { startImmediately: true }));
+    });
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description,
+      input: Input,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        const parent = yield* runtime.session.get(context.sessionID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${context.sessionID}`, error })));
+        let current = parent;
+        let depth = 0;
+        while (current.parentID) {
+          depth++;
+          current = yield* runtime.session.get(current.parentID).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${current.parentID}`, error })));
+        }
+        const limit = exports_config.latest(yield* config.entries(), "experimental")?.subagent_depth ?? 1;
+        if (depth >= limit)
+          return yield* new ToolFailure({
+            message: `Subagent depth limit reached (${limit}). Increase "experimental.subagent_depth" to allow nested subagents.`
+          });
+        const agent = yield* agents.resolve(input.agent);
+        if (agent === undefined)
+          return yield* new ToolFailure({ message: `Unknown agent: ${input.agent}` });
+        if (agent.mode === "primary")
+          return yield* new ToolFailure({ message: `Agent ${input.agent} cannot run as a subagent` });
+        yield* permission.assert({
+          action: name,
+          resources: [agent.id],
+          save: [agent.id],
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source: {
+            type: "tool",
+            messageID: context.messageID,
+            id: context.id
+          }
+        }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Subagent denied: ${agent.id}`, error })));
+        const model = agent.model ?? parent.model;
+        const child = yield* runtime.session.create({
+          parentID: context.sessionID,
+          title: input.description,
+          agent: exports_agent.ID.make(input.agent),
+          model
+        }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Parent session not found: ${context.sessionID}`, error })));
+        const background = input.background === true;
+        yield* context.progress({ sessionID: child.id, status: "running" });
+        const run = Effect.gen(function* () {
+          yield* runtime.session.prompt({
+            sessionID: child.id,
+            text: ["You are a subagent spawned by another session.", input.prompt].join(`
+`),
+            resume: false
+          });
+          yield* runtime.session.resume(child.id);
+          return yield* latestAssistantText(child.id);
+        }).pipe(Effect.onInterrupt(() => runtime.session.interrupt(child.id)));
+        const info = yield* runtime.job.start({
+          id: child.id,
+          type: name,
+          title: input.description,
+          metadata: {},
+          run
+        });
+        if (background) {
+          yield* runtime.job.background(info.id);
+          yield* notifyWhenDone(context.sessionID, child.id, agent.name, input.description);
+          return {
+            sessionID: child.id,
+            status: "running",
+            output: backgroundStarted(child.id)
+          };
+        }
+        const result = yield* runtime.job.block({ id: child.id, sessionID: context.sessionID }).pipe(Effect.onInterrupt(() => Effect.all([runtime.session.interrupt(child.id), runtime.job.cancel(child.id)], {
+          discard: true
+        })));
+        if (result?.type === "backgrounded") {
+          yield* notifyWhenDone(context.sessionID, child.id, agent.name, input.description);
+          return {
+            sessionID: child.id,
+            status: "running",
+            output: backgroundStarted(child.id)
+          };
+        }
+        if (result?.info.status === "error")
+          return yield* new ToolFailure({ message: result.info.error ?? "Subagent failed" });
+        if (result?.info.status === "cancelled")
+          return yield* new ToolFailure({ message: "Subagent cancelled" });
+        return { sessionID: child.id, status: "completed", output: result?.info.output ?? NO_TEXT };
+      }).pipe(Effect.map((output) => ({
+        output,
+        content: output.output,
+        metadata: { sessionID: output.sessionID, status: output.status }
+      })))
+    })).pipe(Effect.orDie);
+    yield* ctx.session.hook("context", (event) => Effect.gen(function* () {
+      const tool = event.tools[name];
+      if (!tool)
+        return;
+      const selected = yield* agents.resolve(event.agent);
+      if (!selected)
+        return;
+      const available = (yield* agents.list()).filter((agent) => agent.mode !== "primary" && !agent.hidden && exports_permission.evaluate(name, agent.id, selected.permissions).effect !== "deny").toSorted((a, b) => a.id.localeCompare(b.id));
+      if (available.length === 0)
+        return;
+      tool.description = [
+        tool.description,
+        "",
+        "Available subagents:",
+        ...available.map((agent) => `- ${agent.id}: ${agent.description ?? "This subagent should only be called when explicitly requested."}`)
+      ].join(`
+`);
+    }));
+  })
+};
+
+export { name, Input, Output, description, Plugin, exports_subagent };

package/dist/chunks/location-mutation-9gg3fnah.js

@@ -0,0 +1,175 @@
+import {
+  exports_read_filesystem
+} from "./location-mutation-7xwrfrqq.js";
+import {
+  exports_instructions
+} from "./location-mutation-9xe9cxt1.js";
+import {
+  exports_permission
+} from "./location-mutation-gjaba53s.js";
+import {
+  exports_location_mutation
+} from "./location-mutation-z17t3kn2.js";
+import {
+  exports_environment1 as exports_environment
+} from "./location-mutation-pysc8t9c.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  AbsolutePath
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/tool/plugin/read.ts
+var exports_read = {};
+__export(exports_read, {
+  toModelContent: () => toModelContent,
+  name: () => name,
+  ReadTool: () => exports_read,
+  Plugin: () => Plugin,
+  Input: () => Input
+});
+import { basename, dirname, join } from "path";
+import { ToolFailure } from "@opencode-ai/ai";
+import { Effect, Schema } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+var name = "read";
+var FILENAME = "AGENTS.md";
+var SUPPORTED_MEDIA_MIMES = new Set(["image/jpeg", "image/png", "image/gif", "image/webp", "application/pdf"]);
+var LocationInput = Schema.Struct({
+  path: Schema.String.annotate({ description: "File or directory to read" }),
+  offset: exports_read_filesystem.PageInput.fields.offset.annotate({
+    description: "The line or directory entry to start reading from (1-based)"
+  }),
+  limit: exports_read_filesystem.PageInput.fields.limit.annotate({
+    description: "The maximum number of lines or directory entries to read (defaults to 2000)"
+  })
+});
+var Input = LocationInput;
+var Output = Schema.Union([exports_read_filesystem.FileContent, exports_read_filesystem.TextPage, exports_read_filesystem.ListPage]);
+var Plugin = {
+  id: "opencode.tool.read",
+  effect: Effect.fn("ReadTool.Plugin")(function* (ctx) {
+    const reader = yield* exports_read_filesystem.Service;
+    const mutation = yield* exports_location_mutation.Service;
+    const permission = yield* exports_permission.Service;
+    const sessionInstructions = yield* exports_instructions.Service;
+    const fs = yield* FSUtil.Service;
+    const location = yield* exports_location.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description: "Read the contents of a file or directory. Supports text files, images, and PDFs. Images and PDFs are presented directly to the model. Each text line is prefixed by its 1-based line number as <line>: <content>. The prefix is for reference and is not part of the file content. Directory entries are returned one per line. Use offset and limit to read large files or directories in sections. Prefer one larger read over many small slices, and use grep to find specific content in large files.",
+      input: Input,
+      output: Output,
+      execute: (input, context) => {
+        return Effect.gen(function* () {
+          const source = {
+            type: "tool",
+            messageID: context.messageID,
+            id: context.id
+          };
+          const target = yield* mutation.resolve({ path: input.path });
+          const external = target.externalDirectory;
+          if (external)
+            yield* permission.assert({
+              ...exports_location_mutation.externalDirectoryPermission(external),
+              sessionID: context.sessionID,
+              agent: context.agent,
+              source
+            });
+          const resource = target.resource;
+          const absolute = AbsolutePath.make(target.absolute);
+          yield* permission.assert({
+            action: name,
+            resources: [resource],
+            save: ["*"],
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source
+          });
+          const content = yield* reader.read(absolute, resource, { offset: input.offset, limit: input.limit }).pipe(Effect.catchIf((error) => error instanceof exports_environment.NotFound, () => missing(input.path, target.absolute)));
+          yield* Effect.gen(function* () {
+            if (target.externalDirectory !== undefined)
+              return;
+            const resolved = yield* fs.resolve(target.absolute);
+            const root = yield* fs.resolve(location.directory);
+            const discovered = yield* fs.up({
+              targets: [FILENAME],
+              start: content.type === "list-page" ? resolved : dirname(resolved),
+              stop: root
+            });
+            const candidates = (yield* Effect.forEach(discovered, fs.resolve)).filter((file) => dirname(file) !== root);
+            if (candidates.length === 0)
+              return;
+            yield* sessionInstructions.load({ sessionID: context.sessionID, paths: candidates });
+          }).pipe(Effect.catch(() => Effect.void), Effect.catchDefect(() => Effect.void));
+          if (content.type === "file" && content.encoding === "base64" && !SUPPORTED_MEDIA_MIMES.has(content.mime))
+            return yield* Effect.fail(new exports_read_filesystem.BinaryFileError({ resource }));
+          return content;
+        }).pipe(Effect.map((output) => ({
+          output,
+          content: toModelContent(input.path, input.offset, output),
+          metadata: { truncated: output.type === "file" ? false : output.truncated }
+        })), Effect.mapError((error) => {
+          if (error instanceof ToolFailure)
+            return error;
+          const message = error instanceof exports_read_filesystem.BinaryFileError || error instanceof exports_read_filesystem.MediaIngestLimitError || error instanceof exports_read_filesystem.OffsetOutOfRangeError || error instanceof exports_read_filesystem.PathKindError ? error.message : `Unable to read ${input.path}`;
+          return new ToolFailure({ message, error });
+        }));
+      }
+    })).pipe(Effect.orDie);
+    const missing = Effect.fn("ReadTool.missing")(function* (input, absolute) {
+      const base = basename(input).toLowerCase();
+      const suggestions = yield* fs.readDirectory(dirname(absolute)).pipe(Effect.map((entries) => entries.filter((entry) => {
+        const candidate = entry.toLowerCase();
+        return candidate.includes(base) || base.includes(candidate);
+      }).map((entry) => join(dirname(input), entry)).slice(0, 3)), Effect.catch(() => Effect.succeed([])));
+      const message = suggestions.length === 0 ? `File not found: ${input}` : `File not found: ${input}
+
+Did you mean one of these?
+${suggestions.join(`
+`)}`;
+      return yield* new ToolFailure({ message });
+    });
+  })
+};
+var toModelContent = (path, offset, output) => {
+  if (output.type === "file" && output.encoding === "base64")
+    return [
+      { type: "text", text: output.mime === "application/pdf" ? "PDF read successfully" : "Image read successfully" },
+      {
+        type: "file",
+        uri: `data:${output.mime};base64,${output.content}`,
+        mime: output.mime,
+        name: path
+      }
+    ];
+  if (output.type === "list-page") {
+    const start2 = offset ?? 1;
+    const content2 = [
+      output.entries.length === 0 ? `Read directory ${path}, 0 entries` : `Read directory ${path}, entries ${start2}-${start2 + output.entries.length - 1}`
+    ];
+    output.entries.forEach((entry) => content2.push(entry.path));
+    if (output.truncated && output.next !== undefined)
+      content2.push(`[Output truncated. Continue reading with offset: ${output.next}]`);
+    return content2.join(`
+`);
+  }
+  const start = output.type === "text-page" ? output.offset : 1;
+  const lines = output.content === "" ? [] : output.content.replace(/\n$/, "").split(`
+`);
+  const content = [
+    lines.length === 0 ? `Read file ${path}, 0 lines` : `Read file ${path}, lines ${start}-${start + lines.length - 1}`
+  ];
+  lines.forEach((line, index) => content.push(`${start + index}: ${line}`));
+  if (output.type === "text-page" && output.truncated && output.next !== undefined)
+    content.push(`[Output truncated. Continue reading with offset: ${output.next}]`);
+  return content.join(`
+`);
+};
+
+export { name, Input, Plugin, toModelContent, exports_read };

package/dist/chunks/location-mutation-9m1tawx7.js

@@ -0,0 +1,120 @@
+import {
+  exports_state
+} from "./location-mutation-wt193r4g.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/websearch.ts
+var exports_websearch = {};
+__export(exports_websearch, {
+  node: () => node,
+  WebSearch: () => exports_websearch,
+  Service: () => Service,
+  Result: () => Result,
+  Response: () => Response,
+  RequestError: () => RequestError,
+  ProviderRequiredError: () => ProviderRequiredError,
+  ProviderNotFoundError: () => ProviderNotFoundError,
+  Provider: () => Provider,
+  Input: () => Input,
+  ID: () => ID,
+  Event: () => Event,
+  DisabledError: () => DisabledError
+});
+import { WebSearch } from "@opencode-ai/schema/websearch";
+import { Context, Effect, Layer, Schema } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Event } from "@opencode-ai/schema/websearch";
+var ID = WebSearch.ID;
+var Provider = WebSearch.Provider;
+var Input = WebSearch.Input;
+var Result = WebSearch.Result;
+var Response = WebSearch.Response;
+
+class ProviderRequiredError extends Schema.TaggedErrorClass()("WebSearch.ProviderRequired", {}) {
+}
+
+class ProviderNotFoundError extends Schema.TaggedErrorClass()("WebSearch.ProviderNotFound", {
+  providerID: ID
+}) {
+}
+
+class DisabledError extends Schema.TaggedErrorClass()("WebSearch.Disabled", {}) {
+}
+
+class RequestError extends Schema.TaggedErrorClass()("WebSearch.Request", {
+  providerID: ID,
+  cause: Schema.Defect()
+}) {
+}
+
+class Service extends Context.Service()("@opencode/WebSearch") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const decodeResults = Schema.decodeUnknownEffect(Schema.Array(Result));
+  const state = exports_state.create({
+    initial: () => ({ providers: new Map }),
+    draft: (draft) => ({
+      add: (provider) => draft.providers.set(provider.id, provider),
+      default: {
+        get: () => draft.selection,
+        set: (selection) => draft.selection = selection
+      }
+    }),
+    finalize: () => bus.publish(WebSearch.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  const requireProvider = (providers, providerID) => {
+    const provider = providers.get(providerID);
+    return provider ? Effect.succeed(provider) : Effect.fail(new ProviderNotFoundError({ providerID }));
+  };
+  const defaultProvider = Effect.fn("WebSearch.default")(function* () {
+    const data = state.get();
+    if (data.selection === false)
+      return yield* new DisabledError;
+    if (data.selection === "random") {
+      const providers = Array.from(data.providers.values());
+      return providers[Math.floor(Math.random() * providers.length)];
+    }
+    return data.selection ? data.providers.get(data.selection) : undefined;
+  });
+  const resolve = Effect.fn("WebSearch.resolve")(function* (input) {
+    const providers = state.get().providers;
+    if (input.providerID)
+      return yield* requireProvider(providers, input.providerID);
+    const provider = yield* defaultProvider();
+    if (!provider)
+      return yield* new ProviderRequiredError;
+    return provider;
+  });
+  return Service.of({
+    transform: state.transform,
+    reload: state.reload,
+    providers: Effect.fn("WebSearch.providers")(function* () {
+      return Array.from(state.get().providers.values(), (provider) => ({
+        id: provider.id,
+        name: provider.name
+      })).toSorted((a, b) => a.name.localeCompare(b.name));
+    }),
+    default: Effect.fn("WebSearch.defaultInfo")(function* () {
+      const provider = yield* defaultProvider();
+      return provider && { id: provider.id, name: provider.name };
+    }),
+    query: Effect.fn("WebSearch.query")(function* (input) {
+      const provider = yield* resolve(input);
+      const results = yield* provider.execute({ query: input.query }).pipe(Effect.flatMap(decodeResults), Effect.mapError((cause) => new RequestError({ providerID: provider.id, cause })));
+      return new Response({ providerID: provider.id, results });
+    })
+  });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_bus.node]
+});
+
+export { ID, Provider, Input, Result, Response, ProviderRequiredError, ProviderNotFoundError, DisabledError, RequestError, Service, node, exports_websearch, Event };