@mrclrchtr/supi-web 5.0.0 → 6.0.0

package/src/tool/web_docs_fetch/result.ts

@@ -0,0 +1,31 @@
+import type { AgentToolResult, TruncationResult } from "@earendil-works/pi-coding-agent";
+import type { ModelVisibleOutput } from "../result.ts";
+
+export interface FetchDetails extends Record<string, unknown> {
+  libraryId: string;
+  raw: boolean;
+  chars: number;
+  lines: number;
+  truncation?: TruncationResult;
+  fullOutputPath?: string;
+}
+
+/** Assemble the model-facing result for one docs fetch. */
+export function buildFetchResult(
+  libraryId: string,
+  raw: boolean,
+  textContent: string,
+  output: ModelVisibleOutput,
+): AgentToolResult<FetchDetails> {
+  return {
+    content: [{ type: "text", text: output.text }],
+    details: {
+      libraryId,
+      raw,
+      chars: textContent.length,
+      lines: textContent.split("\n").length,
+      truncation: output.truncation,
+      fullOutputPath: output.fullOutputPath,
+    },
+  };
+}

package/src/tool/web_docs_fetch/spec.ts

@@ -0,0 +1,32 @@
+import type { Static } from "typebox";
+import { Type } from "typebox";
+import { runFetch } from "./execute.ts";
+
+export const WEB_DOCS_FETCH_TOOL_NAME = "web_docs_fetch";
+export const WEB_DOCS_FETCH_TOOL_LABEL = "Web Docs Fetch";
+
+export const webDocsFetchParameters = Type.Object(
+  {
+    library_id: Type.String({
+      description: "Context7 ID (e.g. /facebook/react); search first if unknown",
+    }),
+    query: Type.String({ description: "Specific docs question" }),
+    raw: Type.Optional(
+      Type.Boolean({
+        description: "Return JSON snippets instead of Markdown",
+        default: false,
+      }),
+    ),
+  },
+  { additionalProperties: false },
+);
+
+export type WebDocsFetchInput = Static<typeof webDocsFetchParameters>;
+
+/** Canonical provider-facing metadata for the web_docs_fetch tool. */
+export const webDocsFetchSpec = {
+  name: WEB_DOCS_FETCH_TOOL_NAME,
+  label: WEB_DOCS_FETCH_TOOL_LABEL,
+  parameters: webDocsFetchParameters,
+  execute: runFetch,
+} as const;

package/src/tool/web_docs_search/execute.ts

@@ -0,0 +1,50 @@
+import type {
+  AgentToolResult,
+  AgentToolUpdateCallback,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { searchLibrary } from "../../context7-client.ts";
+import { limitModelVisibleOutput } from "../result.ts";
+import {
+  buildNoResultsResult,
+  buildSearchResult,
+  formatSearchResults,
+  type SearchDetails,
+} from "./result.ts";
+import type { WebDocsSearchInput } from "./spec.ts";
+
+// biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
+export async function runSearch(
+  _toolCallId: string,
+  params: unknown,
+  signal: AbortSignal | undefined,
+  onUpdate: AgentToolUpdateCallback<Record<string, unknown>> | undefined,
+  _ctx: ExtensionContext,
+): Promise<AgentToolResult<SearchDetails>> {
+  const input = (params ?? {}) as WebDocsSearchInput;
+  const libraryName = input.library_name?.trim();
+  const query = input.query?.trim();
+
+  if (!libraryName) throw new Error("'library_name' parameter is required");
+  if (!query) throw new Error("'query' parameter is required");
+
+  onUpdate?.({
+    content: [{ type: "text", text: `Searching Context7 for ${libraryName}...` }],
+    details: { libraryName },
+  });
+
+  const requestOptions = signal ? { signal } : undefined;
+  const results = await searchLibrary(query, libraryName, requestOptions);
+
+  if (results.length === 0) {
+    return buildNoResultsResult(libraryName);
+  }
+
+  const markdown = formatSearchResults(libraryName, results);
+  const output = await limitModelVisibleOutput(markdown, {
+    tempPrefix: "web-docs-search",
+    suffix: ".md",
+  });
+
+  return buildSearchResult(libraryName, results, output);
+}

package/src/tool/web_docs_search/guidance.ts

@@ -0,0 +1,7 @@
+import { MODEL_OUTPUT_LIMIT_DESCRIPTION } from "../result.ts";
+
+export const toolDescription = `Search Context7 for library IDs; returns compact Markdown. ${MODEL_OUTPUT_LIMIT_DESCRIPTION}`;
+
+export const promptSnippet = "web_docs_search: Context7 library IDs";
+
+export const promptGuidelines = ["Use web_docs_search before web_docs_fetch if ID unknown."];

package/src/tool/web_docs_search/register.ts

@@ -0,0 +1,16 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { promptGuidelines, promptSnippet, toolDescription } from "./guidance.ts";
+import { renderSearchCall, renderSearchResult } from "./render.ts";
+import { webDocsSearchSpec } from "./spec.ts";
+
+/** Register the web_docs_search tool. */
+export function registerWebDocsSearchTool(pi: ExtensionAPI): void {
+  pi.registerTool({
+    ...webDocsSearchSpec,
+    description: toolDescription,
+    promptSnippet,
+    promptGuidelines: [...promptGuidelines],
+    renderCall: renderSearchCall,
+    renderResult: renderSearchResult,
+  });
+}

package/src/tool/web_docs_search/render.ts

@@ -0,0 +1,75 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { renderCollapsibleTextResult, renderToolCall } from "../render.ts";
+import type { SearchDetails } from "./result.ts";
+import { WEB_DOCS_SEARCH_TOOL_NAME, type WebDocsSearchInput } from "./spec.ts";
+
+/** Transcript renderer for web_docs_search tool calls. */
+export function renderSearchCall(args: unknown, theme: Theme) {
+  const input = (args ?? {}) as WebDocsSearchInput;
+  const libraryName = typeof input.library_name === "string" ? input.library_name : "";
+  const query = typeof input.query === "string" ? truncatePreview(input.query) : undefined;
+  return renderToolCall(WEB_DOCS_SEARCH_TOOL_NAME, libraryName, theme, query);
+}
+
+/** Transcript renderer for web_docs_search tool results. */
+export function renderSearchResult(
+  result: { content: Array<{ type: string; text?: string }>; details?: unknown },
+  { expanded, isPartial }: { expanded: boolean; isPartial: boolean },
+  theme: Theme,
+) {
+  if (isPartial) {
+    return renderCollapsibleTextResult({
+      summary: theme.fg("warning", "Searching Context7..."),
+      expanded,
+      theme,
+    });
+  }
+
+  const details = result.details as SearchDetails | undefined;
+  const summary = buildSearchSummary(details, theme);
+  const content = result.content.find((item) => item.type === "text");
+  const body =
+    details?.count === 0 ? undefined : content?.type === "text" ? content.text : undefined;
+
+  return renderCollapsibleTextResult({
+    summary,
+    body,
+    expanded,
+    theme,
+    fullOutputPath: details?.fullOutputPath,
+  });
+}
+
+function truncatePreview(text: string, maxChars = 48): string {
+  const compact = text.replace(/\s+/g, " ").trim();
+  if (compact.length <= maxChars) return compact;
+  return `${compact.slice(0, maxChars - 1).trimEnd()}…`;
+}
+
+function buildSearchSummary(
+  details: SearchDetails | undefined,
+  theme: { fg: (color: "success" | "warning" | "dim", text: string) => string },
+): string {
+  if (!details) {
+    return theme.fg("success", "Context7 search finished");
+  }
+
+  if (details.count === 0) {
+    return [
+      theme.fg("warning", "No libraries found"),
+      theme.fg("dim", ` for ${JSON.stringify(details.libraryName)}`),
+    ].join("");
+  }
+
+  const noun = details.count === 1 ? "library" : "libraries";
+  let summary = [
+    theme.fg("success", `Found ${details.count} ${noun}`),
+    theme.fg("dim", ` for ${JSON.stringify(details.libraryName)}`),
+  ].join("");
+
+  if (details.truncation?.truncated) {
+    summary += theme.fg("warning", " [truncated]");
+  }
+
+  return summary;
+}

package/src/tool/web_docs_search/result.ts

@@ -0,0 +1,103 @@
+import type { AgentToolResult, TruncationResult } from "@earendil-works/pi-coding-agent";
+import type { searchLibrary } from "../../context7-client.ts";
+import type { ModelVisibleOutput } from "../result.ts";
+
+export interface SearchDetails extends Record<string, unknown> {
+  count: number;
+  libraryName: string;
+  truncation?: TruncationResult;
+  fullOutputPath?: string;
+}
+
+type SearchLibraryResult = Awaited<ReturnType<typeof searchLibrary>>[number];
+
+const MAX_SEARCH_RESULTS = 10;
+const MAX_DESCRIPTION_CHARS = 120;
+const MAX_VERSION_COUNT = 5;
+
+/** Assemble the empty-search result. */
+export function buildNoResultsResult(libraryName: string): AgentToolResult<SearchDetails> {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `No libraries found for "${libraryName}". Try a different search term.`,
+      },
+    ],
+    details: { count: 0, libraryName },
+  };
+}
+
+/** Assemble the model-facing result for one successful search. */
+export function buildSearchResult(
+  libraryName: string,
+  results: Awaited<ReturnType<typeof searchLibrary>>,
+  output: ModelVisibleOutput,
+): AgentToolResult<SearchDetails> {
+  return {
+    content: [{ type: "text", text: output.text }],
+    details: {
+      count: results.length,
+      libraryName,
+      truncation: output.truncation,
+      fullOutputPath: output.fullOutputPath,
+    },
+  };
+}
+
+/** Format search results as compact Markdown for the model. */
+export function formatSearchResults(
+  libraryName: string,
+  results: Awaited<ReturnType<typeof searchLibrary>>,
+): string {
+  const visibleResults = results.slice(0, MAX_SEARCH_RESULTS);
+  const hiddenCount = results.length - visibleResults.length;
+  const rows = visibleResults.map(formatSearchRow);
+  const noun = results.length === 1 ? "library" : "libraries";
+  const hiddenNote =
+    hiddenCount > 0
+      ? [`_${hiddenCount} more omitted; refine \`library_name\` or \`query\` if needed._`, ""]
+      : [];
+
+  return [
+    `Found ${results.length} Context7 ${noun} for "${libraryName}"${hiddenCount > 0 ? `; showing top ${visibleResults.length}` : ""}:`,
+    "",
+    "| ID | Name | Trust | Bench | Snips | Versions | Description |",
+    "|---|---|---|---|---|---|---|",
+    ...rows,
+    "",
+    ...hiddenNote,
+    "> Use `web_docs_fetch` with the chosen ID.",
+  ].join("\n");
+}
+
+function formatSearchRow(lib: SearchLibraryResult): string {
+  const cells = [
+    `\`${escapeMd(lib.id)}\``,
+    escapeMd(lib.name),
+    String(lib.trustScore ?? ""),
+    String(lib.benchmarkScore ?? ""),
+    String(lib.totalSnippets ?? ""),
+    escapeMd(formatVersions(lib.versions)),
+    escapeMd(truncateCell(lib.description ?? "", MAX_DESCRIPTION_CHARS)),
+  ];
+
+  return `| ${cells.join(" | ")} |`;
+}
+
+function formatVersions(versions?: string[]): string {
+  if (!versions?.length) return "";
+  const visibleVersions = versions.slice(0, MAX_VERSION_COUNT);
+  const hiddenCount = versions.length - visibleVersions.length;
+  return `${visibleVersions.join(", ")}${hiddenCount > 0 ? `, +${hiddenCount}` : ""}`;
+}
+
+function truncateCell(text: string, maxChars: number): string {
+  const compact = text.replace(/\s+/g, " ").trim();
+  if (compact.length <= maxChars) return compact;
+  return `${compact.slice(0, maxChars - 1).trimEnd()}…`;
+}
+
+function escapeMd(text: string): string {
+  return text.replace(/\|/g, "\\|").replace(/\n/g, " ");
+}

package/src/tool/web_docs_search/spec.ts

@@ -0,0 +1,28 @@
+import type { Static } from "typebox";
+import { Type } from "typebox";
+import { runSearch } from "./execute.ts";
+
+export const WEB_DOCS_SEARCH_TOOL_NAME = "web_docs_search";
+export const WEB_DOCS_SEARCH_TOOL_LABEL = "Web Docs Search";
+
+export const webDocsSearchParameters = Type.Object(
+  {
+    library_name: Type.String({
+      description: "Library name (e.g. react, next.js, fastapi)",
+    }),
+    query: Type.String({
+      description: "Task/question for relevance ranking",
+    }),
+  },
+  { additionalProperties: false },
+);
+
+export type WebDocsSearchInput = Static<typeof webDocsSearchParameters>;
+
+/** Canonical provider-facing metadata for the web_docs_search tool. */
+export const webDocsSearchSpec = {
+  name: WEB_DOCS_SEARCH_TOOL_NAME,
+  label: WEB_DOCS_SEARCH_TOOL_LABEL,
+  parameters: webDocsSearchParameters,
+  execute: runSearch,
+} as const;

package/src/tool/web_fetch_md/execute.ts

@@ -0,0 +1,69 @@
+import type {
+  AgentToolResult,
+  AgentToolUpdateCallback,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { htmlToMarkdown, wrapAsCodeBlock } from "../../convert.ts";
+import { fetchWithNegotiation, isValidHttpUrl } from "../../fetch.ts";
+import { writeTempFile } from "../../temp-file.ts";
+import { limitModelVisibleOutput } from "../result.ts";
+import {
+  WEB_FETCH_INLINE_MAX_CHARS,
+  type WebFetchMdInput,
+  type WebFetchOutputMode,
+} from "./input.ts";
+import { buildFileResult, buildInlineResult, type WebFetchDetails } from "./result.ts";
+
+// biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
+export async function runWebFetch(
+  _toolCallId: string,
+  params: unknown,
+  signal: AbortSignal | undefined,
+  onUpdate: AgentToolUpdateCallback<Record<string, unknown>> | undefined,
+  _ctx: ExtensionContext,
+): Promise<AgentToolResult<WebFetchDetails>> {
+  const input = (params ?? {}) as WebFetchMdInput;
+  const url = String(input.url || "").trim();
+  if (!isValidHttpUrl(url)) {
+    throw new Error(`URL must be http(s): ${url}`);
+  }
+
+  const outputMode = input.output_mode ?? "auto";
+  const absLinks = input.abs_links ?? true;
+  const timeoutMs = typeof input.timeout_ms === "number" ? input.timeout_ms : 30_000;
+
+  onUpdate?.({
+    content: [{ type: "text", text: `Fetching ${url}...` }],
+    details: { url, outputMode },
+  });
+
+  const result = await fetchWithNegotiation(url, { timeoutMs, signal });
+  const markdown = await resolveMarkdown(result, absLinks);
+  const lines = markdown.split("\n").length;
+  const chars = markdown.length;
+  const base = { chars, lines, url: result.url, outputMode };
+
+  if (shouldReturnFile(outputMode, chars)) {
+    const filePath = await writeTempFile(markdown, "web-fetch-md", ".md");
+    return buildFileResult(base, filePath);
+  }
+
+  const output = await limitModelVisibleOutput(markdown, {
+    tempPrefix: "web-fetch-md",
+    suffix: ".md",
+  });
+  return buildInlineResult(base, output);
+}
+
+function shouldReturnFile(outputMode: WebFetchOutputMode, chars: number): boolean {
+  return outputMode === "file" || (outputMode === "auto" && chars > WEB_FETCH_INLINE_MAX_CHARS);
+}
+
+async function resolveMarkdown(
+  result: { isMarkdown: boolean; isPlainText: boolean; text: string; url: string },
+  absLinks: boolean,
+): Promise<string> {
+  if (result.isMarkdown) return result.text;
+  if (result.isPlainText) return wrapAsCodeBlock(result.text, result.url);
+  return htmlToMarkdown(result.text, result.url, { absLinks });
+}

package/src/tool/web_fetch_md/guidance.ts

@@ -0,0 +1,32 @@
+import { spawnSync } from "node:child_process";
+import { MODEL_OUTPUT_LIMIT_DESCRIPTION } from "../result.ts";
+import type { WebToolPromptSurface } from "../tool-specs.ts";
+import { WEB_FETCH_INLINE_MAX_CHARS } from "./spec.ts";
+
+export const toolDescription = `Fetch public http(s) URL as Markdown. Not for login/private pages. output_mode auto inlines <=${WEB_FETCH_INLINE_MAX_CHARS.toLocaleString()} chars else temp; inline may truncate; file returns a temp path. Links are absolute by default. ${MODEL_OUTPUT_LIMIT_DESCRIPTION}`;
+
+export const promptSnippet = "web_fetch_md: public URL to Markdown";
+
+export const promptGuidelines = ["Use web_fetch_md only for public http(s); ask if login/private."];
+
+/** Runtime prompt surface; adds gh guidance when the gh CLI is available. */
+export function getWebFetchPromptSurface(): WebToolPromptSurface {
+  const guidelines = [...promptGuidelines];
+  if (isGhAvailable()) {
+    guidelines.push("Use `gh` CLI instead of web_fetch_md for GitHub URLs.");
+  }
+  return {
+    description: toolDescription,
+    promptSnippet,
+    promptGuidelines: guidelines,
+  };
+}
+
+function isGhAvailable(): boolean {
+  try {
+    const result = spawnSync("gh", ["--version"], { stdio: "ignore" });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}

package/src/tool/web_fetch_md/input.ts

@@ -0,0 +1,39 @@
+// Leaf module for web_fetch_md input vocabulary.
+//
+// The parameter schema and its constants live here (not in spec.ts) so
+// execute.ts can read them without importing spec.ts; spec.ts imports the
+// execute binding, and a spec <-> execute cycle would risk undefined
+// bindings depending on module evaluation order.
+
+import { StringEnum } from "@earendil-works/pi-ai";
+import type { Static } from "typebox";
+import { Type } from "typebox";
+import { FETCH_TIMEOUT_MAX_MS } from "../../fetch.ts";
+
+export const WEB_FETCH_INLINE_MAX_CHARS = 15_000;
+export const WEB_FETCH_OUTPUT_MODES = ["auto", "inline", "file"] as const;
+export type WebFetchOutputMode = (typeof WEB_FETCH_OUTPUT_MODES)[number];
+
+const OutputModeEnum = StringEnum(WEB_FETCH_OUTPUT_MODES, {
+  default: "auto",
+  description: "auto, inline, or file output",
+});
+
+export const webFetchMdParameters = Type.Object(
+  {
+    url: Type.String({ description: "Public http(s) URL" }),
+    output_mode: Type.Optional(OutputModeEnum),
+    abs_links: Type.Optional(Type.Boolean({ description: "Absolute links/images", default: true })),
+    timeout_ms: Type.Optional(
+      Type.Integer({
+        description: "Fetch timeout (ms)",
+        default: 30_000,
+        minimum: 0,
+        maximum: FETCH_TIMEOUT_MAX_MS,
+      }),
+    ),
+  },
+  { additionalProperties: false },
+);
+
+export type WebFetchMdInput = Static<typeof webFetchMdParameters>;

package/src/tool/web_fetch_md/register.ts

@@ -0,0 +1,17 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getWebFetchPromptSurface } from "./guidance.ts";
+import { renderWebFetchCall, renderWebFetchResult } from "./render.ts";
+import { webFetchMdSpec } from "./spec.ts";
+
+/** Register the web_fetch_md tool. */
+export function registerWebFetchMdTool(pi: ExtensionAPI): void {
+  const surface = getWebFetchPromptSurface();
+  pi.registerTool({
+    ...webFetchMdSpec,
+    description: surface.description,
+    promptSnippet: surface.promptSnippet,
+    promptGuidelines: surface.promptGuidelines,
+    renderCall: renderWebFetchCall,
+    renderResult: renderWebFetchResult,
+  });
+}

package/src/tool/web_fetch_md/render.ts

@@ -0,0 +1,74 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { renderCollapsibleTextResult, renderToolCall } from "../render.ts";
+import type { WebFetchDetails } from "./result.ts";
+import { WEB_FETCH_MD_TOOL_NAME, type WebFetchMdInput } from "./spec.ts";
+
+/** Transcript renderer for web_fetch_md tool calls. */
+export function renderWebFetchCall(args: unknown, theme: Theme) {
+  const input = (args ?? {}) as WebFetchMdInput;
+  const url = typeof input.url === "string" ? input.url : "";
+  const outputMode = typeof input.output_mode === "string" ? input.output_mode : undefined;
+  return renderToolCall(WEB_FETCH_MD_TOOL_NAME, url, theme, outputMode);
+}
+
+/** Transcript renderer for web_fetch_md tool results. */
+export function renderWebFetchResult(
+  result: { content: Array<{ type: string; text?: string }>; details?: unknown },
+  { expanded, isPartial }: { expanded: boolean; isPartial: boolean },
+  theme: Theme,
+) {
+  if (isPartial) {
+    return renderCollapsibleTextResult({
+      summary: theme.fg("warning", "Fetching web content..."),
+      expanded,
+      theme,
+    });
+  }
+
+  const details = result.details as WebFetchDetails | undefined;
+  const summary = buildWebFetchSummary(details, theme);
+  const content = result.content.find((item) => item.type === "text");
+  const body = details?.filePath ? undefined : content?.type === "text" ? content.text : undefined;
+
+  return renderCollapsibleTextResult({
+    summary,
+    body,
+    expanded,
+    theme,
+    fullOutputPath: details?.fullOutputPath,
+  });
+}
+
+function buildWebFetchSummary(
+  details: WebFetchDetails | undefined,
+  theme: { fg: (color: "success" | "warning" | "dim", text: string) => string },
+): string {
+  if (!details) {
+    return theme.fg("success", "Fetched web content");
+  }
+
+  if (details.filePath) {
+    return [
+      theme.fg("success", "Saved Markdown to "),
+      theme.fg("dim", details.filePath),
+      theme.fg(
+        "dim",
+        ` (${details.chars.toLocaleString()} chars, ${details.lines.toLocaleString()} lines)`,
+      ),
+    ].join("");
+  }
+
+  let summary = [
+    theme.fg("success", "Fetched Markdown"),
+    theme.fg(
+      "dim",
+      ` (${details.chars.toLocaleString()} chars, ${details.lines.toLocaleString()} lines)`,
+    ),
+  ].join("");
+
+  if (details.truncation?.truncated) {
+    summary += theme.fg("warning", " [truncated]");
+  }
+
+  return summary;
+}

package/src/tool/web_fetch_md/result.ts

@@ -0,0 +1,52 @@
+import type { AgentToolResult, TruncationResult } from "@earendil-works/pi-coding-agent";
+import type { ModelVisibleOutput } from "../result.ts";
+import type { WebFetchOutputMode } from "./spec.ts";
+
+export interface WebFetchDetails extends Record<string, unknown> {
+  chars: number;
+  lines: number;
+  url: string;
+  outputMode: WebFetchOutputMode;
+  filePath?: string;
+  truncation?: TruncationResult;
+  fullOutputPath?: string;
+}
+
+/** Common result metrics shared by both fetch result modes. */
+export interface WebFetchResultBase {
+  chars: number;
+  lines: number;
+  url: string;
+  outputMode: WebFetchOutputMode;
+}
+
+/** Assemble the file-mode result for one fetch. */
+export function buildFileResult(
+  base: WebFetchResultBase,
+  filePath: string,
+): AgentToolResult<WebFetchDetails> {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Content written to ${filePath} (${base.chars.toLocaleString()} chars, ${base.lines.toLocaleString()} lines). Use the read tool to access it.`,
+      },
+    ],
+    details: { ...base, filePath },
+  };
+}
+
+/** Assemble the inline-mode result for one fetch. */
+export function buildInlineResult(
+  base: WebFetchResultBase,
+  output: ModelVisibleOutput,
+): AgentToolResult<WebFetchDetails> {
+  return {
+    content: [{ type: "text", text: output.text }],
+    details: {
+      ...base,
+      truncation: output.truncation,
+      fullOutputPath: output.fullOutputPath,
+    },
+  };
+}

package/src/tool/web_fetch_md/spec.ts

@@ -0,0 +1,21 @@
+import { runWebFetch } from "./execute.ts";
+import { webFetchMdParameters } from "./input.ts";
+
+export {
+  WEB_FETCH_INLINE_MAX_CHARS,
+  WEB_FETCH_OUTPUT_MODES,
+  type WebFetchMdInput,
+  type WebFetchOutputMode,
+  webFetchMdParameters,
+} from "./input.ts";
+
+export const WEB_FETCH_MD_TOOL_NAME = "web_fetch_md";
+export const WEB_FETCH_MD_TOOL_LABEL = "Web Fetch";
+
+/** Canonical provider-facing metadata for the web_fetch_md tool. */
+export const webFetchMdSpec = {
+  name: WEB_FETCH_MD_TOOL_NAME,
+  label: WEB_FETCH_MD_TOOL_LABEL,
+  parameters: webFetchMdParameters,
+  execute: runWebFetch,
+} as const;