savant-code 0.0.17 → 0.0.19

package/packages/agent-runtime/src/util/messages.ts

@@ -0,0 +1,461 @@
+import { AssertionError } from 'assert'
+
+import { buildArray } from '@savant-code/common/util/array'
+import { getErrorObject } from '@savant-code/common/util/error'
+import { systemMessage, userMessage } from '@savant-code/common/util/messages'
+import { closeXml } from '@savant-code/common/util/xml'
+import { cloneDeep, isEqual } from 'lodash'
+
+import { simplifyTerminalCommandResults } from './simplify-tool-results'
+import { countTokensMessages } from './token-counter'
+
+import type { System } from '../llm-api/claude'
+import type {
+  SavantCodeToolMessage,
+  SavantCodeToolOutput,
+} from '@savant-code/common/tools/list'
+import type { Logger } from '@savant-code/common/types/contracts/logger'
+import type { JSONValue } from '@savant-code/common/types/json'
+import type {
+  TextPart,
+  ImagePart,
+} from '@savant-code/common/types/messages/content-part'
+import type { Message } from '@savant-code/common/types/messages/savant-code-message'
+
+export function messagesWithSystem(params: {
+  messages: Message[]
+  system: System
+}): Message[] {
+  const { messages, system } = params
+  return [systemMessage(system), ...messages]
+}
+
+export function asUserMessage(str: string): string {
+  return `<user_message>${str}${closeXml('user_message')}`
+}
+
+/**
+ * Combines prompt, params, and content into a unified message content structure.
+ * Always wraps the first text part in <user_message> tags for consistent XML framing.
+ * If you need a specific text part wrapped, put it first or pre-wrap it yourself before calling.
+ */
+export function buildUserMessageContent(
+  prompt: string | undefined,
+  params: Record<string, JSONValue> | undefined,
+  content?: Array<TextPart | ImagePart>,
+): Array<TextPart | ImagePart> {
+  const promptHasNonWhitespaceText = (prompt ?? '').trim().length > 0
+
+  // If we have content array (e.g., text + images)
+  if (content && content.length > 0) {
+    // Check if content has a non-empty text part
+    const firstTextPart = content.find((p): p is TextPart => p.type === 'text')
+    const hasNonEmptyText = firstTextPart && firstTextPart.text.trim()
+
+    // If content has no meaningful text but prompt is provided, prepend prompt
+    if (!hasNonEmptyText && promptHasNonWhitespaceText) {
+      const nonTextContent = content.filter((p) => p.type !== 'text')
+      return [
+        { type: 'text' as const, text: asUserMessage(prompt!) },
+        ...nonTextContent,
+      ]
+    }
+
+    // Find the first text part and wrap it in <user_message> tags
+    let hasWrappedText = false
+    const wrappedContent = content.map((part) => {
+      if (part.type === 'text' && !hasWrappedText) {
+        hasWrappedText = true
+        // Check if already wrapped
+        const alreadyWrapped = parseUserMessage(part.text) !== undefined
+        if (alreadyWrapped) {
+          return part
+        }
+        return {
+          type: 'text' as const,
+          text: asUserMessage(part.text),
+        }
+      }
+      return part
+    })
+    return wrappedContent
+  }
+
+  // Only prompt/params, combine and return as simple text
+  const textParts = buildArray([
+    promptHasNonWhitespaceText ? prompt : undefined,
+    params && JSON.stringify(params, null, 2),
+  ])
+  return [
+    {
+      type: 'text',
+      text: asUserMessage(textParts.join('\n\n')),
+    },
+  ]
+}
+
+export function parseUserMessage(str: string): string | undefined {
+  const match = str.match(/<user_message>(.*?)<\/user_message>/s)
+  return match ? match[1] : undefined
+}
+
+export function withSystemInstructionTags(str: string): string {
+  return `<system_instructions>${str}${closeXml('system_instructions')}`
+}
+
+export function withSystemTags(str: string): string {
+  return `<system>${str}${closeXml('system')}`
+}
+
+export function castAssistantMessage(message: Message): Message | null {
+  if (message.role !== 'assistant') {
+    return message
+  }
+  if (typeof message.content === 'string') {
+    return userMessage(
+      `<previous_assistant_message>${message.content}${closeXml('previous_assistant_message')}`,
+    )
+  }
+  const content = buildArray(
+    message.content.map((m) => {
+      if (m.type === 'text') {
+        return {
+          ...m,
+          text: `<previous_assistant_message>${m.text}${closeXml('previous_assistant_message')}`,
+        }
+      }
+      return null
+    }),
+  )
+  return content
+    ? {
+        role: 'user' as const,
+        content,
+      }
+    : null
+}
+
+// Number of terminal command outputs to keep in full form before simplifying
+const numTerminalCommandsToKeep = 5
+
+function simplifyTerminalHelper(params: {
+  toolResult: SavantCodeToolOutput<'run_terminal_command'>
+  numKept: number
+  logger: Logger
+}): { result: SavantCodeToolOutput<'run_terminal_command'>; numKept: number } {
+  const { toolResult, numKept, logger } = params
+  const simplified = simplifyTerminalCommandResults({
+    messageContent: toolResult,
+    logger,
+  })
+
+  // Keep the full output for the N most recent commands
+  if (numKept < numTerminalCommandsToKeep && !isEqual(simplified, toolResult)) {
+    return { result: toolResult, numKept: numKept + 1 }
+  }
+
+  return {
+    result: simplified,
+    numKept,
+  }
+}
+
+// Factor to reduce token count target by, to leave room for new messages
+const shortenedMessageTokenFactor = 0.5
+const replacementMessage = userMessage(
+  withSystemTags('Previous message(s) omitted due to length'),
+)
+
+/**
+ * Trims messages from the beginning to fit within token limits while preserving
+ * important content. Also simplifies terminal command outputs to save tokens.
+ *
+ * The function:
+ * 1. Processes messages from newest to oldest
+ * 2. Simplifies terminal command outputs after keeping N most recent ones
+ * 3. Stops adding messages when approaching token limit
+ *
+ * @param messages - Array of messages to trim
+ * @param systemTokens - Number of tokens used by system prompt
+ * @param maxTotalTokens - Maximum total tokens allowed, defaults to 200k
+ * @returns Trimmed array of messages that fits within token limit
+ */
+export function trimMessagesToFitTokenLimit(params: {
+  messages: Message[]
+  systemTokens: number
+  maxTotalTokens?: number
+  logger: Logger
+}): Message[] {
+  const { messages, systemTokens, maxTotalTokens = 190_000, logger } = params
+  const maxMessageTokens = maxTotalTokens - systemTokens
+
+  // Check if we're already under the limit
+  const initialTokens = countTokensMessages(messages)
+
+  if (initialTokens < maxMessageTokens) {
+    return messages
+  }
+
+  const shortenedMessages: Message[] = []
+  let numKept = 0
+
+  // Process messages from newest to oldest
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i]
+    if (m.role === 'system' || m.role === 'user' || m.role === 'assistant') {
+      shortenedMessages.push(m)
+    } else if (m.role === 'tool') {
+      if (m.toolName !== 'run_terminal_command') {
+        shortenedMessages.push(m)
+        continue
+      }
+
+      const terminalResultMessage = cloneDeep(
+        m,
+      ) as SavantCodeToolMessage<'run_terminal_command'>
+
+      const result = simplifyTerminalHelper({
+        toolResult: terminalResultMessage.content,
+        numKept,
+        logger,
+      })
+      terminalResultMessage.content = result.result
+      numKept = result.numKept
+
+      shortenedMessages.push(terminalResultMessage)
+    } else {
+      m satisfies never
+      throw new AssertionError({
+        message: `Not a valid role: ${(m as { role: unknown }).role}`,
+      })
+    }
+  }
+  shortenedMessages.reverse()
+
+  const requiredTokens = countTokensMessages(
+    shortenedMessages.filter((m) => m.keepDuringTruncation),
+  )
+  let removedTokens = 0
+  const tokensToRemove =
+    (maxMessageTokens - requiredTokens) * (1 - shortenedMessageTokenFactor)
+
+  const placeholder = 'deleted'
+  const filteredMessages: (Message | typeof placeholder)[] = []
+  for (const message of shortenedMessages) {
+    if (removedTokens >= tokensToRemove || message.keepDuringTruncation) {
+      filteredMessages.push(message)
+      continue
+    }
+    removedTokens += countTokensMessages([message])
+    if (
+      filteredMessages.length === 0 ||
+      filteredMessages[filteredMessages.length - 1] !== placeholder
+    ) {
+      filteredMessages.push(placeholder)
+      removedTokens -= countTokensMessages([replacementMessage])
+    }
+  }
+
+  return filteredMessages.map((m) =>
+    m === placeholder ? replacementMessage : m,
+  )
+}
+
+export function getMessagesSubset(params: {
+  messages: Message[]
+  otherTokens: number
+  logger: Logger
+}): Message[] {
+  const { messages, otherTokens, logger } = params
+  const messagesSubset = trimMessagesToFitTokenLimit({
+    messages,
+    systemTokens: otherTokens,
+    logger,
+  })
+
+  // Remove cache_control from all messages
+  for (const message of messagesSubset) {
+    for (const provider of [
+      'anthropic',
+      'openrouter',
+      'savant-code',
+    ] as const) {
+      delete message.providerOptions?.[provider]?.cacheControl
+    }
+  }
+
+  // Cache up to the last message!
+  const lastMessage = messagesSubset[messagesSubset.length - 1]
+  if (!lastMessage) {
+    logger.debug(
+      {
+        messages,
+        messagesSubset,
+        otherTokens,
+      },
+      'No last message found in messagesSubset!',
+    )
+  }
+
+  return messagesSubset
+}
+
+export function expireMessages(
+  messages: Message[],
+  endOf: 'agentStep' | 'userPrompt',
+): Message[] {
+  return messages.filter((m) => {
+    // Keep messages with no timeToLive
+    if (m.timeToLive === undefined) return true
+
+    // Remove messages that have expired
+    if (m.timeToLive === 'agentStep') return false
+    if (m.timeToLive === 'userPrompt' && endOf === 'userPrompt') return false
+
+    return true
+  })
+}
+
+/**
+ * Removes tool calls from the message history that don't have corresponding tool responses.
+ * This is important when passing message history to spawned agents, as unfinished tool calls
+ * will cause issues with the LLM expecting tool responses.
+ *
+ * The function:
+ * 1. Collects all toolCallIds from tool response messages
+ * 2. Filters assistant messages to remove tool-call content parts without responses
+ * 3. Removes assistant messages that become empty after filtering
+ */
+export function filterUnfinishedToolCalls(messages: Message[]): Message[] {
+  // Collect all toolCallIds that have corresponding tool responses
+  const respondedToolCallIds = new Set<string>()
+  for (const message of messages) {
+    if (message.role === 'tool') {
+      respondedToolCallIds.add(message.toolCallId)
+    }
+  }
+
+  // Filter messages, removing unfinished tool calls from assistant messages
+  const filteredMessages: Message[] = []
+  for (const message of messages) {
+    if (message.role !== 'assistant') {
+      filteredMessages.push(message)
+      continue
+    }
+
+    // Filter out tool-call content parts that don't have responses
+    const filteredContent = message.content.filter((part) => {
+      if (part.type !== 'tool-call') {
+        return true
+      }
+      return respondedToolCallIds.has(part.toolCallId)
+    })
+
+    // Only include the assistant message if it has content after filtering
+    if (filteredContent.length > 0) {
+      filteredMessages.push({
+        ...message,
+        content: filteredContent,
+      })
+    }
+  }
+
+  return filteredMessages
+}
+
+export function getEditedFiles(params: {
+  messages: Message[]
+  logger: Logger
+}): string[] {
+  const { messages, logger } = params
+  return buildArray(
+    messages
+      .filter(
+        (
+          m,
+        ): m is SavantCodeToolMessage<
+          'create_plan' | 'str_replace' | 'write_file'
+        > => {
+          return (
+            m.role === 'tool' &&
+            (m.toolName === 'create_plan' ||
+              m.toolName === 'str_replace' ||
+              m.toolName === 'write_file')
+          )
+        },
+      )
+      .map((m) => {
+        try {
+          const fileInfo = m.content[0].value
+          if ('errorMessage' in fileInfo) {
+            return null
+          }
+          return fileInfo.file
+        } catch (error) {
+          logger.error(
+            { error: getErrorObject(error), m },
+            'Error parsing file info',
+          )
+          return null
+        }
+      }),
+  )
+}
+
+export function getPreviouslyReadFiles(params: {
+  messages: Message[]
+  logger: Logger
+}): {
+  path: string
+  content: string
+  referencedBy?: Record<string, string[]>
+}[] {
+  const { messages, logger } = params
+  const files: ReturnType<typeof getPreviouslyReadFiles> = []
+  for (const message of messages) {
+    if (message.role !== 'tool') continue
+    if (message.toolName === 'read_files') {
+      try {
+        files.push(
+          ...(
+            message as SavantCodeToolMessage<'read_files'>
+          ).content[0].value.filter(
+            (
+              file,
+            ): file is typeof file & { contentOmittedForLength: undefined } =>
+              !('contentOmittedForLength' in file),
+          ),
+        )
+      } catch (error) {
+        logger.error(
+          { error: getErrorObject(error), message },
+          'Error parsing read_files output from message',
+        )
+      }
+    }
+
+    if (message.toolName === 'find_files') {
+      try {
+        const v = (message as SavantCodeToolMessage<'find_files'>).content[0]
+          .value
+        if ('message' in v) {
+          continue
+        }
+        files.push(
+          ...v.filter(
+            (
+              file,
+            ): file is typeof file & { contentOmittedForLength: undefined } =>
+              !('contentOmittedForLength' in file),
+          ),
+        )
+      } catch (error) {
+        logger.error(
+          { error: getErrorObject(error), message },
+          'Error parsing find_files output from message',
+        )
+      }
+    }
+  }
+  return files
+}

package/packages/agent-runtime/src/util/parse-tool-calls-from-text.ts

@@ -0,0 +1,122 @@
+import {
+  startToolTag,
+  endToolTag,
+  toolNameParam,
+} from '@savant-code/common/tools/constants'
+
+import type { JSONValue } from '@savant-code/common/types/json'
+
+export type ParsedToolCallFromText = {
+  type: 'tool_call'
+  toolName: string
+  input: Record<string, JSONValue>
+}
+
+export type ParsedTextSegment = {
+  type: 'text'
+  text: string
+}
+
+export type ParsedSegment = ParsedToolCallFromText | ParsedTextSegment
+
+/**
+ * Parses text containing tool calls in the <savant_code_tool_call> XML format,
+ * returning interleaved text and tool call segments in order.
+ *
+ * Example input:
+ * ```
+ * Some text before
+ * <savant_code_tool_call>
+ * {
+ *   "cb_tool_name": "read_files",
+ *   "paths": ["file.ts"]
+ * }
+ * </savant_code_tool_call>
+ * Some text after
+ * ```
+ *
+ * @param text - The text containing tool calls in XML format
+ * @returns Array of segments (text and tool calls) in order of appearance
+ */
+export function parseTextWithToolCalls(text: string): ParsedSegment[] {
+  const segments: ParsedSegment[] = []
+
+  // Match <savant_code_tool_call>...</savant_code_tool_call> blocks
+  const toolExtractionPattern = new RegExp(
+    `${escapeRegex(startToolTag)}([\\s\\S]*?)${escapeRegex(endToolTag)}`,
+    'gs',
+  )
+
+  let lastIndex = 0
+
+  for (const match of text.matchAll(toolExtractionPattern)) {
+    // Add any text before this tool call
+    if (match.index !== undefined && match.index > lastIndex) {
+      const textBefore = text.slice(lastIndex, match.index).trim()
+      if (textBefore) {
+        segments.push({ type: 'text', text: textBefore })
+      }
+    }
+
+    const jsonContent = match[1].trim()
+
+    try {
+      const parsed = JSON.parse(jsonContent)
+      const toolName = parsed[toolNameParam]
+
+      if (typeof toolName === 'string') {
+        // Remove the tool name param from the input
+        const input = { ...parsed }
+        delete input[toolNameParam]
+
+        // Also remove cb_easp if present
+        delete input['cb_easp']
+
+        segments.push({
+          type: 'tool_call',
+          toolName,
+          input,
+        })
+      }
+    } catch {
+      // Skip malformed JSON - don't add segment
+    }
+
+    // Update lastIndex to after this match
+    if (match.index !== undefined) {
+      lastIndex = match.index + match[0].length
+    }
+  }
+
+  // Add any remaining text after the last tool call
+  if (lastIndex < text.length) {
+    const textAfter = text.slice(lastIndex).trim()
+    if (textAfter) {
+      segments.push({ type: 'text', text: textAfter })
+    }
+  }
+
+  return segments
+}
+
+/**
+ * Parses tool calls from text in the <savant_code_tool_call> XML format.
+ * This is a convenience function that returns only tool calls (no text segments).
+ *
+ * @param text - The text containing tool calls in XML format
+ * @returns Array of parsed tool calls with toolName and input
+ */
+export function parseToolCallsFromText(
+  text: string,
+): Omit<ParsedToolCallFromText, 'type'>[] {
+  return parseTextWithToolCalls(text)
+    .filter(
+      (segment): segment is ParsedToolCallFromText =>
+        segment.type === 'tool_call',
+    )
+    .map(({ toolName, input }) => ({ toolName, input }))
+}
+
+function escapeRegex(string: string): string {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}

package/packages/agent-runtime/src/util/render-read-files-result.ts

@@ -0,0 +1,18 @@
+export interface TokenCallerMap {
+  [filePath: string]: {
+    [token: string]: string[] // Array of files that call this token
+  }
+}
+
+export function renderReadFilesResult(
+  files: { path: string; content: string }[],
+  tokenCallers: TokenCallerMap,
+) {
+  return files.map((file) => {
+    return {
+      path: file.path,
+      content: file.content,
+      referencedBy: tokenCallers[file.path] ?? {},
+    }
+  })
+}

package/packages/agent-runtime/src/util/simplify-tool-results.ts

@@ -0,0 +1,61 @@
+import { getErrorObject } from '@savant-code/common/util/error'
+import { cloneDeep } from 'lodash'
+
+import type { SavantCodeToolOutput } from '@savant-code/common/tools/list'
+import type { Logger } from '@savant-code/common/types/contracts/logger'
+
+export function simplifyReadFileResults(
+  messageContent: SavantCodeToolOutput<'read_files'>,
+): SavantCodeToolOutput<'read_files'> {
+  return [
+    {
+      type: 'json',
+      value: cloneDeep(messageContent[0]).value.map(({ path }) => {
+        return {
+          path,
+          contentOmittedForLength: true,
+        }
+      }),
+    },
+  ]
+}
+
+export function simplifyTerminalCommandResults(params: {
+  messageContent: SavantCodeToolOutput<'run_terminal_command'>
+  logger: Logger
+}): SavantCodeToolOutput<'run_terminal_command'> {
+  const { messageContent, logger } = params
+  try {
+    const clone = cloneDeep(messageContent)
+    const content = clone[0].value
+    if ('processId' in content || 'errorMessage' in content) {
+      return clone
+    }
+    const { command, message, exitCode } = content
+    return [
+      {
+        type: 'json',
+        value: {
+          command,
+          ...(message && { message }),
+          stdoutOmittedForLength: true,
+          ...(exitCode !== undefined && { exitCode }),
+        },
+      },
+    ]
+  } catch (error) {
+    logger.error(
+      { error: getErrorObject(error), messageContent },
+      'Error simplifying terminal command results',
+    )
+    return [
+      {
+        type: 'json',
+        value: {
+          command: '',
+          stdoutOmittedForLength: true,
+        },
+      },
+    ]
+  }
+}