remove easp and old parsing

Author: charleslien

common/src/tools/constants.ts

@@ -1,11 +1,11 @@
 import type { ToolResultOutput } from '../types/messages/content-part'
 import type z from 'zod/v4'
 
-export const toolNameParam = 'cb_tool_name'
-export const endsAgentStepParam = 'cb_easp'
-export const toolXmlName = 'codebuff_tool_call'
-export const startToolTag = `<${toolXmlName}>\n`
-export const endToolTag = `\n</${toolXmlName}>`
+// export const toolNameParam = 'cb_tool_name'
+// export const endsAgentStepParam = 'cb_easp'
+// export const toolXmlName = 'codebuff_tool_call'
+// export const startToolTag = `<${toolXmlName}>\n`
+// export const endToolTag = `\n</${toolXmlName}>`
 
 export const TOOLS_WHICH_WONT_FORCE_NEXT_STEP = [
   'think_deeply',

common/src/tools/utils.ts

@@ -1,31 +1,3 @@
-import {
-  endsAgentStepParam,
-  endToolTag,
-  startToolTag,
-  toolNameParam,
-} from './constants'
-import { $toolParams } from './list'
-
-import type { ToolName } from './constants'
-import type z from 'zod/v4'
-
-export function getToolCallString<T extends ToolName | (string & {})>(
-  toolName: T,
-  params: T extends ToolName
-    ? z.input<(typeof $toolParams)[T]['parameters']>
-    : Record<string, any>,
-  ...endsAgentStep: T extends ToolName ? [] : [boolean]
-): string {
-  const endsAgentStepValue =
-    toolName in $toolParams
-      ? $toolParams[toolName as keyof typeof $toolParams].endsAgentStep
-      : endsAgentStep[0] ?? false
-  const obj: Record<string, any> = {
-    [toolNameParam]: toolName,
-    ...params,
-  }
-  if (endsAgentStepValue) {
-    obj[endsAgentStepParam] = endsAgentStepValue satisfies true
-  }
-  return [startToolTag, JSON.stringify(obj, null, 2), endToolTag].join('')
+export function getToolCallString(toolName: string, input: any) {
+  return `<${toolName}>\n${(JSON.stringify(input), null, 2)}\n<\n${toolName}>`
 }

common/src/util/file.ts

@@ -44,7 +44,6 @@ export const customToolDefinitionsSchema = z
     z.string(),
     z.object({
       inputJsonSchema: z.any(),
-      endsAgentStep: z.boolean().optional().default(false),
       description: z.string().optional(),
       exampleInputs: z.record(z.string(), z.any()).array().optional(),
     }),

packages/agent-runtime/src/constants.ts

@@ -1,3 +0,0 @@
-import { endsAgentStepParam } from '@codebuff/common/tools/constants'
-
-export const globalStopSequence = `${JSON.stringify(endsAgentStepParam)}`

packages/agent-runtime/src/prompt-agent-stream.ts

@@ -1,5 +1,3 @@
-import { globalStopSequence } from './constants'
-
 import type { AgentTemplate } from './templates/types'
 import type { TrackEventFn } from '@codebuff/common/types/contracts/analytics'
 import type { SendActionFn } from '@codebuff/common/types/contracts/client'
@@ -77,7 +75,6 @@ export const getAgentStreamFromTemplate = (params: {
     runId,
     messages,
     model,
-    stopSequences: [globalStopSequence],
     clientSessionId,
     fingerprintId,
     userInputId,

packages/agent-runtime/src/run-programmatic-step.ts

@@ -1,4 +1,3 @@
-import { getToolCallString } from '@codebuff/common/tools/utils'
 import { getErrorObject } from '@codebuff/common/util/error'
 import { assistantMessage } from '@codebuff/common/util/messages'
 import { generateCompactId } from '@codebuff/common/util/string'
@@ -271,25 +270,18 @@ export async function runProgrammaticStep(
       const excludeToolFromMessageHistory = toolCall?.includeToolCall === false
       // Add assistant message with the tool call before executing it
       if (!excludeToolFromMessageHistory) {
-        const toolCallString = getToolCallString(
-          toolCall.toolName,
-          toolCall.input,
-        )
-        onResponseChunk(toolCallString)
+        onResponseChunk({
+          type: 'tool_call',
+          toolCallId: toolCall.toolCallId,
+          toolName: toolCall.toolName,
+          input: toolCall.input,
+        })
         state.messages.push(
           assistantMessage({
             ...toolCall,
             type: 'tool-call',
           }),
         )
-        // Optional call handles both top-level and nested agents
-        state.sendSubagentChunk?.({
-          userInputId,
-          agentId: state.agentState.agentId,
-          agentType: state.agentState.agentType!,
-          chunk: toolCallString,
-          forwardToPrompt: !state.agentState.parentId,
-        })
       }
 
       // Execute the tool synchronously and get the result immediately

packages/agent-runtime/src/templates/prompts.ts

@@ -1,12 +1,12 @@
-import { getAgentTemplate } from './agent-registry'
 import { buildArray } from '@codebuff/common/util/array'
 import { schemaToJsonStr } from '@codebuff/common/util/zod-schema'
 
+import { getAgentTemplate } from './agent-registry'
+
 import type { AgentTemplate } from '@codebuff/common/types/agent-template'
 import type { Logger } from '@codebuff/common/types/contracts/logger'
 import type { ParamsExcluding } from '@codebuff/common/types/function-params'
 import type { AgentTemplateType } from '@codebuff/common/types/session-state'
-import { getToolCallString } from '@codebuff/common/tools/utils'
 
 export async function buildSpawnableAgentsDescription(
   params: {
@@ -75,14 +75,19 @@ Notes:
 
 Example:
 
-${getToolCallString('spawn_agents', {
-  agents: [
-    {
-      agent_type: 'example-agent',
-      prompt: 'Do an example task for me',
-    },
-  ],
-})}
+${JSON.stringify(
+  {
+    agents: [
+      {
+        agent_type: 'example-agent',
+        prompt: 'Do an example task for me',
+      },
+    ],
+  },
+  null,
+  2,
+)}
+
 
 Spawn only the below agents:
 

packages/agent-runtime/src/templates/strings.ts

@@ -11,11 +11,6 @@ import {
   getProjectFileTreePrompt,
   getSystemInfoPrompt,
 } from '../system-prompt/prompts'
-import {
-  fullToolList,
-  getShortToolInstructions,
-  getToolsInstructions,
-} from '../tools/prompts'
 import { parseUserMessage } from '../util/messages'
 
 import type { AgentTemplate, PlaceholderValue } from './types'
@@ -110,8 +105,7 @@ export async function formatPrompt(
     [PLACEHOLDER.REMAINING_STEPS]: () => `${agentState.stepsRemaining!}`,
     [PLACEHOLDER.PROJECT_ROOT]: () => fileContext.projectRoot,
     [PLACEHOLDER.SYSTEM_INFO_PROMPT]: () => getSystemInfoPrompt(fileContext),
-    [PLACEHOLDER.TOOLS_PROMPT]: async () =>
-      getToolsInstructions(tools, await additionalToolDefinitions()),
+    [PLACEHOLDER.TOOLS_PROMPT]: async () => '',
     [PLACEHOLDER.AGENTS_PROMPT]: () => buildSpawnableAgentsDescription(params),
     [PLACEHOLDER.USER_CWD]: () => fileContext.cwd,
     [PLACEHOLDER.USER_INPUT_PROMPT]: () => escapeString(lastUserInput ?? ''),
@@ -203,15 +197,7 @@ export async function getAgentPrompt<T extends StringField>(
 
   // Add tool instructions, spawnable agents, and output schema prompts to instructionsPrompt
   if (promptType.type === 'instructionsPrompt' && agentState.agentType) {
-    const toolsInstructions = agentTemplate.inheritParentSystemPrompt
-      ? fullToolList(agentTemplate.toolNames, await additionalToolDefinitions())
-      : getShortToolInstructions(
-          agentTemplate.toolNames,
-          await additionalToolDefinitions(),
-        )
     addendum +=
-      '\n\n' +
-      toolsInstructions +
       '\n\n' +
       (await buildSpawnableAgentsDescription({
         ...params,

packages/agent-runtime/src/tool-stream-parser.ts

@@ -1,10 +1,4 @@
 import { AnalyticsEvent } from '@codebuff/common/constants/analytics-events'
-import {
-  endsAgentStepParam,
-  endToolTag,
-  startToolTag,
-  toolNameParam,
-} from '@codebuff/common/tools/constants'
 
 import type { Model } from '@codebuff/common/old-constants'
 import type { TrackEventFn } from '@codebuff/common/types/contracts/analytics'
@@ -15,13 +9,6 @@ import type {
   PrintModeText,
 } from '@codebuff/common/types/print-mode'
 
-const toolExtractionPattern = new RegExp(
-  `${startToolTag}(.*?)${endToolTag}`,
-  'gs',
-)
-
-const completionSuffix = `${JSON.stringify(endsAgentStepParam)}: true\n}${endToolTag}`
-
 export async function* processStreamWithTags(params: {
   stream: AsyncGenerator<StreamChunk, string | null>
   processors: Record<
@@ -60,83 +47,6 @@ export async function* processStreamWithTags(params: {
   let buffer = ''
   let autocompleted = false
 
-  function extractToolCalls(): string[] {
-    const matches: string[] = []
-    let lastIndex = 0
-    for (const match of buffer.matchAll(toolExtractionPattern)) {
-      if (match.index > lastIndex) {
-        onResponseChunk({
-          type: 'text',
-          text: buffer.slice(lastIndex, match.index),
-        })
-      }
-      lastIndex = match.index + match[0].length
-      matches.push(match[1])
-    }
-
-    buffer = buffer.slice(lastIndex)
-    return matches
-  }
-
-  function processToolCallContents(contents: string): void {
-    let input: any
-    try {
-      input = JSON.parse(contents)
-    } catch (error: any) {
-      trackEvent({
-        event: AnalyticsEvent.MALFORMED_TOOL_CALL_JSON,
-        userId: loggerOptions?.userId ?? '',
-        properties: {
-          contents: JSON.stringify(contents),
-          model: loggerOptions?.model,
-          agent: loggerOptions?.agentName,
-          error: {
-            name: error.name,
-            message: error.message,
-            stack: error.stack,
-          },
-          autocompleted,
-        },
-        logger,
-      })
-      const shortenedContents =
-        contents.length < 200
-          ? contents
-          : contents.slice(0, 100) + '...' + contents.slice(-100)
-      const errorMessage = `Invalid JSON: ${JSON.stringify(shortenedContents)}\nError: ${error.message}`
-      onResponseChunk({
-        type: 'error',
-        message: errorMessage,
-      })
-      onError('parse_error', errorMessage)
-      return
-    }
-
-    const toolName = input[toolNameParam] as keyof typeof processors
-    if (typeof toolName !== 'string') {
-      trackEvent({
-        event: AnalyticsEvent.UNKNOWN_TOOL_CALL,
-        userId: loggerOptions?.userId ?? '',
-        properties: {
-          contents,
-          toolName,
-          model: loggerOptions?.model,
-          agent: loggerOptions?.agentName,
-          autocompleted,
-        },
-        logger,
-      })
-      onError(
-        'parse_error',
-        `Unknown tool ${JSON.stringify(toolName)} for tool call: ${contents}`,
-      )
-      return
-    }
-
-    delete input[toolNameParam]
-    processToolCallObject({ toolName, input, contents })
-  }
-
   function processToolCallObject(params: {
     toolName: string
     input: any
@@ -164,18 +74,14 @@ export async function* processStreamWithTags(params: {
     processor.onTagEnd(toolName, input)
   }
 
-  function extractToolsFromBufferAndProcess(forceFlush = false) {
-    const matches = extractToolCalls()
-    matches.forEach(processToolCallContents)
-    if (forceFlush) {
-      if (buffer) {
-        onResponseChunk({
-          type: 'text',
-          text: buffer,
-        })
-      }
-      buffer = ''
+  function flush() {
+    if (buffer) {
+      onResponseChunk({
+        type: 'text',
+        text: buffer,
+      })
     }
+    buffer = ''
   }
 
   function* processChunk(
@@ -185,23 +91,13 @@ export async function* processStreamWithTags(params: {
       buffer += chunk.text
     }
     if (chunk && chunk.type === 'tool-call') {
-      extractToolsFromBufferAndProcess(true)
+      flush()
       processToolCallObject(chunk)
-    } else {
-      extractToolsFromBufferAndProcess()
     }
 
     if (chunk === undefined) {
       streamCompleted = true
-      if (buffer.includes(startToolTag)) {
-        buffer += completionSuffix
-        chunk = {
-          type: 'text',
-          text: completionSuffix,
-        }
-        autocompleted = true
-      }
-      extractToolsFromBufferAndProcess(true)
+      flush()
     }
 
     if (chunk) {