@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-d6s8p2vk.js

@@ -0,0 +1,157 @@
+// src/tool/runtime.ts
+import { Tool } from "@opencode-ai/schema/tool";
+import { Effect, Schema } from "effect";
+var definition = (tool) => ({
+  name: effectiveName(tool),
+  description: tool.description,
+  inputSchema: inputJsonSchema(tool.input),
+  ...tool.output === undefined ? {} : { outputSchema: outputJsonSchema(tool.output) }
+});
+var execute = (tool, input, context) => Effect.gen(function* () {
+  const decoded = yield* decodeInput(tool.input, input);
+  const result = yield* tool.execute(decoded, context);
+  if (tool.output === undefined) {
+    if ("output" in result)
+      return yield* Effect.die("Tool result declared output without an output schema");
+    return {
+      output: undefined,
+      content: normalizeContent(result.content),
+      ...result.metadata === undefined ? {} : { metadata: result.metadata }
+    };
+  }
+  if (!("output" in result))
+    return yield* new Tool.Error({ message: "Tool did not return its declared output" });
+  const output = yield* encodeOutput(tool.output, result.output);
+  return {
+    output,
+    content: normalizeContent(result.content, output),
+    ...result.metadata === undefined ? {} : { metadata: result.metadata }
+  };
+});
+var decodeInput = (schema, value) => {
+  if (Schema.isSchema(schema))
+    return Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((error) => new Tool.Error({ message: `Invalid tool input: ${error.message}` })));
+  if (isStandardSchema(schema))
+    return validateStandard(schema, value, "Invalid tool input");
+  return Effect.succeed(value);
+};
+var encodeOutput = (schema, value) => {
+  if (Schema.isSchema(schema))
+    return Schema.encodeEffect(schema)(value).pipe(Effect.mapError((error) => new Tool.Error({ message: `Tool returned an invalid value for its output schema: ${error.message}` })));
+  if (isStandardSchema(schema))
+    return validateStandard(schema, value, "Tool returned an invalid value for its output schema");
+  return Schema.decodeUnknownEffect(Schema.Json)(value).pipe(Effect.mapError((error) => new Tool.Error({ message: `Tool returned a non-JSON value for its output schema: ${error.message}` })));
+};
+var isStandardSchema = (schema) => typeof schema === "object" && schema !== null && ("~standard" in schema);
+var validateStandard = (schema, value, prefix) => Effect.gen(function* () {
+  const pending = yield* Effect.try({
+    try: () => schema["~standard"].validate(value),
+    catch: (error) => standardFailure(prefix, error)
+  });
+  const result = pending instanceof Promise ? yield* Effect.tryPromise({ try: () => pending, catch: (error) => standardFailure(prefix, error) }) : pending;
+  if (result.issues)
+    return yield* new Tool.Error({
+      message: `${prefix}: ${result.issues.map((issue) => issue.message).join(", ")}`
+    });
+  return result.value;
+});
+var standardFailure = (prefix, error) => new Tool.Error({ message: `${prefix}: ${error instanceof Error ? error.message : String(error)}` });
+var inputJsonSchema = (schema) => {
+  if (schema === undefined || schema === null)
+    return {};
+  if (isStandardSchema(schema))
+    return schema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+  return Schema.isSchema(schema) ? toJsonSchema(schema) : schema;
+};
+var outputJsonSchema = (schema) => {
+  if (isStandardSchema(schema))
+    return schema["~standard"].jsonSchema.output({ target: "draft-2020-12" });
+  return Schema.isSchema(schema) ? toJsonSchema(schema) : schema;
+};
+var toJsonSchema = (schema) => {
+  const document = Schema.toJsonSchemaDocument(schema);
+  const normalized = flattenAllOf(Object.keys(document.definitions).length === 0 ? document.schema : { ...document.schema, $defs: document.definitions });
+  return dropDefinitionsIfResolved(inlineLocalReferences(normalized));
+};
+var flattenAllOf = (value) => {
+  if (Array.isArray(value))
+    return value.map(flattenAllOf);
+  if (typeof value !== "object" || value === null)
+    return value;
+  const schema = Object.fromEntries(Object.entries(value).map(([key, item]) => [key, flattenAllOf(item)]));
+  if (!Array.isArray(schema.allOf) || !schema.allOf.every(isRecord) || !canFlattenAllOf(schema.allOf, schema))
+    return schema;
+  const { allOf, ...rest } = schema;
+  return flattenAllOf({ ...Object.assign({}, ...allOf), ...rest });
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var canFlattenAllOf = (allOf, parent) => {
+  const keys = new Set(Object.keys(parent).filter((key) => key !== "allOf"));
+  return allOf.every((item) => Object.keys(item).every((key) => {
+    if (keys.has(key))
+      return false;
+    keys.add(key);
+    return true;
+  }));
+};
+var inlineLocalReferences = (value, definitions, seen = new Set) => {
+  if (Array.isArray(value))
+    return value.map((item) => inlineLocalReferences(item, definitions, seen));
+  if (!isRecord(value))
+    return value;
+  const localDefinitions = definitions ?? (isRecord(value.$defs) ? value.$defs : undefined);
+  if (typeof value.$ref === "string" && localDefinitions) {
+    const segment = value.$ref.match(/^#\/\$defs\/([^/]+)$/)?.[1];
+    const name = segment?.replaceAll("~1", "/").replaceAll("~0", "~");
+    if (name && !seen.has(name)) {
+      const target = localDefinitions[name];
+      if (target) {
+        const { $ref: _, ...rest } = value;
+        const resolvedTarget = inlineLocalReferences(target, localDefinitions, new Set(seen).add(name));
+        const resolvedSiblings = inlineLocalReferences(rest, localDefinitions, seen);
+        if (!isRecord(resolvedTarget) || !isRecord(resolvedSiblings))
+          return resolvedTarget;
+        if (canMergeRecords(resolvedTarget, resolvedSiblings))
+          return { ...resolvedTarget, ...resolvedSiblings };
+        return { allOf: [resolvedTarget, resolvedSiblings] };
+      }
+    }
+  }
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, inlineLocalReferences(item, localDefinitions, seen)]));
+};
+var canMergeRecords = (left, right) => Object.keys(left).every((key) => !(key in right));
+var dropDefinitionsIfResolved = (value) => {
+  if (!isRecord(value) || hasLocalReference(value))
+    return value;
+  const { $defs: _, ...rest } = value;
+  return rest;
+};
+var hasLocalReference = (value) => {
+  if (Array.isArray(value))
+    return value.some(hasLocalReference);
+  if (!isRecord(value))
+    return false;
+  if (typeof value.$ref === "string" && value.$ref.startsWith("#/$defs/"))
+    return true;
+  return Object.values(value).some(hasLocalReference);
+};
+var normalizeContent = (value, output) => {
+  if (typeof value === "string")
+    return [{ type: "text", text: value }];
+  if (value !== undefined && value.length > 0)
+    return [...value];
+  return [{ type: "text", text: stringify(output) }];
+};
+var stringify = (value) => {
+  if (typeof value === "string")
+    return value;
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+};
+var normalizedName = (tool) => tool.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+var effectiveName = (tool) => tool.options?.namespace === undefined ? normalizedName(tool) : `${tool.options.namespace.replaceAll(".", "_")}_${normalizedName(tool)}`;
+
+export { definition, execute, normalizeContent };

package/dist/chunks/ripgrep-d6vvk673.js

@@ -0,0 +1,149 @@
+import {
+  __export,
+  __require
+} from "./ripgrep-rvfvac9x.js";
+
+// src/provider.ts
+var exports_provider = {};
+__export(exports_provider, {
+  packageName: () => packageName,
+  mergeOverlay: () => mergeOverlay,
+  mergeHeaders: () => mergeHeaders,
+  loadPackage: () => loadPackage,
+  isAISDK: () => isAISDK,
+  aisdk: () => aisdk,
+  Settings: () => Settings,
+  Request: () => Request,
+  Provider: () => exports_provider,
+  LoadError: () => LoadError,
+  Info: () => Info,
+  ID: () => ID,
+  AISDK_PREFIX: () => AISDK_PREFIX
+});
+import { Effect, Schema } from "effect";
+import { Provider } from "@opencode-ai/schema/provider";
+import { importModule, resolveModule } from "@opencode-ai/util/runtime-import";
+var ID = Provider.ID;
+var AISDK_PREFIX = "aisdk:";
+var isAISDK = (value) => value?.startsWith(AISDK_PREFIX) ?? false;
+var aisdk = (value) => isAISDK(value) ? value : `${AISDK_PREFIX}${value}`;
+function packageName(value) {
+  if (value === undefined || !isAISDK(value))
+    return value;
+  return value.slice(AISDK_PREFIX.length);
+}
+var JsonRecord = Schema.Record(Schema.String, Schema.Json);
+var decodeJsonRecord = Schema.decodeUnknownSync(JsonRecord);
+
+class LoadError extends Schema.TaggedErrorClass()("Provider.LoadError", {
+  package: Schema.String,
+  cause: Schema.Defect()
+}) {
+}
+var packages = new Map;
+var builtins = new Map([
+  ["@opencode-ai/ai/providers/amazon-bedrock", () => import("@opencode-ai/ai/providers/amazon-bedrock")],
+  ["@opencode-ai/ai/providers/amazon-bedrock/mantle", () => import("@opencode-ai/ai/providers/amazon-bedrock/mantle")],
+  [
+    "@opencode-ai/ai/providers/amazon-bedrock/mantle/chat",
+    () => import("@opencode-ai/ai/providers/amazon-bedrock/mantle/chat")
+  ],
+  [
+    "@opencode-ai/ai/providers/amazon-bedrock/mantle/responses",
+    () => import("@opencode-ai/ai/providers/amazon-bedrock/mantle/responses")
+  ],
+  ["@opencode-ai/ai/providers/anthropic", () => import("@opencode-ai/ai/providers/anthropic")],
+  ["@opencode-ai/ai/providers/azure", () => import("@opencode-ai/ai/providers/azure")],
+  ["@opencode-ai/ai/providers/azure/chat", () => import("@opencode-ai/ai/providers/azure/chat")],
+  ["@opencode-ai/ai/providers/azure/responses", () => import("@opencode-ai/ai/providers/azure/responses")],
+  ["@opencode-ai/ai/providers/google", () => import("@opencode-ai/ai/providers/google")],
+  ["@opencode-ai/ai/providers/openai", () => import("@opencode-ai/ai/providers/openai")],
+  ["@opencode-ai/ai/providers/openai/chat", () => import("@opencode-ai/ai/providers/openai/chat")],
+  ["@opencode-ai/ai/providers/openai/responses", () => import("@opencode-ai/ai/providers/openai/responses")],
+  ["@opencode-ai/ai/providers/openai-compatible", () => import("@opencode-ai/ai/providers/openai-compatible")],
+  ["@opencode-ai/ai/providers/openrouter", () => import("@opencode-ai/ai/providers/openrouter")],
+  ["@opencode-ai/ai/providers/xai", () => import("@opencode-ai/ai/providers/xai")]
+]);
+var loadPackage = Effect.fn("Provider.loadPackage")(function* (specifier, npm) {
+  const builtin = builtins.get(specifier);
+  if (builtin)
+    return yield* importPackage(specifier, specifier, builtin);
+  const resolved = yield* Effect.sync(() => {
+    if (specifier.startsWith("file://") || specifier.startsWith("@opencode-ai/ai/"))
+      return specifier;
+    try {
+      return import.meta.resolve(specifier);
+    } catch {
+      return;
+    }
+  });
+  if (resolved)
+    return yield* importPackage(specifier, resolved);
+  if (!npm) {
+    return yield* new LoadError({
+      package: specifier,
+      cause: new Error(`Provider package ${specifier} is not installed`)
+    });
+  }
+  const parts = specifier.split("/");
+  const root = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0] ?? specifier;
+  const installed = yield* npm.add(root).pipe(Effect.mapError((cause) => new LoadError({ package: specifier, cause })));
+  const entrypoint = yield* Effect.try({
+    try: () => specifier === root && installed.entrypoint ? installed.entrypoint : resolveModule(specifier, installed.directory),
+    catch: (cause) => new LoadError({ package: specifier, cause })
+  });
+  return yield* importPackage(specifier, entrypoint);
+});
+function mergeOverlay(base, overlay) {
+  if (base === undefined)
+    return overlay && decodeJsonRecord({ ...overlay });
+  if (overlay === undefined)
+    return decodeJsonRecord({ ...base });
+  return decodeJsonRecord(Object.fromEntries(new Set([...Object.keys(base), ...Object.keys(overlay)]).values().map((key) => {
+    const left = base[key];
+    const right = overlay[key];
+    if (right === undefined)
+      return [key, left];
+    if (typeof left === "object" && left !== null && !Array.isArray(left) && typeof right === "object" && right !== null && !Array.isArray(right))
+      return [
+        key,
+        mergeOverlay(left, right) ?? {}
+      ];
+    return [key, right];
+  })));
+}
+function mergeHeaders(base, overlay) {
+  if (base === undefined)
+    return overlay && { ...overlay };
+  if (overlay === undefined)
+    return { ...base };
+  return Object.fromEntries([...Object.entries(base), ...Object.entries(overlay)].reduce((result, entry) => {
+    result.set(entry[0].toLowerCase(), entry);
+    return result;
+  }, new Map).values());
+}
+var Request = Provider.Request;
+var Settings = Provider.Settings;
+var Info = Provider.Info;
+var importPackage = Effect.fn("Provider.importPackage")(function* (specifier, entrypoint, load = () => importModule(entrypoint)) {
+  const module = yield* Effect.tryPromise({
+    try: () => {
+      const existing = packages.get(entrypoint);
+      if (existing)
+        return existing;
+      const loaded = load();
+      packages.set(entrypoint, loaded);
+      return loaded;
+    },
+    catch: (cause) => new LoadError({ package: specifier, cause })
+  });
+  if (typeof module !== "object" || module === null || typeof module.model !== "function") {
+    return yield* new LoadError({
+      package: specifier,
+      cause: new Error(`Provider package ${specifier} does not export model(modelID, settings)`)
+    });
+  }
+  return module;
+});
+
+export { ID, AISDK_PREFIX, isAISDK, aisdk, packageName, LoadError, loadPackage, mergeOverlay, mergeHeaders, Request, Settings, Info, exports_provider };

package/dist/chunks/ripgrep-da1n05jh.js

@@ -0,0 +1,39 @@
+import {
+  KVTable
+} from "./ripgrep-wmxdh12w.js";
+import {
+  exports_database
+} from "./ripgrep-x7kx8910.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/kv.ts
+var exports_kv = {};
+__export(exports_kv, {
+  node: () => node,
+  Service: () => Service,
+  KV: () => exports_kv
+});
+import { eq } from "drizzle-orm";
+import { Context, Effect, Layer } from "effect";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+class Service extends Context.Service()("@opencode/KV") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const { db } = yield* exports_database.Service;
+  return Service.of({
+    get: Effect.fn("KV.get")(function* (key) {
+      return (yield* db.select({ value: KVTable.value }).from(KVTable).where(eq(KVTable.key, key)).get().pipe(Effect.orDie))?.value;
+    }),
+    set: Effect.fn("KV.set")(function* (key, value) {
+      yield* db.insert(KVTable).values({ key, value }).onConflictDoUpdate({ target: KVTable.key, set: { value, time_updated: Date.now() } }).run().pipe(Effect.orDie);
+    }),
+    remove: Effect.fn("KV.remove")(function* (key) {
+      yield* db.delete(KVTable).where(eq(KVTable.key, key)).run().pipe(Effect.orDie);
+    })
+  });
+}));
+var node = makeGlobalNode({ service: Service, layer, deps: [exports_database.node] });
+
+export { Service, node, exports_kv };

package/dist/chunks/ripgrep-dbah77c1.js

@@ -0,0 +1,17 @@
+// src/github-copilot/responses/tool/local-shell.ts
+import { z } from "zod/v4";
+var localShellInputSchema = z.object({
+  action: z.object({
+    type: z.literal("exec"),
+    command: z.array(z.string()),
+    timeoutMs: z.number().optional(),
+    user: z.string().optional(),
+    workingDirectory: z.string().optional(),
+    env: z.record(z.string(), z.string()).optional()
+  })
+});
+var localShellOutputSchema = z.object({
+  output: z.string()
+});
+
+export { localShellInputSchema, localShellOutputSchema };

package/dist/chunks/ripgrep-dcz5072c.js

@@ -0,0 +1,174 @@
+import {
+  MAX_MARKDOWN_BYTES,
+  convertHTMLToMarkdown
+} from "./ripgrep-xhz3jyrc.js";
+import {
+  collectBoundedResponseBody
+} from "./ripgrep-jve7t217.js";
+import {
+  exports_permission
+} from "./ripgrep-x5r76fqd.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/tool/plugin/webfetch.ts
+var exports_webfetch = {};
+__export(exports_webfetch, {
+  name: () => name,
+  extractTextFromHTML: () => extractTextFromHTML,
+  description: () => description,
+  convertHTMLToMarkdown: () => convertHTMLToMarkdown,
+  WebFetchTool: () => exports_webfetch,
+  Plugin: () => Plugin,
+  MAX_TIMEOUT_SECONDS: () => MAX_TIMEOUT_SECONDS,
+  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES,
+  Input: () => Input,
+  DEFAULT_TIMEOUT_SECONDS: () => DEFAULT_TIMEOUT_SECONDS
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { Duration, Effect, Schema } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { Parser } from "htmlparser2";
+var name = "webfetch";
+var MAX_RESPONSE_BYTES = MAX_MARKDOWN_BYTES;
+var DEFAULT_TIMEOUT_SECONDS = 30;
+var MAX_TIMEOUT_SECONDS = 120;
+var description = `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_SECONDS));
+var Input = 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_SECONDS})`
+  })
+});
+var Output = Schema.Struct({
+  url: Schema.String,
+  contentType: Schema.String,
+  format: Input.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";
+  }
+  return "*/*";
+};
+var headers = (format, userAgent) => ({
+  "User-Agent": userAgent,
+  Accept: acceptHeader(format),
+  "Accept-Language": "en-US,en;q=0.9"
+});
+var browserUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36";
+var isCloudflareChallenge = (error) => {
+  if (!error || typeof error !== "object" || !("reason" in error))
+    return false;
+  const reason = error.reason;
+  if (!reason || typeof reason !== "object" || !("_tag" in reason) || reason._tag !== "StatusCodeError" || !("response" in reason))
+    return false;
+  const response = reason.response;
+  return response.status === 403 && response.headers["cf-mitigated"] === "challenge";
+};
+var request = (url, format, userAgent = browserUserAgent) => 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 = browserUserAgent) => http.execute(request(url, format, userAgent)).pipe(Effect.flatMap(HttpClientResponse.filterStatusOk));
+var collectBody = (response) => collectBoundedResponseBody(response, MAX_RESPONSE_BYTES, () => new Error(`Response too large (exceeds ${MAX_RESPONSE_BYTES} 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 convertHTMLToMarkdown(content);
+  if (format === "text")
+    return extractTextFromHTML(content);
+  return content;
+};
+var Plugin = {
+  id: "opencode.tool.webfetch",
+  effect: Effect.fn("WebFetchTool.Plugin")(function* (ctx) {
+    const http = yield* HttpClient.HttpClient;
+    const permission = yield* exports_permission.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false },
+      description,
+      input: Input,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        yield* Effect.try({
+          try: () => assertHttpUrl(new URL(input.url)),
+          catch: (error) => error
+        });
+        yield* permission.assert({
+          action: name,
+          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 contentType2 = response.headers["content-type"] || "";
+          const mime = mimeFrom(contentType2);
+          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: contentType2 };
+        }).pipe(Effect.timeoutOrElse({
+          duration: Duration.seconds(input.timeout ?? DEFAULT_TIMEOUT_SECONDS),
+          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 extractTextFromHTML(html) {
+  let text = "";
+  let skipDepth = 0;
+  const parser = new Parser({
+    onopentag(name2) {
+      if (skipDepth > 0 || ["script", "style", "noscript", "iframe", "object", "embed"].includes(name2))
+        skipDepth++;
+    },
+    ontext(input) {
+      if (skipDepth === 0)
+        text += input;
+    },
+    onclosetag() {
+      if (skipDepth > 0)
+        skipDepth--;
+    }
+  });
+  parser.write(html);
+  parser.end();
+  return text.trim();
+}
+export { name, MAX_RESPONSE_BYTES, DEFAULT_TIMEOUT_SECONDS, MAX_TIMEOUT_SECONDS, description, Input, Plugin, extractTextFromHTML, exports_webfetch };