savant-code 0.0.19 → 0.0.20

package/packages/agent-runtime/src/tools/stream-parser.ts

@@ -1,407 +0,0 @@
-import { toolNames } from '@savant-code/common/tools/constants'
-import { buildArray } from '@savant-code/common/util/array'
-import { AbortError } from '@savant-code/common/util/error'
-import {
-  assistantMessage,
-  userMessage,
-} from '@savant-code/common/util/messages'
-import { generateCompactId } from '@savant-code/common/util/string'
-
-import { INCLUDE_REASONING_IN_MESSAGE_HISTORY } from '../constants'
-import { processStreamWithTools } from '../tool-stream-parser'
-import {
-  executeCustomToolCall,
-  executeToolCall,
-  tryTransformAgentToolCall,
-} from './tool-executor'
-import { withSystemTags } from '../util/messages'
-
-import type { CustomToolCall, ExecuteToolCallParams } from './tool-executor'
-import type { AgentTemplate } from '../templates/types'
-import type { FileProcessingState } from './handlers/tool/write-file'
-import type { ToolName } from '@savant-code/common/tools/constants'
-import type { SavantCodeToolCall } from '@savant-code/common/tools/list'
-import type { Logger as RuntimeLogger } from '@savant-code/common/types/contracts/logger'
-import type { ParamsExcluding } from '@savant-code/common/types/function-params'
-import type { JSONValue } from '@savant-code/common/types/json'
-import type {
-  Message,
-  ToolMessage,
-} from '@savant-code/common/types/messages/savant-code-message'
-import type { PrintModeEvent } from '@savant-code/common/types/print-mode'
-import type { Subgoal } from '@savant-code/common/types/session-state'
-import type {
-  CustomToolDefinitions,
-  ProjectFileContext,
-} from '@savant-code/common/util/file'
-
-export async function processStream(
-  params: {
-    agentContext: Record<string, Subgoal>
-    agentTemplate: AgentTemplate
-    ancestorRunIds: string[]
-    fileContext: ProjectFileContext
-    fingerprintId: string
-    fullResponse: string
-    logger: RuntimeLogger
-    messages: Message[]
-    repoId: string | undefined
-    runId: string
-    signal: AbortSignal
-    userId: string | undefined
-    /** FID-2026-0802-005 H8: step-built custom tool data (incl. MCP tools). */
-    customToolDefinitions?: CustomToolDefinitions
-
-    onCostCalculated: (credits: number) => Promise<void>
-    onResponseChunk: (chunk: string | PrintModeEvent) => void
-  } & Omit<
-    ExecuteToolCallParams<string>,
-    | 'fileProcessingState'
-    | 'fromHandleSteps'
-    | 'fullResponse'
-    | 'input'
-    | 'previousToolCallFinished'
-    | 'state'
-    | 'toolCallId'
-    | 'toolCalls'
-    | 'toolCallsToAddToMessageHistory'
-    | 'toolName'
-    | 'toolResults'
-    | 'toolResultsToAddToMessageHistory'
-  > &
-    ParamsExcluding<
-      typeof processStreamWithTools,
-      'processors' | 'defaultProcessor' | 'loggerOptions' | 'executeXmlToolCall'
-    >,
-) {
-  const {
-    agentState,
-    agentTemplate,
-    ancestorRunIds,
-    fileContext,
-    fullResponse,
-    onCostCalculated,
-    onResponseChunk,
-    runId,
-    signal,
-    userId,
-  } = params
-  const fullResponseChunks: string[] = [fullResponse]
-  // FID-2026-0802-005 H1: incremental accumulator — the previous
-  // `fullResponseChunks.join('')` on every tool call was O(k·L) copying for
-  // tool-dense responses. The chunks array is kept only for the final return.
-  let fullResponseSoFar = fullResponse
-
-  // === MUTABLE STATE ===
-  const toolResults: ToolMessage[] = []
-  const toolResultsToAddToMessageHistory: ToolMessage[] = []
-  const toolCalls: (SavantCodeToolCall | CustomToolCall)[] = []
-  const toolCallsToAddToMessageHistory: (
-    SavantCodeToolCall | CustomToolCall
-  )[] = []
-  const assistantMessages: Message[] = []
-  let hadToolCallError = false
-  let hasNativeIncompleteToolCall = false
-  const errorMessages: Message[] = []
-  const { promise: streamDonePromise, resolve: resolveStreamDonePromise } =
-    Promise.withResolvers<void>()
-  let previousToolCallFinished = streamDonePromise
-
-  const fileProcessingState: FileProcessingState = {
-    promisesByPath: {},
-    allPromises: [],
-    fileChangeErrors: [],
-    fileChanges: [],
-    firstFileProcessed: false,
-  }
-
-  // === RESPONSE HANDLER ===
-  // Creates a response handler that captures tool events into assistantMessages.
-  // When isXmlMode=true, also captures tool_result events for interleaved ordering.
-  function createResponseHandler() {
-    return (chunk: string | PrintModeEvent) => {
-      if (typeof chunk !== 'string') {
-        if (chunk.type === 'error') {
-          hadToolCallError = true
-          errorMessages.push(
-            userMessage({
-              content: withSystemTags(
-                `Error during tool call: ${chunk.message}. Please check the tool name and arguments and try again.`,
-              ),
-              tags: ['TOOL_CALL_ERROR'],
-            }),
-          )
-        }
-      }
-      return onResponseChunk(chunk)
-    }
-  }
-
-  // === TOOL EXECUTION ===
-  // Unified callback factory for both native and custom tools.
-  function createToolExecutionCallback(toolName: string, isXmlMode: boolean) {
-    const responseHandler = createResponseHandler()
-    return {
-      onTagStart: () => {},
-      onTagEnd: async (_: string, input: Record<string, JSONValue>) => {
-        if (signal.aborted) {
-          return
-        }
-        const toolCallId = generateCompactId()
-        const isNativeTool = toolNames.includes(toolName as ToolName)
-
-        // Check if this is an agent tool call that should be transformed to spawn_agents
-        const transformed = !isNativeTool
-          ? tryTransformAgentToolCall({
-              toolName,
-              input,
-              spawnableAgents: agentTemplate.spawnableAgents,
-            })
-          : null
-
-        // Read previousToolCallFinished at execution time to ensure proper sequential chaining.
-        // For XML mode, if this is the first tool call (still pointing to streamDonePromise),
-        // start with a resolved promise so we don't wait for the stream to complete.
-        const previousPromise =
-          isXmlMode && previousToolCallFinished === streamDonePromise
-            ? Promise.resolve()
-            : previousToolCallFinished
-
-        // Determine which executor to use and with what parameters
-        let toolPromise: Promise<void>
-        if (isNativeTool || transformed) {
-          // Use executeToolCall for native tools or transformed agent calls
-          toolPromise = executeToolCall({
-            ...params,
-            toolName: transformed
-              ? transformed.toolName
-              : (toolName as ToolName),
-            input: transformed ? transformed.input : input,
-            fromHandleSteps: false,
-
-            fileProcessingState,
-            fullResponse: fullResponseSoFar,
-            previousToolCallFinished: previousPromise,
-            toolCallId,
-            toolCalls,
-            toolCallsToAddToMessageHistory,
-            toolResults,
-            toolResultsToAddToMessageHistory,
-            excludeToolFromMessageHistory: false,
-            onCostCalculated,
-            onResponseChunk: responseHandler,
-          })
-        } else {
-          // Use executeCustomToolCall for custom/MCP tools
-          toolPromise = executeCustomToolCall({
-            ...params,
-            toolName,
-            input,
-
-            fileProcessingState,
-            fullResponse: fullResponseSoFar,
-            previousToolCallFinished: previousPromise,
-            toolCallId,
-            toolCalls,
-            toolCallsToAddToMessageHistory,
-            toolResults,
-            toolResultsToAddToMessageHistory,
-            excludeToolFromMessageHistory: false,
-            onResponseChunk: responseHandler,
-          })
-        }
-
-        previousToolCallFinished = toolPromise
-
-        // For XML mode, await execution so results appear inline before stream continues
-        if (isXmlMode) {
-          await toolPromise
-        }
-      },
-    }
-  }
-
-  // === STREAM PROCESSING ===
-  const streamWithTags = processStreamWithTools({
-    ...params,
-    processors: Object.fromEntries([
-      ...toolNames.map((name) => [
-        name,
-        createToolExecutionCallback(name, false),
-      ]),
-      ...Object.keys(fileContext.customToolDefinitions ?? {}).map((name) => [
-        name,
-        createToolExecutionCallback(name, false),
-      ]),
-    ]),
-    defaultProcessor: (name: string) =>
-      createToolExecutionCallback(name, false),
-    loggerOptions: {
-      userId,
-      model: agentTemplate.model,
-      agentName: agentTemplate.id,
-    },
-    onResponseChunk: (chunk) => {
-      if (chunk.type === 'text') {
-        if (chunk.text) {
-          assistantMessages.push(assistantMessage(chunk.text))
-        }
-      } else if (chunk.type === 'error') {
-        // do nothing
-      } else {
-        chunk satisfies never
-        throw new Error(
-          `Internal error: unhandled chunk type: ${JSON.stringify(chunk)}`,
-        )
-      }
-      return onResponseChunk(chunk)
-    },
-    // Execute XML-parsed tool calls immediately during streaming
-    executeXmlToolCall: async ({ toolName, input }) => {
-      if (signal.aborted) {
-        return
-      }
-      const callback = createToolExecutionCallback(toolName, true)
-      await callback.onTagEnd(toolName, input as Record<string, string>)
-    },
-  })
-
-  // === STREAM CONSUMPTION LOOP ===
-  let messageId: string | null = null
-
-  // Wrap in try/finally so that the finalization (message history update) always
-  // runs even when the stream throws an AbortError mid-iteration.
-  try {
-    while (true) {
-      if (signal.aborted) {
-        break
-      }
-      const { value: chunk, done } = await streamWithTags.next()
-      if (done) {
-        // Handle PromptResult: extract value if success, null if aborted
-        if (chunk && typeof chunk === 'object' && 'aborted' in chunk) {
-          messageId = chunk.aborted ? null : chunk.value
-        } else {
-          messageId = chunk
-        }
-        break
-      }
-
-      if (chunk.type === 'reasoning') {
-        if (INCLUDE_REASONING_IN_MESSAGE_HISTORY && chunk.text) {
-          const last = assistantMessages[assistantMessages.length - 1]
-          const lastPart =
-            last?.role === 'assistant' && Array.isArray(last.content)
-              ? last.content[last.content.length - 1]
-              : undefined
-          if (lastPart && lastPart.type === 'reasoning') {
-            lastPart.text += chunk.text
-          } else {
-            assistantMessages.push(
-              assistantMessage({ type: 'reasoning', text: chunk.text }),
-            )
-          }
-        }
-        onResponseChunk({
-          type: 'reasoning_delta',
-          text: chunk.text,
-          ancestorRunIds,
-          runId,
-          agentId: agentState.agentId,
-        })
-      } else if (chunk.type === 'text') {
-        onResponseChunk(chunk.text)
-        fullResponseSoFar += chunk.text
-        fullResponseChunks.push(chunk.text)
-      } else if (chunk.type === 'error') {
-        onResponseChunk(chunk)
-        hadToolCallError = true
-        if ('errorClass' in chunk && chunk.errorClass === 'native-incomplete') {
-          hasNativeIncompleteToolCall = true
-        }
-        errorMessages.push(
-          userMessage({
-            content: withSystemTags(
-              `Error during tool call: ${chunk.message}. Please check the tool name and arguments and try again.`,
-            ),
-            tags: ['TOOL_CALL_ERROR'],
-          }),
-        )
-      } else if (chunk.type === 'tool-call') {
-      } else {
-        chunk satisfies never
-        throw new Error(`Unhandled chunk type: ${JSON.stringify(chunk)}`)
-      }
-    }
-
-    // FID-2026-0802-005 H7: settle the initial tool-call chain before
-    // awaiting it on the normal path (in native mode the first call is
-    // chained on streamDonePromise, so it must be resolved first).
-    resolveStreamDonePromise()
-    if (!signal.aborted) {
-      await previousToolCallFinished
-    }
-  } finally {
-    // FID-2026-0802-005 H7: ALWAYS settle streamDonePromise — even on abort
-    // or a mid-stream error — so suspended first-call handlers resume (and
-    // observe signal.aborted) instead of dangling forever with lost credits.
-    // Idempotent: already resolved on the normal path. Trade-off (per FID): a
-    // resumed handler runs to completion bounded by its own signal checks.
-    resolveStreamDonePromise()
-    // === FINALIZATION ===
-    // Trigger cleanup of the processStreamWithTools generator so it flushes any
-    // remaining buffered text to assistantMessages before we build the history.
-    // On path B (AbortError thrown mid-stream) the generator is already completed
-    // so .return() is a no-op. On path A (cooperative signal.aborted break) the
-    // generator is still suspended and .return() triggers its finally → flush().
-    try {
-      await streamWithTags.return({ aborted: true })
-    } catch {
-      // Generator cleanup failed; assistantMessages may be incomplete but
-      // we must not swallow the original error.
-    }
-
-    // This runs even when the stream throws (e.g., AbortError mid-iteration).
-    // Build message history from the current agentState.messageHistory so that
-    // inline agent modifications (e.g. set_messages) are preserved, while
-    // tool_calls and tool_results are still appended in deterministic order.
-    //
-    // When the signal was aborted, tool calls are added synchronously but tool
-    // results arrive asynchronously via .then(). Because we skip awaiting
-    // previousToolCallFinished on abort, some tool calls may not have matching
-    // tool results yet. Including orphaned tool calls in the message history
-    // causes provider errors ("unexpected tool_use_id found in tool_result
-    // blocks"). Filter them out so every tool_call has a corresponding
-    // tool_result.
-    const completedToolCallIds = new Set(
-      toolResultsToAddToMessageHistory.map((r) => r.toolCallId),
-    )
-    const filteredToolCalls = toolCallsToAddToMessageHistory.filter((tc) =>
-      completedToolCallIds.has(tc.toolCallId),
-    )
-
-    agentState.messageHistory = buildArray<Message>([
-      ...agentState.messageHistory,
-      ...assistantMessages,
-      ...filteredToolCalls.map((toolCall) =>
-        assistantMessage({ ...toolCall, type: 'tool-call' }),
-      ),
-      ...toolResultsToAddToMessageHistory,
-      ...errorMessages,
-    ])
-  }
-
-  if (signal.aborted) {
-    throw new AbortError()
-  }
-
-  return {
-    fullResponse: fullResponseSoFar,
-    fullResponseChunks,
-    hadToolCallError,
-    hasNativeIncompleteToolCall,
-    messageId,
-    toolCalls,
-    toolResults,
-  }
-}

package/packages/agent-runtime/src/tools/thinker-convergence-gate.ts

@@ -1,162 +0,0 @@
-import {
-  thinkerFinalArtifactToJSONValue,
-  type ThinkerFinalArtifact,
-} from '@savant-code/common/tools/sequential-thinking'
-import { userMessage } from '@savant-code/common/util/messages'
-
-import {
-  cleanupThoughtSession,
-  getThoughtSessionIfExists,
-} from './thought-session-store'
-import { withSystemTags } from '../util/messages'
-
-import type { Logger } from '@savant-code/common/types/contracts/logger'
-import type { AgentState } from '@savant-code/common/types/session-state'
-
-/**
- * FID-2026-0801-012: runtime convergence gate.
- *
- * Runs at the runtime boundary (in `loopAgentSteps`, after the native step's
- * tool results are committed to history) for Thinker-like agents — the ONLY
- * agent with `sequentialthinking` in `toolNames`. It replaces the removed
- * `handleSteps` text-parsing finalizer.
- *
- * Behavior when the model ended its turn (`shouldEndTurn === true`):
- * - Session converged (last thought `nextThoughtNeeded === false`) → build the
- *   `FinalArtifact` from the session snapshot (never from assistant text), set
- *   `agentState.output` once, clean up the session.
- * - Thoughts accepted but NOT converged (model wrote its conclusion as plain
- *   text and stopped) → non-convergence: append one typed retry message asking
- *   for a final `nextThoughtNeeded: false` thought; after the consecutive cap
- *   (3) → `exhausted` with partial synthesis. Never a fake success.
- * - No accepted thoughts → retry message; after the cap → `failed`.
- *
- * The gate ALWAYS sets `agentState.output` for every terminal status (success,
- * exhausted, failed) and the loop runs it BEFORE the `output === undefined &&
- * shouldEndTurn` restart check, so the "You must use set_output" branch can
- * never reintroduce `structuredOutput: null` for the Thinker.
- */
-export const MAX_CONSECUTIVE_RETRIES = 3
-
-const consecutiveRetries = new Map<string, number>()
-
-export interface ThinkerConvergenceGateResult {
-  /** True when the gate appended a retry message and the loop must continue. */
-  retryAppended: boolean
-  /** True when the gate set a terminal `agentState.output` (success/exhausted/failed). */
-  terminal: boolean
-}
-
-export function runThinkerConvergenceGate(params: {
-  runId: string
-  agentState: AgentState
-  shouldEndTurn: boolean
-  logger: Logger
-}): ThinkerConvergenceGateResult {
-  const { runId, agentState, shouldEndTurn, logger } = params
-
-  if (!shouldEndTurn) {
-    // Mid-reasoning: keep looping normally (native continuation).
-    return { retryAppended: false, terminal: false }
-  }
-
-  if (agentState.output !== undefined) {
-    // Output already set (e.g. a terminal path finalized this run, or a
-    // steering message kept the loop alive after finalization). Never
-    // clobber it or append a retry on top of a completed run.
-    return { retryAppended: false, terminal: false }
-  }
-
-  const session = getThoughtSessionIfExists(runId)
-  const snapshot = session?.getSnapshot()
-  const thoughtCount = snapshot?.length ?? 0
-  const converged = snapshot?.converged ?? false
-
-  if (converged && thoughtCount > 0 && session && snapshot) {
-    // Build the FinalArtifact from the session snapshot — the last accepted
-    // thought (nextThoughtNeeded=false) carries the conclusion.
-    const lastThought = snapshot.thoughts[snapshot.thoughts.length - 1]!
-    const artifact: ThinkerFinalArtifact = session.finalize({
-      message: lastThought.thought,
-    })
-    agentState.output = thinkerFinalArtifactToJSONValue(artifact)
-    cleanupThoughtSession(runId)
-    consecutiveRetries.delete(runId)
-    logger.debug(
-      {
-        runId,
-        totalThoughts: artifact.metrics.totalThoughts,
-        branches: artifact.metrics.branches,
-      },
-      'Thinker converged — final artifact built from session snapshot',
-    )
-    return { retryAppended: false, terminal: true }
-  }
-
-  // Non-convergence (or no thoughts at all). Bounded retry with a consecutive
-  // error cap to prevent token-burning loops.
-  const attempt = (consecutiveRetries.get(runId) ?? 0) + 1
-  consecutiveRetries.set(runId, attempt)
-
-  if (attempt >= MAX_CONSECUTIVE_RETRIES) {
-    const status = thoughtCount === 0 ? 'failed' : 'exhausted'
-    const error =
-      thoughtCount === 0
-        ? 'The Thinker ended its turn without accepting any sequentialthinking thoughts.'
-        : `The Thinker ended its turn ${attempt} times without a converged final thought (nextThoughtNeeded=false).`
-    const artifact: ThinkerFinalArtifact =
-      session?.fail(status, error) ??
-      buildStandaloneFailedArtifact(status, error)
-    agentState.output = thinkerFinalArtifactToJSONValue(artifact)
-    cleanupThoughtSession(runId)
-    consecutiveRetries.delete(runId)
-    logger.warn(
-      { runId, attempt, thoughtCount, status },
-      `Thinker non-convergence cap reached — terminal '${status}' artifact set`,
-    )
-    return { retryAppended: false, terminal: true }
-  }
-
-  // Append a typed retry message and keep the loop going.
-  const retryMessage =
-    thoughtCount === 0
-      ? 'You ended your turn without using the sequentialthinking tool. Reason through the problem with at least one sequentialthinking call, and make your final call set nextThoughtNeeded=false with the complete conclusion in the thought text.'
-      : `You ended your turn before converging. Your sequentialthinking session has ${thoughtCount} accepted thought(s), but the last thought did not set nextThoughtNeeded=false. Append one final sequentialthinking call with nextThoughtNeeded=false whose thought text contains your complete conclusion.`
-  agentState.messageHistory = [
-    ...agentState.messageHistory,
-    userMessage({
-      content: withSystemTags(retryMessage),
-      keepDuringTruncation: true,
-    }),
-  ]
-  logger.warn(
-    { runId, attempt, thoughtCount },
-    `Thinker non-convergence — retry message appended (${attempt}/${MAX_CONSECUTIVE_RETRIES})`,
-  )
-  return { retryAppended: true, terminal: false }
-}
-
-/** Resets the per-run consecutive-retry counter (e.g., on loop teardown). */
-export function resetThinkerConvergenceState(runId: string): void {
-  consecutiveRetries.delete(runId)
-}
-
-/** Test-only: clear all retry counters. */
-export function clearThinkerConvergenceStateForTests(): void {
-  consecutiveRetries.clear()
-}
-
-/** Builds a terminal artifact when no session exists (zero thoughts). */
-function buildStandaloneFailedArtifact(
-  status: 'failed' | 'exhausted',
-  error: string,
-): ThinkerFinalArtifact {
-  return {
-    status,
-    synthesis: 'No sequential thinking thoughts were accepted.',
-    payload: null,
-    metrics: { totalThoughts: 0, durationMs: 0, branches: [] },
-    thoughts: [],
-    error,
-  }
-}

package/packages/agent-runtime/src/tools/thought-session-store.ts

@@ -1,43 +0,0 @@
-import { ThoughtSession } from '@savant-code/common/tools/sequential-thinking'
-
-/**
- * FID-2026-0801-012: per-run session store. Keyed by `runId` so concurrent
- * Thinker runs never share history or branches. The handler appends via
- * `getThoughtSession`; the runtime convergence gate reads via
- * `getThoughtSessionIfExists`; terminal paths (success/failure/abort) call
- * `cleanupThoughtSession`.
- */
-const sessions = new Map<string, ThoughtSession>()
-
-export function getThoughtSession(runId: string): ThoughtSession {
-  let session = sessions.get(runId)
-  if (!session) {
-    session = new ThoughtSession()
-    session.begin()
-    sessions.set(runId, session)
-  }
-  return session
-}
-
-export function getThoughtSessionIfExists(
-  runId: string,
-): ThoughtSession | undefined {
-  return sessions.get(runId)
-}
-
-/** Idempotent: cleans up the session (if any) and removes it from the store. */
-export function cleanupThoughtSession(runId: string): void {
-  const session = sessions.get(runId)
-  if (session) {
-    session.cleanup()
-    sessions.delete(runId)
-  }
-}
-
-/** Test-only: teardown every session and clear the store. */
-export function clearAllThoughtSessionsForTests(): void {
-  for (const session of sessions.values()) {
-    session.cleanup()
-  }
-  sessions.clear()
-}