picocode-core 0.9.170 → 0.9.171

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "picocode-core",
-  "version": "0.9.170",
+  "version": "0.9.171",
   "description": "The agent runtime behind pico: sessions, tools, subagents, MCP, memory, and model access",
   "type": "module",
   "license": "MIT",

package/src/agent.js

@@ -143,7 +143,7 @@ export async function runTurn({ history, tools, recorder, modelName, effort, aut
       // a tool may legitimately run for minutes (test suites, slow fetches)
       // and emits nothing while it does; the watchdog guards the provider
       // stream, so pause it until the tool finishes. tools carry their own
-      // timeouts (bash 120s default, web tools via dredge)
+      // timeouts (bash 120s default)
       clearTimeout(watchdog)
       recorder.currentCall = event.call
       onStream?.(event)

package/src/controller.js

@@ -53,7 +53,7 @@ export const SESSION_COLORS = {
   gray: '#9ca3af',
 }
 
-const WORKER_TOOLS = ['read', 'write', 'edit', 'bash', 'glob', 'grep', 'shell_output', 'shell_kill', 'web_search', 'web_fetch']
+const WORKER_TOOLS = ['read', 'write', 'edit', 'bash', 'glob', 'grep', 'shell_output', 'shell_kill']
 const AGENT_TOOLS = ['agent_plan', 'agent_start', 'agent_list', 'agent_collect', 'agent_cancel']
 const CONTEXT_COLORS = ['#67b7ff', '#c792ea', '#f7c66a', '#f78c6c', '#6be795']
 
@@ -202,7 +202,9 @@ export function createController({ boot }) {
       const sessionId = state.session?.id
       if (!sessionId) throw new Error('worker requires an active session')
       const scratchpad = ensureDir(agentScratchDir(boot.root, sessionId, agent.id))
-      const requestedTools = agent.tools?.length ? agent.tools.filter((name) => WORKER_TOOLS.includes(name)) : WORKER_TOOLS
+      const mcpTools = boot.mcp.tools()
+      const availableNames = [...WORKER_TOOLS, ...mcpTools.map((tool) => tool.name)]
+      const requestedTools = agent.tools?.length ? agent.tools.filter((name) => availableNames.includes(name)) : availableNames
       const { tools, recorder } = createToolset({
         cwd: boot.cwd,
         env: { ...boot.env, PICO_SCRATCHPAD: scratchpad },
@@ -213,10 +215,10 @@ export function createController({ boot }) {
         shells: boot.shells,
         sessionId,
         sessionFile: state.session?.file,
-        dredge: boot.dredge,
         signal,
         maxToolCalls: 30,
         allowNames: requestedTools,
+        mcpTools,
       })
       return runTurn({
         history: [{ role: 'user', content: agent.prompt }],
@@ -277,6 +279,7 @@ export function createController({ boot }) {
 
       const runWorker = async ({ history, role, tools: enabled = true, onStream }) => {
         const scratchpad = ensureDir(agentScratchDir(boot.root, sessionId, `deliberation-${id}-${role}`))
+        const mcpTools = enabled ? boot.mcp.tools() : []
         const toolset = createToolset({
           cwd: boot.cwd,
           env: { ...boot.env, PICO_SCRATCHPAD: scratchpad },
@@ -284,10 +287,10 @@ export function createController({ boot }) {
           shells: boot.shells,
           sessionId,
           sessionFile: state.session?.file,
-          dredge: boot.dredge,
           signal,
           maxToolCalls: 30,
-          allowNames: enabled ? WORKER_TOOLS : [],
+          allowNames: enabled ? [...WORKER_TOOLS, ...mcpTools.map((tool) => tool.name)] : [],
+          mcpTools,
         })
         return runTurn({
           history,
@@ -622,7 +625,6 @@ export function createController({ boot }) {
       deliberations: boot.deliberationModel || (boot.proposerModel && boot.reviewerModel) ? deliberations : null,
       onAgentsCollected: discardCollectedAgentNotes,
       askUser,
-      dredge: boot.dredge,
       mcpTools: boot.mcp.tools(),
       userTools: userToolScan.tools,
       signal: controller.signal,
@@ -1216,7 +1218,6 @@ export function createController({ boot }) {
       shells: boot.shells,
       wakeups: boot.wakeups,
       memory: boot.memory,
-      dredge: boot.dredge,
       ...extra,
     })
   }

package/src/tools/index.js

@@ -5,10 +5,9 @@ import { createEdit } from './edit.js'
 import { createBash } from './bash.js'
 import { createGlob } from './glob.js'
 import { createGrep } from './grep.js'
-import { createWebTools } from './web.js'
 import { createView } from './view.js'
 
-export function createToolset({ cwd, env, tracker, skills, shells, sessionId, sessionFile, wakeups, memory, agents, deliberations, onAgentsCollected, askUser, dredge, mcpTools = [], userTools = [], hostTools = [], signal, maxToolCalls, maxAgentStarts, requireAgentPlan = false, allowNames, onToolUpdate, viewer }) {
+export function createToolset({ cwd, env, tracker, skills, shells, sessionId, sessionFile, wakeups, memory, agents, deliberations, onAgentsCollected, askUser, mcpTools = [], userTools = [], hostTools = [], signal, maxToolCalls, maxAgentStarts, requireAgentPlan = false, allowNames, onToolUpdate, viewer }) {
   const recorder = createRecorder(onToolUpdate)
   let agentStarts = 0
   let plannedAgentStarts = requireAgentPlan ? null : maxAgentStarts
@@ -25,10 +24,6 @@ export function createToolset({ cwd, env, tracker, skills, shells, sessionId, se
 
   if (viewer) local.push(createView({ ...deps, viewer }))
 
-  if (dredge) {
-    local.push(...createWebTools({ dredge, recorder, signal }))
-  }
-
   if (shells) {
     local.push(
       {
@@ -283,7 +278,7 @@ export function createToolset({ cwd, env, tracker, skills, shells, sessionId, se
     })
   }
 
-  const describedToolNames = new Set(['read', 'write', 'edit', 'bash', 'glob', 'grep', 'web_search', 'schedule_wakeup'])
+  const describedToolNames = new Set(['read', 'write', 'edit', 'bash', 'glob', 'grep', 'schedule_wakeup'])
   const describedTools = new Set(local.filter((tool) => describedToolNames.has(tool.name)).map((tool) => tool.name))
   const byName = new Map()
   for (const tool of [...local, ...hostTools, ...userTools, ...mcpTools]) {

package/src/tools/web.js

@@ -1,86 +0,0 @@
-import { describeParam } from './recorder.js'
-const DEFAULT_SLICE_CHARS = 24000
-const MAX_SLICE_CHARS = 100000
-
-export function resolveDredge(config = {}, env = process.env) {
-  const url = env.DREDGE_URL || config.dredge?.url || null
-  if (!url) return null
-  return {
-    url: url.replace(/\/+$/, ''),
-    apiKey: env.DREDGE_API_KEY || config.dredge?.apiKey || null,
-  }
-}
-
-const CALL_TIMEOUT_MS = 120000
-
-async function call(dredge, path, params, signal) {
-  const query = new URLSearchParams(params)
-  // bounded above dredge's own 90s queue ceiling so a wedged server becomes
-  // a tool error instead of a hung turn
-  const signals = [AbortSignal.timeout(CALL_TIMEOUT_MS), ...(signal ? [signal] : [])]
-  const response = await fetch(`${dredge.url}${path}?${query}`, {
-    signal: AbortSignal.any(signals),
-    headers: dredge.apiKey ? { authorization: `Bearer ${dredge.apiKey}` } : {},
-  })
-  const body = await response.json().catch(() => null)
-  if (!body) throw new Error(`dredge returned http ${response.status} with no usable body`)
-  return body
-}
-
-export function createWebTools({ dredge, recorder, signal }) {
-  return [
-    {
-      name: 'web_search',
-      description:
-        'Search the web. Google-style operators work: site:, filetype:pdf, quoted phrases. Returns ranked results; pass a result url to web_fetch to read it.',
-      schema: {
-        q: { type: 'string', description: 'the search query' },
-        description: describeParam,
-      },
-      execute: async ({ q }) => {
-        recorder.extra({ title: q })
-        const body = await call(dredge, '/search', { q }, signal)
-        if (!body.ok) throw new Error(body.error?.message || 'search failed')
-        const results = (body.results || []).map((r) => ({
-          title: r.title,
-          url: r.url,
-          snippet: r.snippet,
-          source: r.source,
-        }))
-        if (results.length === 0) {
-          const backends = (body.backends || []).map((b) => `${b.name}: ${b.status}`).join(', ')
-          return { results, note: backends ? `no results · backends: ${backends}` : 'no results' }
-        }
-        return { results }
-      },
-    },
-    {
-      name: 'web_fetch',
-      description:
-        'Fetch a url and read it as clean markdown (html, pdf, docx, and textual formats like json). Long documents arrive in slices: the result says which slice you have (e.g. "slice 1 of 12") and next_cursor continues from there. Every slice you fetch permanently occupies conversation context, so only walk cursors for content you actually need, and raise maxChars only when the task genuinely needs a bigger window.',
-      schema: {
-        description: describeParam,
-        url: { type: 'string', description: 'the url to fetch' },
-        cursor: { type: 'string', description: 'pagination cursor from a previous web_fetch of the same url', optional: true },
-        maxChars: { type: 'number', description: `slice size in characters, default ${DEFAULT_SLICE_CHARS}, max ${MAX_SLICE_CHARS}`, optional: true },
-      },
-      execute: async ({ url, cursor, maxChars }) => {
-        recorder.extra({ title: url.replace(/^https?:\/\//, '').slice(0, 80) })
-        const slice = Math.min(MAX_SLICE_CHARS, Math.max(1000, maxChars || DEFAULT_SLICE_CHARS))
-        const body = await call(dredge, '/fetch', { url, maxChars: slice, ...(cursor && { cursor }) }, signal)
-        if (!body.ok) {
-          const { code, message, retryable } = body.error || {}
-          throw new Error(`${code || 'fetch failed'}: ${message || url}${retryable ? ' (retryable)' : ''}`)
-        }
-        const { markdown, metadata, pagination } = body.doc
-        return {
-          markdown,
-          title: metadata?.title || null,
-          finalUrl: metadata?.final_url || url,
-          ...(pagination?.total_chunks > 1 && { slice: `${pagination.chunk_index + 1} of ${pagination.total_chunks}` }),
-          ...(pagination?.next_cursor && { next_cursor: pagination.next_cursor }),
-        }
-      },
-    },
-  ]
-}