@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-0w91d2d0.js

@@ -0,0 +1,72 @@
+import {
+  exports_agent
+} from "./permission-0c101nc9.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/plan.ts
+var exports_plan = {};
+__export(exports_plan, {
+  Plugin: () => Plugin,
+  PlanPlugin: () => exports_plan
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Stream } from "effect";
+var plan = exports_agent.ID.make("plan");
+var enter = `<system-reminder>
+You are in Plan mode. You are not allowed to edit or create files, and you may not ask a subagent to do that either.
+
+You are in Plan mode until the user switches agents. Plan mode is not changed by user intent, tone, or imperative language. If the user asks you to change files, do not edit. Tell them they need to switch agents.
+</system-reminder>`;
+var leave = `<system-reminder>
+You are NO LONGER in Plan mode. The previous Plan restrictions no longer apply. Any Plan mode instructions from earlier in this conversation are no longer active.
+</system-reminder>`;
+var Plugin = define({
+  id: "opencode.plan",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.agent.transform((draft) => {
+      draft.update(plan, (item) => {
+        item.name = exports_agent.Name.make("Plan");
+        item.description = "Read-only agent for exploring the codebase and planning work before implementation.";
+        item.mode = "primary";
+        item.permissions.push({ action: "question", resource: "*", effect: "allow" });
+      });
+    });
+    yield* ctx.tool.hook("execute.before", (event) => {
+      if (event.agent !== plan)
+        return Effect.void;
+      if (event.tool !== "edit" && event.tool !== "write" && event.tool !== "patch")
+        return Effect.void;
+      return new ToolFailure({
+        message: `Cannot use ${event.tool} in Plan mode. You are in a read-only mode and must not modify files.`
+      });
+    });
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "session.created" || event.type === "session.agent.selected"), Stream.runForEach((event) => {
+      const text = reminder(event);
+      if (!text)
+        return Effect.void;
+      return ctx.session.synthetic({
+        sessionID: event.data.sessionID,
+        text,
+        resume: false
+      }).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to inject Plan mode reminder", { sessionID: event.data.sessionID, cause })));
+    }), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+function reminder(event) {
+  if (event.type === "session.created") {
+    if (event.data.agent !== plan)
+      return;
+    return enter;
+  }
+  if (event.data.agent === event.data.previous)
+    return;
+  if (event.data.agent === plan)
+    return enter;
+  if (event.data.previous === plan)
+    return leave;
+}
+
+export { Plugin, exports_plan };

package/dist/chunks/permission-0zr7btsm.js

@@ -0,0 +1,203 @@
+import {
+  fileDiff
+} from "./permission-c77ad0vh.js";
+import {
+  exports_file_mutation
+} from "./permission-2nkse5ac.js";
+import {
+  exports_formatter
+} from "./permission-w4678h5q.js";
+import {
+  exports_environment1 as exports_environment
+} from "./permission-z5ystmxz.js";
+import {
+  exports_location_mutation
+} from "./permission-a2yyszsy.js";
+import {
+  exports_permission
+} from "./permission-qa8qg9jd.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/tool/plugin/edit.ts
+var exports_edit = {};
+__export(exports_edit, {
+  name: () => name,
+  Plugin: () => Plugin,
+  Output: () => Output,
+  Input: () => Input,
+  EditTool: () => exports_edit
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { FileDiff } from "@opencode-ai/schema/file-diff";
+import { Bom } from "@opencode-ai/util/bom";
+import { Effect, Schema } from "effect";
+import path from "path";
+var name = "edit";
+var Input = Schema.Struct({
+  path: Schema.String.annotate({
+    description: "File to edit"
+  }),
+  oldString: Schema.String.annotate({ description: "Exact text to find and replace" }),
+  newString: Schema.String.annotate({ description: "Text to replace oldString with (must differ from oldString)" }),
+  replaceAll: Schema.optionalKey(Schema.Boolean).annotate({
+    description: "Whether to replace every occurrence of oldString. When false, oldString must match exactly once. Defaults to false."
+  })
+});
+var Output = Schema.Struct({
+  files: Schema.Array(FileDiff.Info),
+  replacements: Schema.Number
+});
+var crlf = `\r
+`;
+var normalizeForMatch = (value) => value.replace(/[‘’‚‛]/g, "'").replace(/[“”„‟]/g, '"').replace(/[‐‑‒–—―−]/g, "-").replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
+var findOccurrences = (content, search) => {
+  const result = [];
+  let offset = 0;
+  while ((offset = content.indexOf(search, offset)) !== -1) {
+    result.push({ start: offset, end: offset + search.length });
+    offset += search.length;
+  }
+  return result;
+};
+var findLineOccurrences = (content, search) => {
+  const trailingNewline = search.endsWith(`
+`);
+  const expected = search.split(`
+`);
+  if (trailingNewline)
+    expected.pop();
+  const lines = [...content.matchAll(/[^\n]*(?:\n|$)/g)].filter((match) => match[0] !== "").map((match) => {
+    const newline = match[0].endsWith(`
+`);
+    const text = newline ? match[0].slice(0, -1) : match[0];
+    return {
+      start: match.index,
+      end: match.index + match[0].length,
+      text,
+      contentEnd: match.index + text.length - (text.endsWith("\r") ? 1 : 0),
+      newline
+    };
+  });
+  const candidates = lines.flatMap((line, index) => {
+    const actual = lines.slice(index, index + expected.length);
+    if (actual.length !== expected.length)
+      return [];
+    if (!actual.every((item, lineIndex) => normalizeForMatch(item.text.trimEnd()) === normalizeForMatch(expected[lineIndex].trimEnd())))
+      return [];
+    const last = actual.at(-1);
+    if (trailingNewline && !last.newline)
+      return [];
+    return [{ start: line.start, end: trailingNewline ? last.end : last.contentEnd }];
+  });
+  return candidates.reduce((result, candidate) => {
+    if (result.some((match) => match.end > candidate.start && match.start < candidate.end))
+      return result;
+    result.push(candidate);
+    return result;
+  }, []);
+};
+var Plugin = {
+  id: "opencode.tool.edit",
+  effect: Effect.fn("EditTool.Plugin")(function* (ctx) {
+    const mutation = yield* exports_location_mutation.Service;
+    const fileMutation = yield* exports_file_mutation.Service;
+    const environment = yield* exports_environment.Service;
+    const formatter = yield* exports_formatter.Service;
+    const location = yield* exports_location.Service;
+    const permission = yield* exports_permission.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false, permission: "edit" },
+      description: "Edit the contents of a file by finding and replacing exact text. When editing text from Read output, preserve the exact indentation (tabs or spaces) and omit the line-number prefix, such as `1: `. Never include the prefix in oldString or newString. The edit fails if oldString is not found. By default, oldString must identify a UNIQUE location. Multiple matches FAIL unless replaceAll is true. Add more surrounding context to disambiguate, or set replaceAll to true to replace every occurrence. Use replaceAll when the change should apply to every occurrence, such as renaming a variable.",
+      input: Input,
+      output: Output,
+      execute: (input, context) => {
+        return Effect.gen(function* () {
+          const permissionSource = {
+            type: "tool",
+            messageID: context.messageID,
+            id: context.id
+          };
+          if (input.oldString === input.newString) {
+            return yield* new ToolFailure({
+              message: "No changes to apply: oldString and newString are identical."
+            });
+          }
+          if (input.oldString === "") {
+            return yield* new ToolFailure({
+              message: "oldString must not be empty. Use write to create or overwrite a file."
+            });
+          }
+          const target = yield* mutation.resolve({ path: input.path, kind: "file" });
+          const external = target.externalDirectory;
+          if (external) {
+            yield* permission.assert({
+              ...exports_location_mutation.externalDirectoryPermission(external),
+              sessionID: context.sessionID,
+              agent: context.agent,
+              source: permissionSource
+            });
+          }
+          const original = yield* exports_file_mutation.readText(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `File not found: ${input.path}` }))), Effect.catchTag("Environment.WrongKind", (error) => error.actual === "directory" ? Effect.fail(new ToolFailure({ message: `Path is a directory, not a file: ${input.path}` })) : Effect.fail(new ToolFailure({ message: `Unable to edit ${input.path}`, error }))));
+          const source = original.text;
+          const ending = source.includes(crlf) ? crlf : `
+`;
+          const oldString = input.oldString.replaceAll(crlf, `
+`).replaceAll(`
+`, ending);
+          const newString = input.newString.replaceAll(crlf, `
+`).replaceAll(`
+`, ending);
+          const exact = findOccurrences(source, oldString);
+          const unicode = exact.length > 0 ? [] : findOccurrences(normalizeForMatch(source), normalizeForMatch(oldString));
+          const trailing = exact.length > 0 || unicode.length > 0 ? [] : findLineOccurrences(source, oldString);
+          const matches = exact.length > 0 ? exact : unicode.length > 0 ? unicode : trailing;
+          const replacements = matches.length;
+          const replaced = (input.replaceAll === true ? matches : matches.slice(0, 1)).toReversed().reduce((content, match) => `${content.slice(0, match.start)}${newString}${content.slice(match.end)}`, source);
+          const preview = replacements > 0 && (replacements === 1 || input.replaceAll === true) ? fileDiff(target.resource, source, replaced) : undefined;
+          yield* permission.assert({
+            action: "edit",
+            resources: [target.resource],
+            save: ["*"],
+            metadata: preview ? { files: [preview] } : undefined,
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source: permissionSource
+          });
+          if (replacements === 0) {
+            return yield* new ToolFailure({
+              message: `Could not find oldString in ${input.path}. It must match exactly, including whitespace and indentation.`
+            });
+          }
+          if (replacements > 1 && input.replaceAll !== true) {
+            return yield* new ToolFailure({
+              message: `Found ${replacements} matches for oldString, but expected exactly one. Add more surrounding context to make oldString unique, or set replaceAll to true to replace every occurrence.`
+            });
+          }
+          const replacementBom = replaced.startsWith("\uFEFF");
+          const result = yield* fileMutation.write({
+            target,
+            content: Bom.join(replaced, original.bom || replacementBom)
+          });
+          const bom = original.bom || replacementBom;
+          const formatted = (yield* formatter.file(target.absolute)) ? yield* exports_file_mutation.syncTextBom(environment.files, target.absolute, bom) : (yield* exports_file_mutation.readText(environment.files, target.absolute)).text;
+          return {
+            files: [fileDiff(result.resource, source, formatted)],
+            replacements
+          };
+        }).pipe(fileMutation.withLock([path.resolve(location.directory, input.path)]), Effect.map((output) => ({
+          output,
+          content: `Edited ${output.files[0]?.file} (${output.replacements} replacement${output.replacements === 1 ? "" : "s"})`,
+          metadata: { files: output.files }
+        })), Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to edit ${input.path}`, error })));
+      }
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name, Input, Output, Plugin, exports_edit };

package/dist/chunks/permission-0zz82cjq.js

@@ -0,0 +1,17 @@
+// src/plugin/provider/factory.ts
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect } from "effect";
+function createProviderPlugin(input) {
+  return define({
+    id: input.id,
+    effect: Effect.fn(function* (ctx) {
+      yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+        if (evt.package !== input.package)
+          return;
+        evt.sdk = yield* Effect.promise(() => input.load(evt.options));
+      }));
+    })
+  });
+}
+
+export { createProviderPlugin };

package/dist/chunks/permission-10xtr3be.js

@@ -0,0 +1,34 @@
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+import {
+  __require
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/provider/cerebras.ts
+import { Effect } from "effect";
+import { define } from "@opencode-ai/plugin/effect/plugin";
+var CerebrasPlugin = define({
+  id: "opencode.provider.cerebras",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!exports_provider.isAISDK(item.provider.package))
+          continue;
+        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/cerebras")
+          continue;
+        evt.provider.update(item.provider.id, (provider) => {
+          provider.headers = { ...provider.headers, "X-Cerebras-3rd-Party-Integration": "opencode" };
+        });
+      }
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.package !== "@ai-sdk/cerebras")
+        return;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/cerebras"));
+      evt.sdk = mod.createCerebras(evt.options);
+    }));
+  })
+});
+
+export { CerebrasPlugin };

package/dist/chunks/permission-14dbm5wf.js

@@ -0,0 +1,90 @@
+import {
+  exports_model_resolver
+} from "./permission-chtvf7xd.js";
+import {
+  exports_catalog
+} from "./permission-849eva8b.js";
+import {
+  exports_schema
+} from "./permission-y8rs54ne.js";
+import {
+  ID,
+  Ref
+} from "./permission-xfd1xnk3.js";
+import {
+  exports_provider
+} from "./permission-d6vvk673.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/runner/model.ts
+var exports_model = {};
+__export(exports_model, {
+  resolved: () => resolved,
+  node: () => node,
+  VariantUnavailableError: () => VariantUnavailableError,
+  UnsupportedPackageError: () => UnsupportedPackageError,
+  UnresolvedProviderVariablesError: () => UnresolvedProviderVariablesError,
+  SessionRunnerModel: () => exports_model,
+  Service: () => Service,
+  ModelUnavailableError: () => ModelUnavailableError,
+  ModelNotSelectedError: () => ModelNotSelectedError
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+class ModelNotSelectedError extends Schema.TaggedErrorClass()("SessionRunnerModel.ModelNotSelectedError", { sessionID: exports_schema.ID }) {
+  get message() {
+    return `No model is available for session ${this.sessionID}`;
+  }
+}
+
+class ModelUnavailableError extends Schema.TaggedErrorClass()("SessionRunnerModel.ModelUnavailableError", { providerID: exports_provider.ID, modelID: ID }) {
+  get message() {
+    if (this.providerID === "azure-cognitive-services")
+      return `Model unavailable: ${this.providerID}/${this.modelID}. This provider has been deprecated; use azure/${this.modelID} instead.`;
+    if (this.providerID === "google-vertex-anthropic")
+      return `Model unavailable: ${this.providerID}/${this.modelID}. This provider has been deprecated; use google-vertex/${this.modelID} instead.`;
+    return `Model unavailable: ${this.providerID}/${this.modelID}`;
+  }
+}
+var VariantUnavailableError = exports_model_resolver.VariantUnavailableError;
+var UnsupportedPackageError = exports_model_resolver.UnsupportedPackageError;
+var UnresolvedProviderVariablesError = exports_model_resolver.UnresolvedProviderVariablesError;
+
+class Service extends Context.Service()("@opencode/SessionRunnerModel") {
+}
+var resolved = (model, options) => ({
+  model,
+  ref: Ref.make({
+    id: ID.make(model.id),
+    providerID: exports_provider.ID.make(model.provider),
+    ...options.variant === undefined ? {} : { variant: options.variant }
+  }),
+  capabilities: options.capabilities,
+  cost: options.cost
+});
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const catalog = yield* exports_catalog.Service;
+  const resolver = yield* exports_model_resolver.Service;
+  return Service.of({
+    resolve: Effect.fn("SessionRunnerModel.resolve")(function* (session) {
+      if (!session.model) {
+        const resolved2 = yield* resolver.resolve();
+        if (resolved2)
+          return resolved2;
+        return yield* new ModelNotSelectedError({ sessionID: session.id });
+      }
+      const selected = (yield* catalog.model.available()).find((model) => model.providerID === session.model?.providerID && model.id === session.model.id);
+      if (!selected)
+        return yield* new ModelUnavailableError({
+          providerID: session.model.providerID,
+          modelID: session.model.id
+        });
+      return yield* resolver.resolveModel(selected, session.model.variant);
+    })
+  });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_catalog.node, exports_model_resolver.node] });
+
+export { ModelNotSelectedError, ModelUnavailableError, VariantUnavailableError, UnsupportedPackageError, UnresolvedProviderVariablesError, Service, resolved, node, exports_model };

package/dist/chunks/permission-18pv8fg3.js

@@ -0,0 +1,98 @@
+import {
+  PositiveInt
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/v1/config/provider.ts
+var exports_provider = {};
+__export(exports_provider, {
+  ModelStatus: () => ModelStatus,
+  Model: () => Model,
+  Info: () => Info,
+  ConfigProviderV1: () => exports_provider
+});
+import { Schema } from "effect";
+var ModelStatus = Schema.Literals(["alpha", "beta", "deprecated", "active"]);
+var Model = Schema.Struct({
+  id: Schema.optional(Schema.String),
+  name: Schema.optional(Schema.String),
+  family: Schema.optional(Schema.String),
+  release_date: Schema.optional(Schema.String),
+  attachment: Schema.optional(Schema.Boolean),
+  reasoning: Schema.optional(Schema.Boolean),
+  temperature: Schema.optional(Schema.Boolean),
+  tool_call: Schema.optional(Schema.Boolean),
+  interleaved: Schema.optional(Schema.Union([
+    Schema.Boolean,
+    Schema.String,
+    Schema.Struct({
+      field: Schema.String
+    })
+  ])),
+  cost: Schema.optional(Schema.Struct({
+    input: Schema.Finite,
+    output: Schema.Finite,
+    cache_read: Schema.optional(Schema.Finite),
+    cache_write: Schema.optional(Schema.Finite),
+    context_over_200k: Schema.optional(Schema.Struct({
+      input: Schema.Finite,
+      output: Schema.Finite,
+      cache_read: Schema.optional(Schema.Finite),
+      cache_write: Schema.optional(Schema.Finite)
+    }))
+  })),
+  limit: Schema.optional(Schema.Struct({
+    context: Schema.Finite,
+    input: Schema.optional(Schema.Finite),
+    output: Schema.Finite
+  })),
+  modalities: Schema.optional(Schema.Struct({
+    input: Schema.optional(Schema.mutable(Schema.Array(Schema.Literals(["text", "audio", "image", "video", "pdf"])))),
+    output: Schema.optional(Schema.mutable(Schema.Array(Schema.Literals(["text", "audio", "image", "video", "pdf"]))))
+  })),
+  experimental: Schema.optional(Schema.Boolean),
+  status: Schema.optional(ModelStatus),
+  provider: Schema.optional(Schema.Struct({ npm: Schema.optional(Schema.String), api: Schema.optional(Schema.String) })),
+  options: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+  variants: Schema.optional(Schema.Record(Schema.String, Schema.StructWithRest(Schema.Struct({
+    disabled: Schema.optional(Schema.Boolean).annotate({ description: "Disable this variant for the model" })
+  }), [Schema.Record(Schema.String, Schema.Any)])).annotate({ description: "Variant-specific configuration" }))
+});
+var Info = Schema.Struct({
+  api: Schema.optional(Schema.String),
+  name: Schema.optional(Schema.String),
+  env: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+  id: Schema.optional(Schema.String),
+  npm: Schema.optional(Schema.String),
+  whitelist: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+  blacklist: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+  options: Schema.optional(Schema.StructWithRest(Schema.Struct({
+    apiKey: Schema.optional(Schema.String),
+    baseURL: Schema.optional(Schema.String),
+    enterpriseUrl: Schema.optional(Schema.String).annotate({
+      description: "GitHub Enterprise URL for copilot authentication"
+    }),
+    setCacheKey: Schema.optional(Schema.Boolean).annotate({
+      description: "Enable promptCacheKey for this provider (default false)"
+    }),
+    timeout: Schema.optional(Schema.Union([PositiveInt, Schema.Literal(false)]).annotate({
+      description: "Timeout in milliseconds for full requests to this provider. Set to false to disable timeout."
+    })).annotate({
+      description: "Timeout in milliseconds for full requests to this provider. Set to false to disable timeout."
+    }),
+    headerTimeout: Schema.optional(Schema.Union([PositiveInt, Schema.Literal(false)]).annotate({
+      description: "Timeout in milliseconds to wait for response headers. Provider integrations may set defaults. Set to false to disable timeout."
+    })).annotate({
+      description: "Timeout in milliseconds to wait for response headers. Provider integrations may set defaults. Set to false to disable timeout."
+    }),
+    chunkTimeout: Schema.optional(PositiveInt).annotate({
+      description: "Timeout in milliseconds between streamed SSE chunks for this provider. If no chunk arrives within this window, the request is aborted."
+    })
+  }), [Schema.Record(Schema.String, Schema.Any)])),
+  models: Schema.optional(Schema.Record(Schema.String, Model))
+}).annotate({ identifier: "ProviderConfig" });
+
+export { ModelStatus, Model, Info, exports_provider };

package/dist/chunks/permission-1c00jchy.js

@@ -0,0 +1,64 @@
+import {
+  collectBoundedResponseBody
+} from "./permission-jve7t217.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/plugin/websearch/mcp.ts
+var exports_mcp = {};
+__export(exports_mcp, {
+  parseResponse: () => parseResponse,
+  call: () => call,
+  WebSearchMcp: () => exports_mcp,
+  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES
+});
+import { Duration, Effect, Schema } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+var MAX_RESPONSE_BYTES = 256 * 1024;
+var parseResponse = (body, result) => {
+  const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ result })));
+  const parse = (payload) => {
+    const trimmed = payload.trim();
+    if (!trimmed.startsWith("{"))
+      return Effect.succeed(undefined);
+    return decode(trimmed).pipe(Effect.map((response) => response.result));
+  };
+  return Effect.gen(function* () {
+    const trimmed = body.trim();
+    const direct = trimmed ? yield* parse(trimmed) : undefined;
+    if (direct)
+      return direct;
+    for (const line of body.split(`
+`)) {
+      if (!line.startsWith("data: "))
+        continue;
+      const data = yield* parse(line.substring(6));
+      if (data)
+        return data;
+    }
+  });
+};
+var call = (http, url, tool, schema, value, headers = {}) => Effect.gen(function* () {
+  const request = yield* HttpClientRequest.post(url).pipe(HttpClientRequest.accept("application/json, text/event-stream"), HttpClientRequest.setHeaders(headers), HttpClientRequest.schemaBodyJson(Schema.Struct({
+    jsonrpc: Schema.Literal("2.0"),
+    id: Schema.Literal(1),
+    method: Schema.Literal("tools/call"),
+    params: Schema.Struct({ name: Schema.String, arguments: schema.input })
+  }))({
+    jsonrpc: "2.0",
+    id: 1,
+    method: "tools/call",
+    params: { name: tool, arguments: value }
+  }));
+  return yield* Effect.gen(function* () {
+    const response = yield* HttpClient.filterStatusOk(http).execute(request);
+    const body = yield* collectBoundedResponseBody(response, MAX_RESPONSE_BYTES, () => new Error(`${tool} response exceeded ${MAX_RESPONSE_BYTES} bytes`));
+    return yield* parseResponse(body.toString("utf8"), schema.output);
+  }).pipe(Effect.timeoutOrElse({
+    duration: Duration.seconds(25),
+    orElse: () => Effect.fail(new Error(`${tool} request timed out`))
+  }));
+});
+
+export { MAX_RESPONSE_BYTES, parseResponse, call, exports_mcp };

package/dist/chunks/permission-1cxqkg6x.js

@@ -0,0 +1,63 @@
+import {
+  exports_instructions
+} from "./permission-q4r4pzs4.js";
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/instructions/builtins.ts
+var exports_builtins = {};
+__export(exports_builtins, {
+  node: () => node,
+  Service: () => Service,
+  InstructionBuiltIns: () => exports_builtins
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, DateTime, Effect, Layer, Schema } from "effect";
+import { Global } from "@opencode-ai/util/global";
+class Service extends Context.Service()("@opencode/InstructionBuiltIns") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const global = yield* Global.Service;
+  const location = yield* exports_location.Service;
+  return Service.of({
+    load: (sessionID) => Effect.succeed(exports_instructions.combine([
+      exports_instructions.make({
+        key: exports_instructions.Key.make("core/environment"),
+        codec: Schema.toCodecJson(Schema.String),
+        read: Effect.sync(() => [
+          "<env>",
+          `  Current conversation session ID: ${sessionID}`,
+          `  Working directory: ${location.directory}`,
+          `  Workspace root folder: ${location.project.directory}`,
+          `  Is directory a git repo: ${location.vcs?.type === "git" ? "yes" : "no"}`,
+          `  Platform: ${process.platform}`,
+          `  Use ${global.tmp} for temporary work outside the workspace; it already exists and is pre-approved for external directory access.`,
+          "</env>"
+        ].join(`
+`)),
+        render: {
+          initial: (environment) => ["Here is some useful information about the environment you are running in:", environment].join(`
+`),
+          changed: (_previous, environment) => ["The environment you are running in is now:", environment].join(`
+`)
+        }
+      }),
+      exports_instructions.make({
+        key: exports_instructions.Key.make("core/date"),
+        codec: Schema.toCodecJson(Schema.String),
+        read: DateTime.nowAsDate.pipe(Effect.map((date) => date.toDateString())),
+        render: {
+          initial: (date) => `Today's date: ${date}`,
+          changed: (_previous, date) => `Today's date is now: ${date}`
+        }
+      })
+    ]))
+  });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [Global.node, exports_location.node] });
+
+export { Service, node, exports_builtins };