mirror of
https://github.com/deepseek-ai/deepseek-harness
synced 2026-08-15 21:04:50 +00:00
70a8b57738
The web tool package exposed ./search and ./fetch as standalone subpath
plugins, but nothing consumed them, the RFC never called for them, and the
sibling dsh-tool-bash (also a multi-tool consumer) ships a single entry and
selects tools via config. The extra entries also tripped the workspace
constraints gate, whose expected `files` list covers single-entry and bin
packages but not a non-bin multi-entry one.
Collapse to a single `.` entry: drop the ./search|./fetch exports and their
lib/*.js from package.json files, delete the per-package tsdown override (the
root config's lib/types/index.js entry now suffices), and remove the
plugin-shaped name/inject exports from search.ts/fetch.ts (renaming each
apply to its applyWeb{Search,Fetch}Tool helper, still composed by the root
plugin and re-exported from the index). Selective enablement stays via the
existing { search?, fetch? } config. Docs updated to match.
77 lines
3.5 KiB
TypeScript
77 lines
3.5 KiB
TypeScript
/**
|
|
* The model-facing `web_fetch` tool: retrieve the content of a specific URL.
|
|
* Execution goes through `ctx.web` — this module owns the model-facing schema,
|
|
* argument validation, and PRESENTATION (HTML→markdown, truncation formatting),
|
|
* while the fetch provider owns safe retrieval (transport, redirects, caps).
|
|
*/
|
|
|
|
import type { Context } from 'cordis'
|
|
import { defineTool } from '@deepseek-ai/dsh-tools'
|
|
import type { ToolCallPresentation } from '@deepseek-ai/dsh-tools'
|
|
import type { ContentBlock } from '@deepseek-ai/dsh-llm'
|
|
import type { WebFetchBody, WebFetchResult } from '@deepseek-ai/dsh-web'
|
|
import { assertNever } from '@deepseek-ai/dsh-llm'
|
|
import type {} from '@deepseek-ai/dsh-system-prompt'
|
|
import { htmlToMarkdown } from './html.ts'
|
|
|
|
/** Validate value constraints the schema DSL can't express. */
|
|
export function parseFetchArgs(args: { url: string; timeout_ms?: number }): { url: string; timeoutMs?: number } {
|
|
if (args.url.trim().length === 0) throw new Error('url must be a non-empty string')
|
|
if (args.timeout_ms !== undefined && (!Number.isFinite(args.timeout_ms) || args.timeout_ms <= 0)) {
|
|
throw new Error('timeout_ms must be a positive number')
|
|
}
|
|
return { url: args.url, ...args.timeout_ms !== undefined ? { timeoutMs: args.timeout_ms } : {} }
|
|
}
|
|
|
|
/** Render a fetched body to model-facing markdown text. */
|
|
export function renderBody(body: WebFetchBody): string {
|
|
switch (body.kind) {
|
|
case 'html':
|
|
return htmlToMarkdown(body.content)
|
|
case 'text':
|
|
return body.content
|
|
/* v8 ignore next 2 -- WebFetchBody is a closed union; this arm is unreachable and only makes adding a kind a compile error. */
|
|
default:
|
|
return assertNever(body, 'unhandled web fetch body kind')
|
|
}
|
|
}
|
|
|
|
/** Format a fetch result as one model-facing text block. */
|
|
export function formatFetchOutput(result: WebFetchResult): string {
|
|
const header = `Fetched ${result.url} (HTTP ${result.statusCode})`
|
|
const footer = result.truncated ? '\n\n(Content truncated. Fetch a more specific URL or section for the full text.)' : ''
|
|
return `${header}\n\n${renderBody(result.body)}${footer}`
|
|
}
|
|
|
|
/** Pending-call presentation: a fetch card titled by the URL. */
|
|
export function presentFetchCall(args: { url: string; timeout_ms?: number }): ToolCallPresentation {
|
|
return { title: args.url, kind: 'fetch', rawInput: args.url }
|
|
}
|
|
|
|
/** Register the `web_fetch` tool and its system-prompt guidance. */
|
|
export function applyWebFetchTool(ctx: Context): void {
|
|
ctx.systemPrompt.section({
|
|
name: 'tool:web_fetch',
|
|
order: 111,
|
|
text: 'Use the web_fetch tool to retrieve the content of a specific HTTP(S) URL (for example a result from web_search). It returns the page content decoded to text. Cite the URL as a markdown link when you use its content.',
|
|
})
|
|
|
|
ctx.tools.register(defineTool({
|
|
name: 'web_fetch',
|
|
description: 'Fetch the content of a specific HTTP(S) URL and return it decoded to text.',
|
|
parameters: {
|
|
url: { type: 'string', required: true, description: 'The HTTP(S) URL to fetch.' },
|
|
timeout_ms: { type: 'number', description: 'Optional fetch timeout in milliseconds (capped by the provider).' },
|
|
},
|
|
async execute(args, exec): Promise<ContentBlock[]> {
|
|
const input = parseFetchArgs(args)
|
|
const result = await ctx.web.fetch(
|
|
{ url: input.url, ...input.timeoutMs !== undefined ? { timeoutMs: input.timeoutMs } : {} },
|
|
exec.signal ? { signal: exec.signal } : undefined,
|
|
)
|
|
return [{ type: 'text', text: formatFetchOutput(result) }]
|
|
},
|
|
presentCall: presentFetchCall,
|
|
}))
|
|
}
|