savant-code 0.0.19 → 0.0.21

package/packages/agent-runtime/src/util/__tests__/token-counter.test.ts

@@ -1,121 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import {
-  countTokens,
-  countTokensJson,
-  countTokensMessages,
-} from '../token-counter'
-
-import type { JSONValue } from '@savant-code/common/types/json'
-import type { Message } from '@savant-code/common/types/messages/savant-code-message'
-
-describe('countTokensMessages', () => {
-  test('counts text content plus per-message overhead', () => {
-    const messages = [
-      { role: 'user', content: [{ type: 'text', text: 'hello world' }] },
-    ] as unknown as Message[]
-
-    const count = countTokensMessages(messages)
-    // At least the text tokens; overhead makes it strictly greater.
-    expect(count).toBeGreaterThan(countTokens('hello world'))
-  })
-
-  test('counts tool-call inputs and tool-result payloads', () => {
-    const messages = [
-      {
-        role: 'assistant',
-        content: [
-          { type: 'text', text: 'reading' },
-          {
-            type: 'tool-call',
-            toolCallId: '1',
-            toolName: 'read_files',
-            input: { paths: ['a.ts', 'b.ts'] },
-          },
-        ],
-      },
-      {
-        role: 'tool',
-        toolCallId: '1',
-        toolName: 'read_files',
-        content: [{ type: 'json', value: { files: ['contents here'] } }],
-      },
-    ] as unknown as Message[]
-
-    expect(countTokensMessages(messages)).toBeGreaterThan(0)
-  })
-
-  test('is cheaper than JSON.stringify counting for structured messages', () => {
-    const codeBlock = 'const x = "a \\"b\\" c";\n'.repeat(50)
-    const messages = [
-      {
-        role: 'tool',
-        toolCallId: '1',
-        toolName: 'read_files',
-        content: [
-          { type: 'json', value: { path: 'x.ts', content: codeBlock } },
-        ],
-      },
-      { role: 'user', content: [{ type: 'text', text: codeBlock }] },
-    ] as unknown as Message[]
-
-    // Structured counting removes the JSON envelope for text parts, so it must
-    // not exceed the whole-array JSON count.
-    expect(countTokensMessages(messages)).toBeLessThanOrEqual(
-      countTokensJson(messages as unknown as JSONValue),
-    )
-  })
-
-  test('does NOT count image/file base64 as text (uses a fixed estimate)', () => {
-    const bigB64 = 'A'.repeat(500_000)
-    const messages = [
-      {
-        role: 'user',
-        content: [
-          { type: 'text', text: 'screenshot:' },
-          { type: 'image', image: bigB64, mediaType: 'image/png' },
-        ],
-      },
-      {
-        role: 'tool',
-        toolCallId: '1',
-        toolName: 'browser',
-        content: [{ type: 'media', data: bigB64, mediaType: 'image/png' }],
-      },
-    ] as unknown as Message[]
-
-    const count = countTokensMessages(messages)
-    // Two images at a ~1600-token ceiling each, plus a little text/overhead —
-    // nowhere near the ~hundreds-of-thousands of tokens the base64 would add.
-    expect(count).toBeLessThan(10_000)
-  })
-
-  test('tolerates string content without iterating characters', () => {
-    const text = 'a plain string message content'
-    const messages = [{ role: 'user', content: text }] as unknown as Message[]
-
-    // Must count the string as one blob, not char-by-char via the default case.
-    expect(countTokensMessages(messages)).toBeGreaterThan(countTokens(text))
-    expect(countTokensMessages(messages)).toBeLessThan(countTokens(text) + 100)
-  })
-
-  test('does not throw on missing/non-array content', () => {
-    const messages = [
-      { role: 'assistant' },
-      { role: 'user', content: undefined },
-    ] as unknown as Message[]
-
-    expect(() => countTokensMessages(messages)).not.toThrow()
-  })
-
-  test('falls back to JSON for unknown part shapes so it never under-counts', () => {
-    const messages = [
-      {
-        role: 'user',
-        content: [{ type: 'mystery', payload: 'some meaningful content here' }],
-      },
-    ] as unknown as Message[]
-
-    expect(countTokensMessages(messages)).toBeGreaterThan(0)
-  })
-})

package/packages/agent-runtime/src/util/activity-tracking.ts

@@ -1,252 +0,0 @@
-/**
- * Activity tracking helpers — FID-2026-0718-009.
- *
- * Three concerns:
- *   1. setActivity         — mutate agentState.activity + emit chunk event
- *   2. bumpActivityIdleTimer — heartbeat that auto-idles after 5s of inactivity
- *   3. extractAllowlistedTarget — safe display string per tool from allowlist
- *
- * Security: only allowlisted target fields per tool are ever surfaced to the UI.
- * Free-form text fields (content, notes, description, ...) are NEVER included.
- * Hard truncation at 30 chars + '…' suffix.
- */
-
-import type { JSONValue } from '@savant-code/common/types/json'
-import type { PrintModeEvent } from '@savant-code/common/types/print-mode'
-import type {
-  AgentActivity,
-  AgentState,
-} from '@savant-code/common/types/session-state'
-
-const DEFAULT_IDLE_TIMEOUT_MS = 5000
-const TARGET_DISPLAY_MAX = 30
-
-/**
- * Per-tool allowlist of safe input fields to extract for activity display.
- * Adding a tool here is safe ONLY when the listed field is non-sensitive.
- * Don't add fields that could contain user PII, secrets, file contents, etc.
- */
-const ALLOWLISTED_TARGET_FIELDS: Partial<Record<string, string>> = {
-  bash: 'command',
-  run_terminal_command: 'command',
-  write_file: 'path',
-  str_replace: 'path',
-  propose_write_file: 'path',
-  apply_patch: 'path',
-  propose_str_replace: 'path',
-  code_search: 'pattern',
-  grep: 'pattern',
-  find_files: 'pattern',
-  glob: 'pattern',
-  list_directory: 'path',
-  web_search: 'query',
-  read_docs: 'query',
-  read_files: 'paths',
-  read_subtree: 'paths',
-  read_url: 'url',
-  ask_user: '',
-  lookup_agent_info: 'agentId',
-  set_output: '',
-  suggest_followups: '',
-  render_ui: '',
-  get_file_reading_updates: '',
-  task_completed: '',
-  add_subgoal: '',
-  update_subgoal: '',
-  create_plan: '',
-  end_turn: '',
-  spawn_inline_subagent: 'agentType',
-  spawn_agents: 'agents',
-  browser_logs: '',
-  compositor: '',
-  savant_code_terminal_command: 'command',
-  skill: 'name',
-  read_subtree_exa: 'path',
-  list_files_in_blob: 'path',
-  glob_exa: 'pattern',
-  find_files_by_query: 'query',
-  find_files_exa: 'pattern',
-  websearch_with_date: 'query',
-  web_search_simple: 'query',
-  researcher: 'query',
-  write_file_to_blob: 'path',
-  validate_agents: '',
-  apply_migration: '',
-  find_unused_files: 'path',
-  find_files_for_line_range: 'pattern',
-  list_branches: '',
-  search_semantic: 'pattern',
-  map_repo_structure: 'path',
-  read_file_with_line_range: 'paths',
-  read_multiple_files_with_line_range: 'paths',
-}
-
-function truncate(s: string, max: number = TARGET_DISPLAY_MAX): string {
-  return s.length > max ? `${s.slice(0, max - 1)}…` : s
-}
-
-/**
- * Extract a safe, abbreviated target string from a tool's structured input.
- * Returns undefined when:
- *   - the tool has no allowlisted field,
- *   - the input is missing the allowlisted field,
- *   - the input contains a sensitive-style free-form field with no safe field.
- */
-export function extractAllowlistedTarget(
-  toolName: string,
-  input: Record<string, JSONValue> | null | undefined,
-): string | undefined {
-  if (!input) return undefined
-  const field = ALLOWLISTED_TARGET_FIELDS[toolName] ?? null
-  if (field === null) return undefined
-  if (field === '') return undefined
-
-  // spawn_agents special: show first agent_type only
-  if (toolName === 'spawn_agents') {
-    const agents = input.agents
-    if (Array.isArray(agents) && agents.length > 0) {
-      const first = agents[0]
-      if (first && typeof first === 'object') {
-        const agentType = (first as Record<string, JSONValue>).agent_type
-        if (typeof agentType === 'string') return truncate(agentType)
-      }
-    }
-    return undefined
-  }
-
-  // spawn_inline_subagent: show agentType
-  if (toolName === 'spawn_inline_subagent') {
-    const v = input[field]
-    if (typeof v === 'string') return truncate(v)
-    return undefined
-  }
-
-  // List-style fields (read_files, read_subtree): show first element
-  if (field === 'paths') {
-    const v = input.paths
-    if (Array.isArray(v) && v.length > 0 && typeof v[0] === 'string') {
-      return truncate(v[0])
-    }
-    if (typeof v === 'string') return truncate(v)
-    return undefined
-  }
-
-  const v = input[field]
-  if (typeof v === 'string') return truncate(v)
-  return undefined
-}
-
-type OnChunk = (chunk: string | PrintModeEvent) => void
-
-/**
- * Set agentState.activity (mutates in place) and emit a chunk so the CLI
- * subscriber gets the update. Also bumps the idle timer.
- *
- * Pass `parentAgentId` when this mutator is called from a sub-agent's parent
- * view (writes the activity through both layers).
- */
-export function setActivity(
-  agentState: AgentState,
-  activity: AgentActivity,
-  onChunk?: OnChunk,
-): void {
-  agentState.activity = activity
-  // Fast-path: clear pending timer when transitioning to idle, so the
-  // closure isn't held for 5s past 'idle'. (The timer can still fire even
-  // after agentState is GC-eligible, preventing Map/Object cleanup.)
-  if (activity.kind === 'idle' && agentState.activityIdleTimer) {
-    clearTimeout(agentState.activityIdleTimer)
-    agentState.activityIdleTimer = undefined
-  } else if (activity.kind !== 'idle') {
-    bumpActivityIdleTimer(agentState)
-  }
-
-  if (onChunk) {
-    try {
-      onChunk({
-        type: 'activity',
-        activity,
-        agentId: agentState.agentId,
-        parentAgentId: agentState.parentId,
-      })
-    } catch {
-      // activity chunk emits are best-effort — never derail the tool call
-    }
-  }
-}
-
-/**
- * Reset the idle timer. On expiry, transition activity to 'idle' unless
- * it's already idle. Single timer per session — cleared-before-set.
- */
-export function bumpActivityIdleTimer(
-  agentState: AgentState,
-  timeoutMs: number = DEFAULT_IDLE_TIMEOUT_MS,
-): void {
-  if (agentState.activityIdleTimer) {
-    clearTimeout(agentState.activityIdleTimer)
-  }
-  agentState.activityIdleTimer = setTimeout(() => {
-    const a = agentState.activity
-    if (!a || a.kind !== 'idle') {
-      agentState.activity = { kind: 'idle', since: Date.now() }
-    }
-    agentState.activityIdleTimer = undefined
-  }, timeoutMs)
-}
-
-/**
- * Build an `AgentActivity` payload for a tool dispach event.
- * Used by tool-executor at M1 (tool_call) and to handle research-tool cases (M6).
- */
-export function toolActivity(
-  agentState: AgentState,
-  toolName: string,
-  input: Record<string, JSONValue> | null | undefined,
-  onChunk?: OnChunk,
-): AgentActivity {
-  const target = extractAllowlistedTarget(toolName, input)
-
-  // web_search & read_docs are surfaced as 'researching' (a richer signal)
-  if (
-    toolName === 'web_search' ||
-    toolName === 'read_docs' ||
-    toolName === 'researcher' ||
-    toolName === 'websearch_with_date' ||
-    toolName === 'web_search_simple'
-  ) {
-    const query = typeof input?.query === 'string' ? input.query : ''
-    const activity: AgentActivity = {
-      kind: 'researching',
-      query: truncate(query, 60),
-      startedAt: Date.now(),
-      source: toolName === 'read_docs' ? 'docs' : 'web',
-    }
-    setActivity(agentState, activity, onChunk)
-    return activity
-  }
-
-  if (toolName === 'spawn_agents' || toolName === 'spawn_inline_subagent') {
-    const firstAgentType =
-      Array.isArray(input?.agents) && input.agents.length > 0
-        ? (input.agents[0] as Record<string, JSONValue>)?.agent_type
-        : undefined
-    const activity: AgentActivity = {
-      kind: 'subagent',
-      agentType:
-        typeof firstAgentType === 'string' ? firstAgentType : 'subagent',
-      startedAt: Date.now(),
-    }
-    setActivity(agentState, activity, onChunk)
-    return activity
-  }
-
-  const activity: AgentActivity = {
-    kind: 'tool',
-    toolName,
-    startedAt: Date.now(),
-    ...(target ? { target } : {}),
-  }
-  setActivity(agentState, activity, onChunk)
-  return activity
-}

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

@@ -1,102 +0,0 @@
-import type { AgentTemplate } from '@savant-code/common/types/agent-template'
-import type { Message } from '@savant-code/common/types/messages/savant-code-message'
-import type {
-  AgentState,
-  AgentOutput,
-} from '@savant-code/common/types/session-state'
-
-/** Messages tagged with these tags are stripped from agent output. */
-const EXCLUDED_OUTPUT_TAGS = ['TOOL_CALL_ERROR'] as const
-
-function isExcludedFromOutput(message: Message): boolean {
-  return !!message.tags?.some((t) =>
-    (EXCLUDED_OUTPUT_TAGS as readonly string[]).includes(t),
-  )
-}
-
-/**
- * Get the last assistant turn messages, which includes the last assistant
- * message and any subsequent tool messages that are responses to its tool
- * calls.
- *
- * Turn selection walks the raw `messageHistory` so that user-role messages
- * (including synthesized TOOL_CALL_ERROR ones) correctly bound the turn —
- * otherwise a failed attempt + its retry would get conflated into a single
- * "turn". Exclusion filtering is applied *after* selection: TOOL_CALL_ERROR
- * messages are user-role so they never enter `result` anyway (the role check
- * below stops at user messages), but keeping the filter explicit documents
- * the contract that no excluded tags leak into agent output.
- */
-function getLastAssistantTurnMessages(messageHistory: Message[]): Message[] {
-  let lastAssistantIndex = -1
-  for (let i = messageHistory.length - 1; i >= 0; i--) {
-    if (messageHistory[i].role === 'assistant') {
-      lastAssistantIndex = i
-      break
-    }
-  }
-
-  for (let i = lastAssistantIndex; i >= 0; i--) {
-    if (messageHistory[i].role === 'assistant') {
-      lastAssistantIndex = i
-    } else break
-  }
-
-  if (lastAssistantIndex === -1) {
-    return []
-  }
-
-  const result: Message[] = []
-  for (let i = lastAssistantIndex; i < messageHistory.length; i++) {
-    const message = messageHistory[i]
-    if (message.role === 'assistant' || message.role === 'tool') {
-      result.push(message)
-    } else {
-      // Stop if we hit a user or system message.
-      break
-    }
-  }
-
-  return result.filter((m) => !isExcludedFromOutput(m))
-}
-
-export function getAgentOutput(
-  agentState: AgentState,
-  agentTemplate: AgentTemplate,
-): AgentOutput {
-  if (agentTemplate.outputMode === 'structured_output') {
-    return {
-      type: 'structuredOutput',
-      value: agentState.output ?? null,
-    }
-  }
-  if (agentTemplate.outputMode === 'last_message') {
-    const lastTurnMessages = getLastAssistantTurnMessages(
-      agentState.messageHistory,
-    )
-    if (lastTurnMessages.length === 0) {
-      return {
-        type: 'error',
-        message: 'No response from agent',
-      }
-    }
-    return {
-      type: 'lastMessage',
-      value: lastTurnMessages,
-    }
-  }
-  if (agentTemplate.outputMode === 'all_messages') {
-    // Remove the first message, which includes the previous conversation history.
-    const agentMessages = agentState.messageHistory
-      .slice(1)
-      .filter((m) => !isExcludedFromOutput(m))
-    return {
-      type: 'allMessages',
-      value: agentMessages,
-    }
-  }
-  agentTemplate.outputMode satisfies never
-  throw new Error(
-    `Unknown output mode: ${'outputMode' in agentTemplate ? agentTemplate.outputMode : 'undefined'}`,
-  )
-}