@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-2v08kgv1.js

@@ -0,0 +1,213 @@
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  optional2,
+  statics2
+} from "./repository-922hggd3.js";
+import {
+  Ref2,
+  Service66,
+  node70
+} from "./repository-6wjjjhy6.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/rpc.ts
+var exports_rpc = {};
+__export(exports_rpc, {
+  Rpc: () => exports_rpc,
+  Service: () => Service15,
+  define: () => define2,
+  node: () => node19
+});
+import { define as define2 } from "@opencode/schema/rpc";
+import { Event } from "@opencode/schema/event";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Deferred, Effect, JsonSchema, Layer, Schema, SchemaRepresentation, Stream } from "effect";
+class Service15 extends Context.Service()("@opencode/Rpc") {
+}
+
+class DeclaredError extends Error {
+  type;
+  data;
+  constructor(type, message, data) {
+    super(message);
+    this.type = type;
+    this.data = data;
+  }
+}
+var layer = Layer.effect(Service15, Effect.gen(function* () {
+  const bus = yield* Service78;
+  const location = yield* Service66;
+  const ref = Ref2.make({ directory: location.directory, workspaceID: location.workspaceID });
+  const closed = yield* Deferred.make();
+  const callContext = {
+    error: (type, message, data) => new DeclaredError(type, message, data)
+  };
+  const registrations = new Map;
+  const definitions = new WeakMap;
+  const eventsFor = (definition) => {
+    const existing = definitions.get(definition);
+    if (existing)
+      return existing;
+    const events = new Map(Object.entries(definition.events).map(([name, event]) => [
+      name,
+      { event, definition: eventDefinition(definition, name) }
+    ]));
+    definitions.set(definition, events);
+    return events;
+  };
+  const register = Effect.fn("Rpc.register")(function* (definition, handlers) {
+    const entry = { definition, handlers };
+    const dispose = Effect.sync(() => {
+      const remaining = (registrations.get(definition.id) ?? []).filter((candidate) => candidate !== entry);
+      if (remaining.length === 0) {
+        registrations.delete(definition.id);
+        return;
+      }
+      registrations.set(definition.id, remaining);
+    });
+    yield* Effect.acquireRelease(Effect.sync(() => registrations.set(definition.id, [...registrations.get(definition.id) ?? [], entry])), () => dispose);
+    const events = eventsFor(definition);
+    return {
+      dispose,
+      events: {
+        emit: Effect.fn("Rpc.emit")(function* (...args) {
+          const registered = events.get(args[0]);
+          if (!registered)
+            return yield* Effect.fail(new Error(`Unknown RPC event: ${definition.id}.${args[0]}`));
+          const event = registered.event;
+          const data = yield* encode(event.schema, args[1]);
+          return yield* bus.publish(registered.definition, data, {
+            location: Ref2.make({ directory: ref.directory, workspaceID: ref.workspaceID })
+          }).pipe(Effect.asVoid);
+        })
+      }
+    };
+  });
+  const call = Effect.fn("Rpc.call")(function* (rpcID, name, input) {
+    if (yield* Deferred.isDone(closed))
+      return yield* Effect.fail(failure("rpc.unavailable", `RPC is unavailable: ${rpcID}`));
+    const entry = registrations.get(rpcID)?.at(-1);
+    if (!entry)
+      return yield* Effect.fail(failure("rpc.unavailable", `RPC is unavailable: ${rpcID}`));
+    if (!Object.hasOwn(entry.definition.methods, name) || !Object.hasOwn(entry.handlers, name))
+      return yield* Effect.fail(failure("rpc.method_not_found", `Unknown RPC method: ${rpcID}.${name}`));
+    const method = entry.definition.methods[name];
+    const handler = entry.handlers[name];
+    const parsed = yield* parse(method.input, input).pipe(Effect.mapError((error) => failure("rpc.invalid_input", errorMessage(error, "Invalid RPC input"))));
+    const result = yield* Effect.suspend(() => {
+      const execution = Reflect.apply(handler, undefined, [parsed, callContext]);
+      return execution;
+    }).pipe(Effect.catch((error) => encodeError(method, error)), Effect.catchDefect((defect) => Effect.logError("rpc handler failed", { rpc: rpcID, method: name, defect }).pipe(Effect.andThen(Effect.fail(failure("rpc.internal", "RPC call failed"))))), Effect.raceFirst(Deferred.await(closed).pipe(Effect.andThen(Effect.fail(failure("rpc.unavailable", `RPC is unavailable: ${rpcID}`))))));
+    return yield* encode(method.output, result).pipe(Effect.mapError((error) => failure("rpc.invalid_output", errorMessage(error, "Invalid RPC output"))));
+  });
+  const client = (definition) => {
+    const events = eventsFor(definition);
+    const methods = Object.fromEntries(Object.entries(definition.methods).map(([name, method]) => [
+      name,
+      (input) => call(definition.id, name, input).pipe(Effect.catch((error) => decodeError(method, error)), Effect.flatMap((value) => read(method.output, value).pipe(Effect.catch((cause) => Effect.die(cause)))))
+    ]));
+    return {
+      ...methods,
+      events: {
+        subscribe: (name) => {
+          const registered = events.get(name);
+          if (!registered)
+            return Stream.fail(new Error(`Unknown RPC event: ${definition.id}.${name}`));
+          return bus.subscribe(registered.definition).pipe(Stream.provideService(Service66, location), Stream.mapEffect((payload) => logicalEvent(definition, name, payload, ref)));
+        }
+      }
+    };
+  };
+  return Service15.of({ register, call, client, close: Deferred.succeed(closed, undefined).pipe(Effect.asVoid) });
+}));
+var node19 = makeLocationNode({ service: Service15, layer, deps: [node83, node70] });
+var fields = {
+  id: Event.ID,
+  created: Schema.Finite,
+  metadata: optional2(Schema.Record(Schema.String, Schema.Unknown)),
+  location: optional2(Ref2)
+};
+var EventData = Schema.Record(Schema.String, Schema.Unknown);
+var jsonSchemas = new WeakMap;
+function eventType(definition, name) {
+  return `rpc.${definition.id}.${name}`;
+}
+function eventDefinition(definition, name) {
+  const type = eventType(definition, name);
+  const data = EventData;
+  return Schema.Struct({ ...fields, type: Schema.Literal(type), data }).pipe(statics2(() => ({ type, durability: "ephemeral", durable: undefined, data })));
+}
+function parse(schema, value) {
+  if (Schema.isSchema(schema))
+    return Schema.decodeUnknownEffect(schema)(value);
+  if (isStandardSchema(schema)) {
+    return Effect.gen(function* () {
+      const parsed = yield* Effect.try({ try: () => schema["~standard"].validate(value), catch: (cause) => cause });
+      const result = parsed instanceof Promise ? yield* Effect.tryPromise({ try: () => parsed, catch: (cause) => cause }) : parsed;
+      if (result.issues)
+        return yield* Effect.fail(new Error(result.issues.map((issue) => issue.message).join(`
+`)));
+      return result.value;
+    });
+  }
+  return Effect.try({
+    try: () => {
+      const existing = jsonSchemas.get(schema);
+      if (existing)
+        return existing;
+      const codec = Schema.make(SchemaRepresentation.fromJsonSchemaDocument(JsonSchema.fromSchemaDraft2020_12(schema)).ast);
+      jsonSchemas.set(schema, codec);
+      return codec;
+    },
+    catch: (cause) => cause
+  }).pipe(Effect.flatMap((codec) => Schema.decodeUnknownEffect(codec)(value)));
+}
+function encode(schema, value) {
+  return Schema.isSchema(schema) ? Schema.encodeUnknownEffect(schema)(value) : parse(schema, value);
+}
+function encodeError(method, error) {
+  if (!(error instanceof DeclaredError))
+    return Effect.die(error);
+  if (!method.errors || !Object.hasOwn(method.errors, error.type)) {
+    return Effect.die(new Error(`Undeclared RPC error: ${error.type}`));
+  }
+  return encode(method.errors[error.type], error.data).pipe(Effect.catch((cause) => Effect.die(cause)), Effect.flatMap((data) => Effect.fail(failure(error.type, error.message, data))));
+}
+function decodeError(method, error) {
+  if (!method.errors || !Object.hasOwn(method.errors, error.type))
+    return Effect.fail(error);
+  return read(method.errors[error.type], error.data).pipe(Effect.catch((cause) => Effect.die(cause)), Effect.flatMap((data) => Effect.fail(failure(error.type, error.message, data))));
+}
+function failure(type, message, data) {
+  return data === undefined ? { type, message } : { type, message, data };
+}
+function errorMessage(error, fallback) {
+  if (error instanceof Error)
+    return error.message;
+  if (typeof error === "string")
+    return error;
+  return fallback;
+}
+function isStandardSchema(schema) {
+  return "~standard" in schema;
+}
+function read(schema, value) {
+  return Schema.isSchema(schema) ? Schema.decodeUnknownEffect(schema)(value) : Effect.succeed(value);
+}
+var logicalEvent = Effect.fn("Rpc.logicalEvent")(function* (definition, name, payload, ref) {
+  const event = definition.events[name];
+  const data = yield* read(event.schema, payload.data);
+  return {
+    ...payload,
+    type: eventType(definition, name),
+    data,
+    location: Ref2.make({ directory: ref.directory, workspaceID: ref.workspaceID })
+  };
+});
+
+export { Service15, node19, exports_rpc, define2 };

package/dist/chunks/repository-2yv9jfkc.js

@@ -0,0 +1,34 @@
+import {
+  Ref2
+} from "./repository-6wjjjhy6.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/location-service-map.ts
+var exports_location_service_map = {};
+__export(exports_location_service_map, {
+  LocationServiceMap: () => exports_location_service_map,
+  Service: () => Service53,
+  canonical: () => canonical3,
+  node: () => node57
+});
+import { Context, Effect, Layer } from "effect";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+import { Node } from "@opencode/util/effect/app-node";
+import { AbsolutePath } from "@opencode/schema/schema";
+import path from "path";
+class Service53 extends Context.Service()("@opencode/example/LocationServiceMap") {
+  static get(ref) {
+    return Layer.unwrap(Effect.map(Service53, (locations) => locations.get(ref)));
+  }
+}
+var node57 = LayerNode.unbound(Service53, Node.tags.values.global);
+function canonical3(ref) {
+  return Ref2.make({
+    directory: AbsolutePath.make(process.platform === "win32" ? path.normalize(ref.directory) : ref.directory),
+    workspaceID: ref.workspaceID
+  });
+}
+
+export { Service53, node57, canonical3, exports_location_service_map };

package/dist/chunks/repository-359p4xyc.js

@@ -0,0 +1,25 @@
+// src/database/migration/20260823191254_nullable_workspace_binding.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260823191254_nullable_workspace_binding",
+  foreignKeys: false,
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`__new_workspace\` (
+          \`id\` text PRIMARY KEY,
+          \`provider\` text NOT NULL,
+          \`binding\` text,
+          \`created_at\` integer NOT NULL,
+          \`last_used_at\` integer NOT NULL
+        );
+      `);
+      yield* tx.run(`INSERT INTO \`__new_workspace\`(\`id\`, \`provider\`, \`binding\`, \`created_at\`, \`last_used_at\`) SELECT \`id\`, \`provider\`, \`binding\`, \`created_at\`, \`last_used_at\` FROM \`workspace\`;`);
+      yield* tx.run(`DROP TABLE \`workspace\`;`);
+      yield* tx.run(`ALTER TABLE \`__new_workspace\` RENAME TO \`workspace\`;`);
+    });
+  }
+};
+var _20260823191254_nullable_workspace_binding_default = migration;
+
+export { _20260823191254_nullable_workspace_binding_default };

package/dist/chunks/repository-36564s8r.js

@@ -0,0 +1,226 @@
+import {
+  Service79,
+  node84
+} from "./repository-8m31s27t.js";
+import {
+  makeUnsafe2
+} from "./repository-y71avatq.js";
+import {
+  Binding2,
+  RegistryService2,
+  node81
+} from "./repository-w4axh9wz.js";
+import {
+  WorkspaceTable2
+} from "./repository-faypxj3z.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/workspace.ts
+var exports_workspace = {};
+__export(exports_workspace, {
+  CreateConflict: () => CreateConflict2,
+  ID: () => ID17,
+  Info: () => Info32,
+  NotFound: () => NotFound3,
+  Service: () => Service76,
+  Workspace: () => exports_workspace,
+  configured: () => configured11,
+  node: () => node80
+});
+import { Workspace } from "@opencode/schema/workspace";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { eq } from "drizzle-orm";
+import { Clock, Context, Deferred, Duration, Effect, Exit, FiberSet, Layer, Ref, Schedule, Schema, Scope } from "effect";
+import { systemError } from "effect/PlatformError";
+import { make } from "effect/unstable/process/ChildProcessSpawner";
+var ID17 = Workspace.ID;
+
+class Info32 extends Schema.Class("Workspace.Info")({
+  id: ID17,
+  provider: Schema.String,
+  binding: Binding2,
+  createdAt: Schema.Number,
+  lastUsedAt: Schema.Number
+}) {
+}
+
+class NotFound3 extends Schema.TaggedError()("Workspace.NotFound", { workspaceID: ID17 }) {
+}
+
+class CreateConflict2 extends Schema.TaggedError()("Workspace.CreateConflict", {
+  workspaceID: ID17,
+  provider: Schema.String,
+  existingProvider: Schema.String
+}) {
+}
+
+class Service76 extends Context.Service()("@opencode/Workspace") {
+}
+var configured11 = (options = {}) => makeGlobalNode({
+  service: Service76,
+  layer: layer(options),
+  deps: [node84, node81]
+});
+var layer = (options) => Layer.effect(Service76, Effect.gen(function* () {
+  const db = (yield* Service79).db;
+  const registry = yield* RegistryService2;
+  const lifetime = yield* Scope.Scope;
+  const connections = new Map;
+  const attempts = new Map;
+  const locks = makeUnsafe2();
+  const fork = yield* FiberSet.makeRuntime();
+  const idleThreshold = Duration.toMillis(options.idleThreshold ?? Duration.minutes(20));
+  const find = (workspaceID) => db.select().from(WorkspaceTable2).where(eq(WorkspaceTable2.id, workspaceID)).get().pipe(Effect.orDie);
+  const load = Effect.fn("Workspace.load")(function* (workspaceID) {
+    const row = yield* find(workspaceID);
+    if (!row)
+      return yield* new NotFound3({ workspaceID });
+    return row;
+  });
+  const saveBinding = (workspaceID, binding) => db.update(WorkspaceTable2).set({ binding }).where(eq(WorkspaceTable2.id, workspaceID)).run().pipe(Effect.orDie);
+  const info = (row, binding) => new Info32({
+    id: row.id,
+    provider: row.provider,
+    binding,
+    createdAt: row.created_at,
+    lastUsedAt: row.last_used_at
+  });
+  const provision = Effect.fn("Workspace.provision")((workspaceID) => Effect.suspend(() => {
+    const existing = attempts.get(workspaceID);
+    if (existing)
+      return Deferred.await(existing);
+    const attempt = Deferred.makeUnsafe();
+    attempts.set(workspaceID, attempt);
+    fork(locks.withLock(workspaceID)(Effect.gen(function* () {
+      const row = yield* load(workspaceID);
+      if (row.binding)
+        return info(row, row.binding);
+      const driver = yield* registry.get(row.provider);
+      const result = yield* driver.create({ workspaceID });
+      yield* saveBinding(workspaceID, result.binding);
+      return info(row, result.binding);
+    })).pipe(Effect.raceFirst(Deferred.await(attempt)), Effect.onExit((exit) => Effect.sync(() => {
+      if (attempts.get(workspaceID) === attempt)
+        attempts.delete(workspaceID);
+      Deferred.doneUnsafe(attempt, exit);
+    })), Effect.exit, Effect.asVoid));
+    return Deferred.await(attempt);
+  }));
+  const open = Effect.fn("Workspace.open")(function* (workspaceID) {
+    const existing = connections.get(workspaceID);
+    if (existing)
+      return existing;
+    const row = yield* load(workspaceID);
+    if (!row.binding)
+      return yield* Effect.die(`workspace ${workspaceID} has no binding after provision`);
+    const driver = yield* registry.get(row.provider);
+    const persistBinding = (binding) => saveBinding(workspaceID, binding);
+    const scope = yield* Scope.fork(lifetime);
+    const environment = yield* driver.connect({ workspaceID, binding: row.binding, saveBinding: persistBinding }).pipe(Effect.provideService(Scope.Scope, scope), Effect.onError((cause) => Scope.close(scope, Exit.failCause(cause))));
+    const now = yield* Clock.currentTimeMillis;
+    const connection = {
+      driver,
+      environment,
+      saveBinding: persistBinding,
+      lastActivity: yield* Ref.make(now),
+      active: yield* Ref.make(0),
+      scope
+    };
+    connections.set(workspaceID, connection);
+    yield* db.update(WorkspaceTable2).set({ last_used_at: now }).where(eq(WorkspaceTable2.id, workspaceID)).run().pipe(Effect.orDie);
+    return connection;
+  });
+  yield* Effect.gen(function* () {
+    const now = yield* Clock.currentTimeMillis;
+    yield* Effect.forEach([...connections.entries()], ([workspaceID, expected]) => locks.withLock(workspaceID)(Effect.gen(function* () {
+      const connection = connections.get(workspaceID);
+      if (connection !== expected || (yield* Ref.get(connection.active)) > 0)
+        return;
+      const lastActivity = yield* Ref.get(connection.lastActivity);
+      if (now - lastActivity < idleThreshold)
+        return;
+      const row = yield* load(workspaceID);
+      if (!row.binding)
+        return;
+      yield* connection.driver.suspendForIdle({
+        workspaceID,
+        binding: row.binding,
+        saveBinding: connection.saveBinding
+      });
+      yield* db.update(WorkspaceTable2).set({ last_used_at: lastActivity }).where(eq(WorkspaceTable2.id, workspaceID)).run().pipe(Effect.orDie);
+      connections.delete(workspaceID);
+      yield* Scope.close(connection.scope, Exit.void);
+    }).pipe(Effect.catchCause((cause) => Effect.logError("workspace idle suspension failed", cause)))), { concurrency: "unbounded", discard: true });
+  }).pipe(Effect.repeat(Schedule.spaced(options.pollInterval ?? Duration.minutes(1))), Effect.forkScoped);
+  return Service76.of({
+    create: Effect.fn("Workspace.create")(function* (input) {
+      const workspaceID = input.id ?? ID17.create();
+      const existing = yield* db.select({ provider: WorkspaceTable2.provider }).from(WorkspaceTable2).where(eq(WorkspaceTable2.id, workspaceID)).get().pipe(Effect.orDie);
+      if (existing) {
+        if (existing.provider === input.provider)
+          return workspaceID;
+        return yield* new CreateConflict2({
+          workspaceID,
+          provider: input.provider,
+          existingProvider: existing.provider
+        });
+      }
+      yield* registry.get(input.provider);
+      const now = yield* Clock.currentTimeMillis;
+      const inserted = yield* db.insert(WorkspaceTable2).values({ id: workspaceID, provider: input.provider, binding: null, created_at: now, last_used_at: now }).onConflictDoNothing().returning({ id: WorkspaceTable2.id }).get().pipe(Effect.orDie);
+      if (inserted)
+        return workspaceID;
+      const row = yield* load(workspaceID).pipe(Effect.orDie);
+      if (row.provider !== input.provider)
+        return yield* new CreateConflict2({
+          workspaceID,
+          provider: input.provider,
+          existingProvider: row.provider
+        });
+      return workspaceID;
+    }),
+    provision,
+    connect: Effect.fn("Workspace.connect")(function* (workspaceID) {
+      const spawner = make((command) => Effect.acquireRelease(Effect.suspend(() => connections.has(workspaceID) ? Effect.void : provision(workspaceID)).pipe(Effect.andThen(locks.withLock(workspaceID)(Effect.gen(function* () {
+        const connection = yield* open(workspaceID);
+        yield* Ref.set(connection.lastActivity, yield* Clock.currentTimeMillis);
+        yield* Ref.update(connection.active, (active) => active + 1);
+        return connection;
+      }))), Effect.mapError((cause) => systemError({
+        _tag: "Unknown",
+        module: "Workspace",
+        method: "spawn",
+        description: `Failed to wake workspace ${workspaceID}`,
+        cause
+      }))), (connection) => locks.withLock(workspaceID)(Effect.gen(function* () {
+        yield* Ref.update(connection.active, (active) => active - 1);
+        yield* Ref.set(connection.lastActivity, yield* Clock.currentTimeMillis);
+      }))).pipe(Effect.flatMap((connection) => connection.environment.spawner.spawn(command))));
+      return { spawner };
+    }),
+    destroy: Effect.fn("Workspace.destroy")(function* (workspaceID) {
+      const attempt = attempts.get(workspaceID);
+      if (attempt) {
+        attempts.delete(workspaceID);
+        Deferred.doneUnsafe(attempt, Exit.fail(new NotFound3({ workspaceID })));
+      }
+      return yield* locks.withLock(workspaceID)(Effect.gen(function* () {
+        const row = yield* find(workspaceID);
+        if (!row)
+          return { destroyed: false };
+        const connection = connections.get(workspaceID);
+        connections.delete(workspaceID);
+        if (connection)
+          yield* Scope.close(connection.scope, Exit.void);
+        yield* registry.get(row.provider).pipe(Effect.flatMap((driver) => driver.destroy({ workspaceID, binding: row.binding })), Effect.catchTag("WorkspaceDriver.ProviderNotFound", (error) => row.binding ? Effect.fail(error) : Effect.void));
+        yield* db.delete(WorkspaceTable2).where(eq(WorkspaceTable2.id, workspaceID)).run().pipe(Effect.orDie);
+        return { destroyed: true };
+      }));
+    })
+  });
+}));
+var node80 = configured11();
+
+export { ID17, Info32, NotFound3, CreateConflict2, Service76, configured11, node80, exports_workspace };

package/dist/chunks/repository-386j3b86.js

@@ -0,0 +1,170 @@
+import {
+  Service58
+} from "./repository-ykpr0q7c.js";
+import {
+  MAX_MARKDOWN_BYTES2,
+  convertHTMLToMarkdown2
+} from "./repository-4vcrnpx2.js";
+import {
+  collectBoundedResponseBody2
+} from "./repository-3v8g72cx.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/tool/plugin/webfetch.ts
+var exports_webfetch = {};
+__export(exports_webfetch, {
+  DEFAULT_TIMEOUT_SECONDS: () => DEFAULT_TIMEOUT_SECONDS2,
+  Input: () => Input8,
+  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES2,
+  MAX_TIMEOUT_SECONDS: () => MAX_TIMEOUT_SECONDS2,
+  Plugin: () => Plugin25,
+  WebFetchTool: () => exports_webfetch,
+  convertHTMLToMarkdown: () => convertHTMLToMarkdown2,
+  description: () => description5,
+  extractTextFromHTML: () => extractTextFromHTML2,
+  name: () => name8
+});
+import { ToolFailure } from "@opencode/ai";
+import { Duration, Effect, Schema } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { Parser } from "htmlparser2";
+var name8 = "webfetch";
+var MAX_RESPONSE_BYTES2 = MAX_MARKDOWN_BYTES2;
+var DEFAULT_TIMEOUT_SECONDS2 = 30;
+var MAX_TIMEOUT_SECONDS2 = 120;
+var description5 = `Fetch content from an HTTP or HTTPS URL and return it as text, markdown, or HTML. Markdown is the default.
+
+Use 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.`;
+var Timeout = Schema.Finite.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(MAX_TIMEOUT_SECONDS2));
+var Input8 = Schema.Struct({
+  url: Schema.String.annotate({ description: "The HTTP or HTTPS URL to fetch content from" }),
+  format: Schema.Literals(["text", "markdown", "html"]).annotate({ description: "The format to return the content in. Defaults to markdown." }).pipe(Schema.withDecodingDefaultKey(Effect.succeed("markdown"))),
+  timeout: Schema.optionalKey(Timeout).annotate({
+    description: `Optional timeout in seconds (maximum: ${MAX_TIMEOUT_SECONDS2})`
+  })
+});
+var Output = Schema.Struct({
+  url: Schema.String,
+  contentType: Schema.String,
+  format: Input8.fields.format,
+  output: Schema.String
+});
+var acceptHeader = (format) => {
+  switch (format) {
+    case "markdown":
+      return "text/markdown;q=1.0, text/x-markdown;q=0.9, text/plain;q=0.8, text/html;q=0.7, */*;q=0.1";
+    case "text":
+      return "text/plain;q=1.0, text/markdown;q=0.9, text/html;q=0.8, */*;q=0.1";
+    case "html":
+      return "text/html;q=1.0, application/xhtml+xml;q=0.9, text/plain;q=0.8, text/markdown;q=0.7, */*;q=0.1";
+  }
+};
+var headers = (format, userAgent) => ({
+  "User-Agent": userAgent,
+  Accept: acceptHeader(format),
+  "Accept-Language": "en-US,en;q=0.9"
+});
+var openCodeUserAgent = "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; OpenCode-User/1.0; +https://opencode.ai";
+var isCloudflareChallenge = (error) => {
+  if (error.reason._tag !== "StatusCodeError")
+    return false;
+  const response = error.reason.response;
+  return response.status === 403 && response.headers["cf-mitigated"] === "challenge";
+};
+var request = (url, format, userAgent = openCodeUserAgent) => HttpClientRequest.get(url).pipe(HttpClientRequest.setHeaders(headers(format, userAgent)));
+var assertHttpUrl = (url) => {
+  if (url.protocol !== "http:" && url.protocol !== "https:")
+    throw new Error("URL must use http:// or https://");
+};
+var execute = (http, url, format, userAgent = openCodeUserAgent) => http.execute(request(url, format, userAgent)).pipe(Effect.flatMap(HttpClientResponse.filterStatusOk));
+var collectBody = (response) => collectBoundedResponseBody2(response, MAX_RESPONSE_BYTES2, () => new Error(`Response too large (exceeds ${MAX_RESPONSE_BYTES2} byte limit)`));
+var mimeFrom = (contentType) => contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+var isImageAttachment = (mime) => mime.startsWith("image/") && mime !== "image/svg+xml" && mime !== "image/vnd.fastbidsheet";
+var isTextualMime = (mime) => !mime || mime.startsWith("text/") || mime === "application/json" || mime.endsWith("+json") || mime === "application/xml" || mime.endsWith("+xml") || mime === "application/javascript" || mime === "application/x-javascript";
+var convert = (content, contentType, format) => {
+  if (!contentType.includes("text/html"))
+    return content;
+  if (format === "markdown")
+    return convertHTMLToMarkdown2(content);
+  if (format === "text")
+    return extractTextFromHTML2(content);
+  return content;
+};
+var Plugin25 = {
+  id: "opencode.tool.webfetch",
+  effect: Effect.fn("WebFetchTool.Plugin")(function* (ctx) {
+    const http = yield* HttpClient.HttpClient;
+    const permission = yield* Service58;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name8,
+      options: { codemode: false },
+      description: description5,
+      input: Input8,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        yield* Effect.try({
+          try: () => assertHttpUrl(new URL(input.url)),
+          catch: (error) => error
+        });
+        yield* permission.assert({
+          action: name8,
+          resources: [input.url],
+          save: ["*"],
+          metadata: input,
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source: { type: "tool", messageID: context.messageID, id: context.id }
+        });
+        const { body, contentType } = yield* Effect.gen(function* () {
+          const response = yield* execute(http, input.url, input.format).pipe(Effect.catchIf(isCloudflareChallenge, () => execute(http, input.url, input.format, "opencode")));
+          const contentType = response.headers["content-type"] || "";
+          const mime = mimeFrom(contentType);
+          if (isImageAttachment(mime))
+            return yield* Effect.fail(new Error(`Unsupported fetched image content type: ${mime}`));
+          if (!isTextualMime(mime))
+            return yield* Effect.fail(new Error(`Unsupported fetched file content type: ${mime}`));
+          return { body: yield* collectBody(response), contentType };
+        }).pipe(Effect.timeoutOrElse({
+          duration: Duration.seconds(input.timeout ?? DEFAULT_TIMEOUT_SECONDS2),
+          orElse: () => Effect.fail(new Error("Request timed out"))
+        }));
+        const content = new TextDecoder().decode(body);
+        const output = yield* Effect.try({
+          try: () => convert(content, contentType, input.format),
+          catch: (error) => error
+        });
+        const result = {
+          url: input.url,
+          contentType,
+          format: input.format,
+          output
+        };
+        return { output: result, content: result.output, metadata: { contentType: result.contentType } };
+      }).pipe(Effect.mapError((error) => new ToolFailure({ message: `Unable to fetch ${input.url}`, error })))
+    })).pipe(Effect.orDie);
+  })
+};
+function extractTextFromHTML2(html) {
+  let text = "";
+  let skipDepth = 0;
+  const parser = new Parser({
+    onopentag(name) {
+      if (skipDepth > 0 || ["script", "style", "noscript", "iframe", "object", "embed"].includes(name))
+        skipDepth++;
+    },
+    ontext(input) {
+      if (skipDepth === 0)
+        text += input;
+    },
+    onclosetag() {
+      if (skipDepth > 0)
+        skipDepth--;
+    }
+  });
+  parser.write(html);
+  parser.end();
+  return text.trim();
+}
+export { name8, MAX_RESPONSE_BYTES2, DEFAULT_TIMEOUT_SECONDS2, MAX_TIMEOUT_SECONDS2, description5, Input8, Plugin25, extractTextFromHTML2, exports_webfetch };