picocode-core 0.9.173 → 0.9.175

package/package.json

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

package/src/agent-context.js

@@ -0,0 +1,39 @@
+import { readFile } from 'node:fs/promises'
+import { createContextTracker } from './context.js'
+import { buildSystemPrompt } from './system-prompt.js'
+import { memoryIndex } from './memory.js'
+
+export async function createAgentContext(boot, { userTools = [], isolated = false, instructions = '' } = {}) {
+  const files = [...boot.startupContext.files]
+  if (isolated) {
+    const known = new Set(files.map((file) => file.path))
+    for (const path of boot.tracker.loaded) {
+      if (known.has(path)) continue
+      const content = await readFile(path, 'utf8').catch(() => null)
+      if (content !== null) files.push({ path, content })
+    }
+  }
+  const tracker = isolated
+    ? createContextTracker({ stopDir: boot.startupContext.stopDir, loaded: new Set(files.map((file) => file.path)) })
+    : boot.tracker
+  const system = buildSystemPrompt({
+    cwd: boot.cwd,
+    contextFiles: files,
+    skills: boot.skills.list(),
+    memoryIndexText: memoryIndex(await boot.memory.list().catch(() => []), boot.root),
+  })
+  return {
+    system: instructions ? `${system}\n\n${instructions}` : system,
+    tools: {
+      cwd: boot.cwd,
+      env: boot.env,
+      tracker,
+      skills: boot.skills,
+      memory: boot.memory,
+      shells: boot.shells,
+      hostTools: (boot.hostTools ?? []).filter((tool) => !isolated || !tool.name.startsWith('browser_')),
+      userTools,
+      mcpTools: boot.mcp.tools(),
+    },
+  }
+}

package/src/controller.js

@@ -3,7 +3,7 @@ import { writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { makeEvent } from './events.js'
 import { createSession, createEphemeralSession, forkSession, openSession, loadSession, listSessions, deleteSession, appendSessionEvent, onSessionWriteError } from './session.js'
-import { createContextTracker } from './context.js'
+import { createAgentContext } from './agent-context.js'
 import { deriveState, userEntries, rewindStats } from './derive.js'
 import { appendPrompt } from './history.js'
 import { runTurn, summarizeText, compactHistory, compactProgress } from './agent.js'
@@ -11,6 +11,7 @@ import { createAgentManager } from './agents.js'
 import { runDeliberation, validateDeliberation } from './deliberation.js'
 import { deliberationsFromEvents } from './deliberation-history.js'
 import { compactionPrompt, formatCompactSummary, summarySections, compactionKeepFrom } from './compaction.js'
+import { completedToolCalls, TOOL_TRIM_VERSION } from './tool-trimming.js'
 import { createToolset } from './tools/index.js'
 import { defaultTitle } from './tools/recorder.js'
 import { scanUserTools } from './user-tools.js'
@@ -53,7 +54,6 @@ export const SESSION_COLORS = {
   gray: '#9ca3af',
 }
 
-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,23 +202,16 @@ 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 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 scan = await refreshProjectIndexes()
+      const context = await createAgentContext(boot, { userTools: scan.tools, isolated: true, instructions: workerSystemPrompt(scratchpad) })
       const { tools, recorder } = createToolset({
-        cwd: boot.cwd,
+        ...context.tools,
         env: { ...boot.env, PICO_SCRATCHPAD: scratchpad },
-        // a private tracker seeded from the main one: a worker may read an
-        // AGENTS.md the main agent has not seen, and consuming it from the
-        // shared set would mean the main agent never receives it
-        tracker: createContextTracker({ stopDir: boot.startupContext.stopDir, loaded: new Set(boot.tracker.loaded) }),
-        shells: boot.shells,
         sessionId,
         sessionFile: state.session?.file,
         signal,
         maxToolCalls: 30,
-        allowNames: requestedTools,
-        mcpTools,
+        allowNames: agent.tools?.length ? agent.tools : undefined,
       })
       return runTurn({
         history: [{ role: 'user', content: agent.prompt }],
@@ -227,7 +220,7 @@ export function createController({ boot }) {
         modelName: worker.name,
         effort: worker.effort ? 'low' : null,
         auth,
-        system: workerSystemPrompt(scratchpad),
+        system: context.system,
         signal,
         onStream,
       })
@@ -279,18 +272,16 @@ 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 scan = await refreshProjectIndexes()
+        const context = await createAgentContext(boot, { userTools: scan.tools, isolated: true, instructions: participantSystemPrompt(scratchpad) })
         const toolset = createToolset({
-          cwd: boot.cwd,
+          ...context.tools,
           env: { ...boot.env, PICO_SCRATCHPAD: scratchpad },
-          tracker: createContextTracker({ stopDir: boot.startupContext.stopDir, loaded: new Set(boot.tracker.loaded) }),
-          shells: boot.shells,
           sessionId,
           sessionFile: state.session?.file,
           signal,
           maxToolCalls: 30,
-          allowNames: enabled ? [...WORKER_TOOLS, ...mcpTools.map((tool) => tool.name)] : [],
-          mcpTools,
+          allowNames: enabled ? undefined : [],
         })
         return runTurn({
           history,
@@ -299,7 +290,7 @@ export function createController({ boot }) {
           modelName: roleWorkers[role].name,
           effort: roleWorkers[role].effort ? 'low' : null,
           auth: roleAuths[role],
-          system: participantSystemPrompt(scratchpad),
+          system: context.system,
           signal,
           onStream,
         })
@@ -609,24 +600,16 @@ export function createController({ boot }) {
     const { tracker } = boot
     const loadedBefore = new Set(tracker.loaded)
     const userToolScan = await refreshProjectIndexes()
-    const freshSkills = boot.skills
+    const context = await createAgentContext(boot, { userTools: userToolScan.tools })
     const { tools, recorder } = createToolset({
-      cwd: boot.cwd,
-      env: boot.env,
-      hostTools: boot.hostTools ?? [],
-      tracker,
-      skills: freshSkills,
-      shells: boot.shells,
+      ...context.tools,
       sessionId: state.session?.id,
       sessionFile: state.session?.file,
       wakeups: boot.wakeups,
-      memory: boot.memory,
       agents: boot.researchModel ? agents : null,
       deliberations: boot.deliberationModel || (boot.proposerModel && boot.reviewerModel) ? deliberations : null,
       onAgentsCollected: discardCollectedAgentNotes,
       askUser,
-      mcpTools: boot.mcp.tools(),
-      userTools: userToolScan.tools,
       signal: controller.signal,
       maxAgentStarts: researchAgentLimit ? 100 : undefined,
       requireAgentPlan: !!researchAgentLimit,
@@ -645,12 +628,7 @@ export function createController({ boot }) {
         modelName: state.model.name,
         effort: effortApplies() ? state.effort ?? 'auto' : null,
         auth,
-        system: buildSystemPrompt({
-          cwd: boot.cwd,
-          contextFiles: boot.startupContext.files,
-          skills: freshSkills.list(),
-          memoryIndexText: memoryIndex(await boot.memory.list().catch(() => []), boot.root),
-        }),
+        system: context.system,
         signal: controller.signal,
         onStream: streamHandler(recorder, controller),
       })
@@ -847,6 +825,29 @@ export function createController({ boot }) {
     flash(value ? `session color: ${names[values.indexOf(value)] || value}` : 'session color cleared')
   }
 
+  function changeToolTrims(type, callIds) {
+    if (state.busy || state.compacting) return flash('error: finish or interrupt the current turn first')
+    if (!Array.isArray(callIds) || !callIds.length || callIds.some((id) => typeof id !== 'string' || !id)) {
+      return flash('error: tool call IDs must be a non-empty array of strings')
+    }
+    const ids = [...new Set(callIds)]
+    const completed = completedToolCalls(state.derived.providerHistory)
+    const unavailable = ids.filter((id) => !completed.has(id))
+    if (unavailable.length) return flash(`error: tool calls are not completed in current context: ${unavailable.join(', ')}`)
+    persist(makeEvent(type, { callIds: ids, version: TOOL_TRIM_VERSION }))
+    ensureSession()
+    reDerive()
+    return true
+  }
+
+  function trimTools(callIds) {
+    return changeToolTrims('tool_trim', callIds)
+  }
+
+  function restoreTools(callIds) {
+    return changeToolTrims('tool_restore', callIds)
+  }
+
   function clear() {
     if (state.busy) return flash('finish or interrupt the current turn first')
     persist(makeEvent('clear', {}))
@@ -1366,6 +1367,8 @@ export function createController({ boot }) {
     send,
     interrupt,
     compact,
+    trimTools,
+    restoreTools,
     answerQuestion,
     cancelQuestion,
     recallPending,

package/src/derive.js

@@ -1,5 +1,6 @@
 import { continuationMessage } from './compaction.js'
 import { applySteering } from './steer.js'
+import { annotateToolContext, applyToolTrims } from './tool-trimming.js'
 
 const DROPPING_MODES = ['both', 'chat', 'summary']
 
@@ -178,6 +179,7 @@ export function deriveState(events) {
     loadedContext: new Set(),
     toolItems: new Map(),
     latestCompactIndex,
+    trimmedToolIds: new Set(),
   }
 
   for (const event of effectiveEvents) {
@@ -256,11 +258,20 @@ export function deriveState(events) {
         state.lastPromptTokens = 0
         break
       }
+      case 'tool_trim':
+        for (const callId of event.data.callIds || []) state.trimmedToolIds.add(callId)
+        state.lastPromptTokens = 0
+        break
+      case 'tool_restore':
+        for (const callId of event.data.callIds || []) state.trimmedToolIds.delete(callId)
+        state.lastPromptTokens = 0
+        break
       case 'clear':
         state.transcript = []
         state.providerHistory = []
         state.historyEventIds = []
         state.toolItems = new Map()
+        state.trimmedToolIds = new Set()
         state.lastPromptTokens = 0
         break
       case 'context_file':
@@ -287,7 +298,9 @@ export function deriveState(events) {
     }
   }
 
-  state.providerHistory = elideStaleToolResults(state.providerHistory)
+  const effectiveHistory = elideStaleToolResults(state.providerHistory)
+  state.providerHistory = applyToolTrims(effectiveHistory, state.trimmedToolIds)
+  annotateToolContext(state, state.providerHistory, state.trimmedToolIds)
   return state
 }
 

package/src/tool-trimming.js

@@ -0,0 +1,138 @@
+const ALGORITHM = 'tool-trim-v1'
+const ARGUMENT_CHARS = 8000
+const RESULT_CHARS = 12000
+const STRING_CHARS = 6000
+const ARRAY_ITEMS = 40
+const OBJECT_KEYS = 80
+const HEAD_RATIO = 0.6
+
+function truncateText(value, limit, label = 'content') {
+  const text = String(value ?? '')
+  if (text.length <= limit) return text
+  const marker = `\n[${label} omitted: ${text.length - limit} or more chars]\n`
+  const available = Math.max(0, limit - marker.length)
+  const head = Math.floor(available * HEAD_RATIO)
+  return text.slice(0, head) + marker + text.slice(text.length - (available - head))
+}
+
+function boundedValue(value, depth = 0) {
+  if (typeof value === 'string') return truncateText(value, STRING_CHARS)
+  if (value === null || typeof value !== 'object') return value
+  if (depth >= 8) return '[nested value omitted]'
+  if (Array.isArray(value)) {
+    if (value.length <= ARRAY_ITEMS) return value.map((item) => boundedValue(item, depth + 1))
+    const head = Math.ceil(ARRAY_ITEMS * HEAD_RATIO)
+    const tail = ARRAY_ITEMS - head
+    return [
+      ...value.slice(0, head).map((item) => boundedValue(item, depth + 1)),
+      `[${value.length - ARRAY_ITEMS} array items omitted]`,
+      ...value.slice(-tail).map((item) => boundedValue(item, depth + 1)),
+    ]
+  }
+  const entries = Object.entries(value)
+  const kept = entries.length <= OBJECT_KEYS
+    ? entries
+    : [...entries.slice(0, Math.ceil(OBJECT_KEYS * HEAD_RATIO)), ['_trimmed', `${entries.length - OBJECT_KEYS} object fields omitted`], ...entries.slice(-(OBJECT_KEYS - Math.ceil(OBJECT_KEYS * HEAD_RATIO)))]
+  return Object.fromEntries(kept.map(([key, item]) => [key, boundedValue(item, depth + 1)]))
+}
+
+function importantArguments(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return {}
+  return Object.fromEntries(['description', 'name', 'outcome'].filter((key) => key in value).map((key) => [key, boundedValue(value[key])]))
+}
+
+function trimArguments(raw) {
+  let parsed
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    parsed = { _raw: String(raw ?? '') }
+  }
+  let bounded = boundedValue(parsed)
+  let encoded = JSON.stringify(bounded)
+  if (encoded.length <= ARGUMENT_CHARS) return encoded
+  const important = importantArguments(parsed)
+  let previewLimit = ARGUMENT_CHARS
+  while (previewLimit > 0) {
+    encoded = JSON.stringify({ ...important, _trimmed: truncateText(JSON.stringify(parsed), previewLimit, 'arguments') })
+    if (encoded.length <= ARGUMENT_CHARS) return encoded
+    previewLimit = Math.floor(previewLimit / 2)
+  }
+  return JSON.stringify({ _trimmed: truncateText(JSON.stringify(parsed), 1000, 'arguments') })
+}
+
+function isImagePart(part) {
+  return part && typeof part === 'object' && (part.type === 'image' || part.type === 'image_url' || part.type === 'input_image' || part.source?.type === 'base64')
+}
+
+function trimResult(content) {
+  if (!Array.isArray(content)) return truncateText(content, RESULT_CHARS, 'tool result')
+  const safe = content.map((part) => isImagePart(part)
+    ? { type: 'text', text: '[tool image omitted to save context]' }
+    : boundedValue(part))
+  const encoded = JSON.stringify(safe)
+  return encoded.length <= RESULT_CHARS
+    ? safe
+    : [{ type: 'text', text: truncateText(encoded, RESULT_CHARS, 'tool result') }]
+}
+
+function callsIn(history) {
+  const calls = new Map()
+  history.forEach((message, index) => {
+    for (const call of message.tool_calls || []) calls.set(call.id, { call, callIndex: index, result: null, resultIndex: -1 })
+    if (message.role === 'tool') {
+      const entry = calls.get(message.tool_call_id)
+      if (entry) Object.assign(entry, { result: message, resultIndex: index })
+    }
+  })
+  return calls
+}
+
+export function completedToolCalls(history) {
+  return new Map([...callsIn(history)].filter(([, entry]) => entry.result))
+}
+
+export function applyToolTrims(history, trimmedIds) {
+  if (!trimmedIds.size) return history
+  const completed = completedToolCalls(history)
+  const callMessages = new Map()
+  const resultMessages = new Map()
+  for (const id of trimmedIds) {
+    const entry = completed.get(id)
+    if (!entry) continue
+    let callMessage = callMessages.get(entry.callIndex)
+    if (!callMessage) {
+      callMessage = { ...history[entry.callIndex], tool_calls: history[entry.callIndex].tool_calls.map((call) => ({ ...call, function: { ...call.function } })) }
+      callMessages.set(entry.callIndex, callMessage)
+    }
+    const call = callMessage.tool_calls.find((candidate) => candidate.id === id)
+    call.function.arguments = trimArguments(call.function.arguments)
+    resultMessages.set(entry.resultIndex, { ...entry.result, content: trimResult(entry.result.content) })
+  }
+  return history.map((message, index) => callMessages.get(index) || resultMessages.get(index) || message)
+}
+
+function resultText(content) {
+  if (typeof content === 'string') return content
+  if (Array.isArray(content)) return content.filter((part) => part.type === 'text').map((part) => part.text ?? '').join('\n')
+  return JSON.stringify(content ?? '')
+}
+
+export function annotateToolContext(state, effectiveHistory, trimmedIds) {
+  const completed = completedToolCalls(effectiveHistory)
+  for (const item of state.toolItems.values()) {
+    const entry = completed.get(item.callId)
+    item.contextAvailable = !!entry
+    item.contextTrimmed = !!entry && trimmedIds.has(item.callId)
+    item.contextTokens = entry
+      ? Math.ceil((String(entry.call.function.arguments ?? '').length + resultText(entry.result.content).length) / 4)
+      : 0
+  }
+}
+
+export const TOOL_TRIM_VERSION = {
+  algorithm: ALGORITHM,
+  argumentChars: ARGUMENT_CHARS,
+  resultChars: RESULT_CHARS,
+  stringChars: STRING_CHARS,
+}