deepseek-web-retrieval 0.2.0 → 0.4.0

package/src/opencode/plugin.ts

@@ -1,12 +1,10 @@
 import { Plugin } from "@opencode/plugin"
 import type { Context } from "@opencode/plugin/promise/plugin"
 import type { ToolContext } from "@opencode/plugin/promise/tool"
-import { assertFetchHostPolicy } from "../core/domains"
-import { formatFetchedContent } from "../core/format"
+import { fetchDocument, inspectFetchTarget, searchWeb } from "../core/client"
+import { FETCH_MARKDOWN_ONLY, FETCH_OUTPUT_TRUNCATED } from "../core/descriptions"
 import { resolveFetchTimeoutMs, resolvePluginOptions } from "../core/options"
-import { fetchPage, searchWeb } from "../core/client"
-import type { ResolvedOptions } from "../core/types"
-import { parseFetchUrl } from "../core/url"
+import type { PluginOptions, ResolvedOptions, SearchResult } from "../core/types"
 import { resolveApiKey } from "./auth"
 
 type FetchInput = {
@@ -41,10 +39,53 @@ const FETCH_INPUT = {
 } as const
 
 const DEEPSEEK_FETCH_DESCRIPTION =
-  'Fetch one web page as clean Markdown through DeepSeek\'s Fetch API. This separate tool remains available when the built-in webfetch is replaced. Only format "markdown" is supported. Output is truncated to the configured size.'
+  "Fetch one web page as clean Markdown through DeepSeek's Fetch API. This separate tool remains " +
+    `available when the built-in webfetch is replaced. ${FETCH_MARKDOWN_ONLY} ${FETCH_OUTPUT_TRUNCATED}`
 
 const WEBFETCH_DESCRIPTION =
-  'Fetch content from an HTTP or HTTPS URL and return it as Markdown through DeepSeek\'s Fetch API. This is the built-in webfetch replacement enabled by fetchOverrideWebfetch. DeepSeek does not render JavaScript and some sites return 403/404. Only format "markdown" is supported. Output is truncated to the configured size.'
+  "Fetch content from an HTTP or HTTPS URL and return it as Markdown through DeepSeek's Fetch API. " +
+    "This is the built-in webfetch replacement enabled by fetchOverrideWebfetch. DeepSeek does not " +
+    `render JavaScript and some sites return 403/404. ${FETCH_MARKDOWN_ONLY} ${FETCH_OUTPUT_TRUNCATED}`
+
+/** OpenCode's WebSearch.Result shape, which wraps the published date in `time`. */
+interface OpenCodeSearchResult {
+  readonly url: string
+  readonly title?: string
+  readonly content?: string
+  readonly time: { readonly published?: number }
+}
+
+/** Maps the core's neutral SearchResult onto the shape OpenCode expects. */
+function toOpenCodeResult(result: SearchResult): OpenCodeSearchResult {
+  return {
+    url: result.url,
+    ...(result.title ? { title: result.title } : {}),
+    ...(result.content ? { content: result.content } : {}),
+    ...(result.published !== undefined
+      ? { time: { published: result.published } }
+      : { time: {} }),
+  }
+}
+
+/** How the plugin registers itself with OpenCode; resolved where it is consumed. */
+export interface Registration {
+  readonly setDefault: boolean
+  readonly overrideWebfetch: boolean
+  readonly registerTool: boolean
+}
+
+export function resolveRegistration(input?: PluginOptions): Registration {
+  return {
+    setDefault: input?.setDefaultWebsearch === true,
+    overrideWebfetch: input?.fetchOverrideWebfetch === true,
+    registerTool: input?.fetchRegisterTool !== false,
+  }
+}
+
+/** One place builds the per-request context the core expects. */
+function requestContext(config: ResolvedOptions, apiKey: string, signal: AbortSignal, timeoutMs?: number) {
+  return { signal, auth: { apiKey }, retry: config.retry, ...(timeoutMs === undefined ? {} : { timeoutMs }) }
+}
 
 async function runFetch(
   ctx: Context,
@@ -64,10 +105,9 @@ async function runFetch(
   if (typeof input.url !== "string") {
     throw new Error('"url" must be a string')
   }
-  const target = parseFetchUrl(input.url)
-  // Fail before the permission prompt; fetchPage enforces this again for core
-  // consumers that skip the pre-check.
-  assertFetchHostPolicy(target, config.fetch)
+  // Inspect before the permission prompt so an invalid or blocked target fails
+  // without asking the user; fetchPage enforces the policy again.
+  const target = inspectFetchTarget(input.url, config.fetch)
   const timeoutMs = resolveFetchTimeoutMs(config.fetch.timeoutMs, input.timeout)
 
   // Resolved before the permission prompt so a missing key fails fast instead
@@ -84,18 +124,13 @@ async function runFetch(
     source: { type: "tool", messageID: context.messageID, id: context.id },
   })
 
-  const page = await fetchPage(
-    target,
-    { ...config.fetch, timeoutMs },
-    { signal: context.signal, auth: { apiKey }, retry: config.retry },
-  )
-  const formatted = formatFetchedContent(page.title, page.content, config.fetch.maxChars)
+  const page = await fetchDocument(target, config.fetch, requestContext(config, apiKey, context.signal, timeoutMs))
   return {
-    content: formatted.content,
+    content: page.content,
     metadata: {
       url: page.url,
       title: page.title,
-      truncated: formatted.truncated,
+      truncated: page.truncated,
     },
   }
 }
@@ -104,47 +139,49 @@ export default Plugin.define({
   id: "deepseek-web-retrieval",
   async setup(ctx) {
     const config = resolvePluginOptions(ctx.options)
+    const registration = resolveRegistration(ctx.options)
 
-    await ctx.websearch.transform((editor) => {
-      editor.add({
-        id: "deepseek",
-        name: "DeepSeek",
-        execute: async (input, { signal }) => {
-          const apiKey = await resolveApiKey(ctx, config.auth.source)
-          return searchWeb(input.query, config.search, {
-            signal,
-            auth: { apiKey },
-            retry: config.retry,
-          })
-        },
+    if (config.search.enabled) {
+      await ctx.websearch.transform((editor) => {
+        editor.add({
+          id: "deepseek",
+          name: "DeepSeek",
+          execute: async (input, { signal }) => {
+            const apiKey = await resolveApiKey(ctx, config.auth.source)
+            const results = await searchWeb(input.query, config.search, requestContext(config, apiKey, signal))
+            return results.map(toOpenCodeResult)
+          },
+        })
+        if (registration.setDefault) editor.default.set("deepseek")
       })
-      if (config.search.setDefault) editor.default.set("deepseek")
-    })
+    }
 
-    await ctx.tool.transform((editor) => {
-      if (config.fetch.overrideWebfetch) editor.remove("webfetch")
+    if (config.fetch.enabled) {
+      await ctx.tool.transform((editor) => {
+        if (registration.overrideWebfetch) editor.remove("webfetch")
 
-      if (config.fetch.registerTool) {
-        editor.add({
-          name: "deepseek_fetch",
-          description: DEEPSEEK_FETCH_DESCRIPTION,
-          input: FETCH_INPUT,
-          options: { codemode: false, permission: "deepseek_fetch" },
-          execute: (input, context) =>
-            runFetch(ctx, config, input as FetchInput, context, "deepseek_fetch", false),
-        })
-      }
+        if (registration.registerTool) {
+          editor.add({
+            name: "deepseek_fetch",
+            description: DEEPSEEK_FETCH_DESCRIPTION,
+            input: FETCH_INPUT,
+            options: { codemode: false, permission: "deepseek_fetch" },
+            execute: (input, context) =>
+              runFetch(ctx, config, input as FetchInput, context, "deepseek_fetch", false),
+          })
+        }
 
-      if (config.fetch.overrideWebfetch) {
-        editor.add({
-          name: "webfetch",
-          description: WEBFETCH_DESCRIPTION,
-          input: FETCH_INPUT,
-          options: { codemode: false, permission: "webfetch" },
-          execute: (input, context) =>
-            runFetch(ctx, config, input as FetchInput, context, "webfetch", true),
-        })
-      }
-    })
+        if (registration.overrideWebfetch) {
+          editor.add({
+            name: "webfetch",
+            description: WEBFETCH_DESCRIPTION,
+            input: FETCH_INPUT,
+            options: { codemode: false, permission: "webfetch" },
+            execute: (input, context) =>
+              runFetch(ctx, config, input as FetchInput, context, "webfetch", true),
+          })
+        }
+      })
+    }
   },
 })

package/src/mcp/format.ts

@@ -1,31 +0,0 @@
-import type { WebSearchResult } from "../core/types"
-
-/**
- * Renders processed search results as Markdown for the text content block.
- * Hosts that ignore `structuredContent` (Gemini CLI, Continue) read this text.
- */
-export function formatSearchResults(results: readonly WebSearchResult[]): string {
-  if (results.length === 0) return "No results found."
-
-  return results
-    .map((result, index) => {
-      const title = result.title?.trim() || result.url
-      const lines = [`${index + 1}. [${escapeBrackets(title)}](${result.url})`]
-      if (result.content) {
-        lines.push(`   ${result.content.replaceAll("\n", " ")}`)
-      }
-      if (result.time.published !== undefined) {
-        lines.push(`   Published: ${formatPublished(result.time.published)}`)
-      }
-      return lines.join("\n")
-    })
-    .join("\n\n")
-}
-
-function escapeBrackets(value: string): string {
-  return value.replaceAll("[", "\\[").replaceAll("]", "\\]")
-}
-
-function formatPublished(epochMs: number): string {
-  return new Date(epochMs).toISOString().slice(0, 10)
-}