@electerm/electerm-react 5.5.25 → 5.5.56

package/client/components/ai/agent.js

@@ -1,8 +1,31 @@
 import { agentTools, executeToolCall } from './agent-tools'
 import { appendMandatoryGuardrails } from './ai-guardrails'
+import { buildAgentMessages, summarizeContext, CONTEXT_DANGER_PERCENT } from './ai-context'
+import {
+  shouldAutoCompress,
+  canCompact,
+  applySummary
+} from './ai-auto-compress'
+import {
+  autoCompressEnabled,
+  summarizeMessages,
+  autoCompressSession
+} from './ai-compress'
+import uid from '../../common/uid'
 
 const MAX_ITERATIONS = 150
 
+// A summary request that failed (provider hiccup, rate limit) must not be
+// retried on every following iteration -- that would turn a full window into a
+// call per tool result. Only try again once the estimate has grown by this
+// share of the window.
+const AUTO_COMPRESS_RETRY_GROWTH_PERCENT = 5
+
+// Which loop currently owns `store.agentRunning`. A stopped run keeps
+// unwinding for a moment (its last request has to settle), and it must not
+// clear the flag of a run the user started in the meantime.
+let activeRunId = null
+
 function buildAgentSystemPrompt (config) {
   const lang = config.languageAI || window.store.getLangName()
   const baseRole = config.roleAI || 'You are a helpful assistant.'
@@ -26,14 +49,10 @@ Reply in ${lang} language.`)
 }
 
 function updateChatEntry (chatEntry, updates) {
-  const index = window.store.aiChatHistory.findIndex(i => i.id === chatEntry.id)
-  if (index !== -1) {
-    Object.assign(window.store.aiChatHistory[index], updates)
-    window.store.aiChatHistory = [...window.store.aiChatHistory]
-  }
+  window.store.updateAiHistoryEntry(chatEntry.id, updates)
 }
 
-async function callBackendAIchatWithTools (messages, config) {
+async function callBackendAIchatWithTools (messages, config, requestId) {
   return window.pre.runGlobalAsync(
     'AIchatWithTools',
     messages,
@@ -43,31 +62,59 @@ async function callBackendAIchatWithTools (messages, config) {
     config.apiKeyAI,
     config.proxyAI,
     agentTools,
-    config.authHeaderNameAI
+    config.authHeaderNameAI,
+    // `format` stays undefined (the main process detects it); `requestId` is
+    // the last argument so that exact request can be cancelled on stop.
+    undefined,
+    requestId
   )
 }
 
+// Publish the size of the context the agent is carrying so the panel can show
+// it. An agent request is not just the conversation: it also carries every
+// tool schema, and each iteration appends the tool results, which is what
+// actually fills the window. `usage` is the provider's own count for the
+// previous request and is kept for comparison -- the estimate is what the
+// *next* request will cost, so that is the number on display.
+function publishContext (messages, config, usage) {
+  const info = summarizeContext(messages, {
+    model: config.modelAI,
+    contextLength: window.store.config.contextLengthAI,
+    tools: agentTools
+  })
+  if (usage && usage.promptTokens) {
+    info.measuredTokens = usage.promptTokens
+  }
+  window.store.aiContextInfo = info
+}
+
 export async function runAgentLoop (chatEntry, config, abortRef, setIsStreaming, conversationMessages = null) {
+  const runId = uid()
+  activeRunId = runId
   window.store.agentRunning = true
+  const isAborted = () => !!(abortRef && abortRef.current)
+  // Auto compression bookkeeping, read by the finally block as well: how many
+  // times this run compacted itself, whether it failed on the way, and the
+  // size at the last summary attempt (AUTO_COMPRESS_RETRY_GROWTH_PERCENT)
+  let autoCompressCount = 0
+  let autoCompressAttemptTokens = 0
+  let runErrored = false
   try {
-    let messages
-    if (conversationMessages && conversationMessages.length > 1) {
-      // Replace system message with agent system prompt, keep conversation history
-      messages = [
-        { role: 'system', content: buildAgentSystemPrompt(config) },
-        ...conversationMessages.filter(m => m.role !== 'system')
-      ]
-    } else {
-      messages = [
-        { role: 'system', content: buildAgentSystemPrompt(config) },
-        {
-          role: 'user',
-          content: chatEntry.promptWithAttachments || chatEntry.prompt
-        }
-      ]
-    }
+    const messages = buildAgentMessages({
+      systemPrompt: buildAgentSystemPrompt(config),
+      conversationMessages,
+      prompt: chatEntry.promptWithAttachments || chatEntry.prompt
+    })
     const toolCallsLog = []
     let accumulatedContent = ''
+    let lastUsage = null
+
+    const markStopped = () => {
+      setIsStreaming(false)
+      updateChatEntry(chatEntry, {
+        response: accumulatedContent + '\n\n*(Agent stopped by user)*'
+      })
+    }
 
     setIsStreaming(true)
     updateChatEntry(chatEntry, {
@@ -76,17 +123,79 @@ export async function runAgentLoop (chatEntry, config, abortRef, setIsStreaming,
     })
 
     for (let iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
-      if (abortRef && abortRef.current) {
-        setIsStreaming(false)
-        updateChatEntry(chatEntry, {
-          response: accumulatedContent + '\n\n*(Agent stopped by user)*'
-        })
+      if (isAborted()) {
+        markStopped()
         return
       }
 
-      const result = await callBackendAIchatWithTools(messages, config)
+      publishContext(messages, config, lastUsage)
+
+      // Auto compression, when the popover toggle is on: the request about to
+      // go out carries the whole conversation plus a tool result per step, and
+      // past ~90% of the window the provider rejects it outright. Replacing the
+      // conversation with a summary first keeps the run alive; the stored
+      // session is compacted at the end (autoCompressSession), because that is
+      // what the next turn starts from.
+      const info = window.store.aiContextInfo
+      // A failed summary is only worth retrying once the context has grown by
+      // this much -- but never more than the trigger itself, or a threshold
+      // below it would let the retry floor decide when to compress.
+      const growthPercent = Math.min(
+        AUTO_COMPRESS_RETRY_GROWTH_PERCENT,
+        CONTEXT_DANGER_PERCENT
+      )
+      const grewEnough = info &&
+        info.tokens - autoCompressAttemptTokens >=
+          (info.windowSize || 0) * growthPercent / 100
+      if (
+        autoCompressEnabled() &&
+        canCompact(messages) &&
+        shouldAutoCompress(info) &&
+        grewEnough
+      ) {
+        autoCompressAttemptTokens = info.tokens
+        // Shown before the request rather than after: summarizing a nearly full
+        // window takes a while, and this badge is the only sign of why the run
+        // is waiting. Taken back if the summary comes back unusable.
+        updateChatEntry(chatEntry, { autoCompressCount: autoCompressCount + 1 })
+        const summary = await summarizeMessages(messages, config)
+        if (isAborted()) {
+          markStopped()
+          return
+        }
+        if (summary) {
+          applySummary(messages, summary)
+          autoCompressCount++
+          lastUsage = null
+          publishContext(messages, config, null)
+        } else {
+          updateChatEntry(chatEntry, { autoCompressCount })
+        }
+      }
+
+      const requestId = uid()
+      if (abortRef) {
+        abortRef.requestId = requestId
+      }
+      const result = await callBackendAIchatWithTools(messages, config, requestId)
+      if (abortRef && abortRef.requestId === requestId) {
+        abortRef.requestId = null
+      }
+
+      // Re-check after the await, before anything from the answer is used:
+      // stopping cancels the request, and neither the partial answer nor the
+      // resulting error belongs in the transcript.
+      if (isAborted()) {
+        markStopped()
+        return
+      }
+
+      if (result.usage) {
+        lastUsage = result.usage
+      }
 
       if (result.error) {
+        runErrored = true
         setIsStreaming(false)
         updateChatEntry(chatEntry, {
           response: accumulatedContent + `\n\n**Error:** ${result.error}`
@@ -96,6 +205,7 @@ export async function runAgentLoop (chatEntry, config, abortRef, setIsStreaming,
 
       const assistantMessage = result.message
       if (!assistantMessage) {
+        runErrored = true
         setIsStreaming(false)
         updateChatEntry(chatEntry, {
           response: accumulatedContent || 'No response from AI.'
@@ -104,6 +214,7 @@ export async function runAgentLoop (chatEntry, config, abortRef, setIsStreaming,
       }
 
       messages.push(assistantMessage)
+      publishContext(messages, config, lastUsage)
 
       if (assistantMessage.content) {
         accumulatedContent += (accumulatedContent ? '\n\n' : '') + assistantMessage.content
@@ -121,11 +232,8 @@ export async function runAgentLoop (chatEntry, config, abortRef, setIsStreaming,
       }
 
       for (const toolCall of assistantMessage.tool_calls) {
-        if (abortRef && abortRef.current) {
-          setIsStreaming(false)
-          updateChatEntry(chatEntry, {
-            response: accumulatedContent + '\n\n*(Agent stopped by user)*'
-          })
+        if (isAborted()) {
+          markStopped()
           return
         }
 
@@ -136,28 +244,32 @@ export async function runAgentLoop (chatEntry, config, abortRef, setIsStreaming,
           args = {}
         }
 
-        const toolEntry = {
+        toolCallsLog.push({
           id: toolCall.id,
           name: toolCall.function.name,
           args,
           status: 'running',
           result: null
-        }
-        toolCallsLog.push(toolEntry)
+        })
         updateChatEntry(chatEntry, {
           toolCalls: [...toolCallsLog]
         })
 
-        let toolResult
+        let finished
         try {
-          toolResult = await executeToolCall(toolCall.function.name, args)
-          toolEntry.status = 'completed'
-          toolEntry.result = toolResult
+          const toolResult = await executeToolCall(toolCall.function.name, args)
+          finished = { status: 'completed', result: toolResult }
         } catch (err) {
-          toolEntry.status = 'error'
-          toolEntry.result = err.message
+          finished = { status: 'error', result: err.message }
         }
 
+        // Swap in a new entry object instead of mutating the running one: the
+        // tool call card is memo()'d on that object's identity, so an in-place
+        // mutation would leave the card showing "running" forever.
+        toolCallsLog[toolCallsLog.length - 1] = {
+          ...toolCallsLog[toolCallsLog.length - 1],
+          ...finished
+        }
         updateChatEntry(chatEntry, {
           toolCalls: [...toolCallsLog]
         })
@@ -165,7 +277,7 @@ export async function runAgentLoop (chatEntry, config, abortRef, setIsStreaming,
         messages.push({
           role: 'tool',
           tool_call_id: toolCall.id,
-          content: toolEntry.result
+          content: finished.result
         })
       }
     }
@@ -175,6 +287,54 @@ export async function runAgentLoop (chatEntry, config, abortRef, setIsStreaming,
       response: accumulatedContent + '\n\n*(Agent reached maximum iterations)*'
     })
   } finally {
-    window.store.agentRunning = false
+    if (abortRef) {
+      abortRef.requestId = null
+    }
+    // Only the run that still owns the flag may clear it -- a stopped run
+    // unwinds a moment later and must not unlock a newer one.
+    const ownsRun = activeRunId === runId
+    if (ownsRun) {
+      activeRunId = null
+      window.store.agentRunning = false
+      // hand the panel back to the session based estimate: tool results are not
+      // carried into the next turn, so the agent figure stops being meaningful
+      window.store.aiContextInfo = null
+    }
+    // A run that compacted its live conversation leaves the stored session
+    // untouched, so the next turn would start from the full history again and
+    // pay for another summary. Compact the session as well -- once, after the
+    // run, when the turns it summarizes are complete. Skipped for a stopped or
+    // failed run: those transcripts are not a conversation worth keeping.
+    if (ownsRun && autoCompressCount > 0 && !runErrored && !isAborted()) {
+      await autoCompressSession(chatEntry.chatSessionId, config)
+    }
+  }
+}
+
+// Stop the running agent loop, called by the panel's stop button.
+//
+// The loop itself only looks at `abortRef` between iterations, so on its own
+// that flag does nothing while a request is in flight -- and the panel keeps
+// the composer locked for as long as the provider takes to answer (which is
+// forever if it never does, these requests carry no timeout). So this also
+// cancels the in-flight request and releases the composer right away; the loop
+// then unwinds on its own and marks the entry as stopped.
+export async function stopAgentRun (abortRef) {
+  if (abortRef) {
+    abortRef.current = true
+  }
+  const requestId = abortRef && abortRef.requestId
+  if (abortRef) {
+    abortRef.requestId = null
+  }
+  activeRunId = null
+  window.store.agentRunning = false
+  window.store.aiContextInfo = null
+  if (requestId) {
+    try {
+      await window.pre.runGlobalAsync('abortAIRequest', requestId)
+    } catch (error) {
+      console.error('Error aborting agent request:', error)
+    }
   }
 }

package/client/components/ai/ai-auto-compress.js

@@ -0,0 +1,119 @@
+// Automatic context compression, shared by agent mode and ask mode.
+//
+// A request is not just the conversation: agent runs append the assistant's
+// tool calls and their results on every iteration, ask turns append the answer
+// of every turn. Either way the request that leaves the machine grows past what
+// the session transcript suggests, and once it approaches the model's window
+// the provider starts rejecting it outright, which kills the run mid-way. The
+// fix is the same one the manual Compress button performs -- replace the
+// history with a summary -- except it has to happen before the request that
+// would overflow.
+//
+// Pure module (no window / store access) so the decision and the rewrite can
+// be unit tested, and so the manual and the automatic path share one summary
+// prompt and one message shape. The request that asks for a summary lives in
+// ai-compress.js.
+
+import { CONTEXT_DANGER_PERCENT } from './ai-context.js'
+
+// Sent as the closing user turn when asking for a summary. Shared with the
+// manual path (store.compressChatSession) so both produce the same thing.
+export const COMPRESS_SUMMARY_PROMPT = 'Please summarize the above conversation concisely. Include key information, decisions, context, and any important details that would be needed to continue this conversation effectively.'
+
+// `info` is the object summarizeContext returns. Percent is null/absent when
+// the window size is unknown, which must not read as "0, no compression
+// needed" -- there is simply nothing to decide on.
+//
+// The threshold is the danger level from ai-context.js, read here rather than
+// copied into a constant of this module: the same value is what turns the
+// context indicator red, and a live read cannot be left behind in a stale copy
+// of this file when that value is edited (which is how "I set it to 5 and it
+// still did not compress" happens).
+export function shouldAutoCompress (info, percent = CONTEXT_DANGER_PERCENT) {
+  if (!info) {
+    return false
+  }
+  const p = info.percent
+  if (p === null || p === undefined || !isFinite(p)) {
+    return false
+  }
+  return p >= percent
+}
+
+// There has to be something a summary can replace. A fresh request is just the
+// system prompt plus the prompt being sent; compacting that would only re-word
+// the question, so a model whose tool schemas alone fill the window is left
+// alone rather than sent a summary request on every turn.
+export function canCompact (messages) {
+  return Array.isArray(messages) && messages.length > 2
+}
+
+// An ask-mode request ends with the prompt being answered, because
+// buildSessionMessages appends each turn's prompt after the earlier ones.
+// Compaction must keep that last message out of the summary: it is the live
+// question, and folding it into "here is a summary of our previous
+// conversation" would ask the model to answer a question it only sees quoted
+// back at it.
+export function splitPendingTurn (messages) {
+  if (!Array.isArray(messages)) {
+    return { context: [], pending: null }
+  }
+  const last = messages[messages.length - 1]
+  if (last && last.role === 'user') {
+    return { context: messages.slice(0, -1), pending: last }
+  }
+  return { context: messages, pending: null }
+}
+
+// How a summary re-enters the conversation. Deliberately the same pair
+// buildSessionMessages emits for a compressed session entry, so a live loop
+// that compacted itself and a session compressed between turns read
+// identically to the model.
+export function summaryMessages (summary) {
+  return [
+    {
+      role: 'user',
+      content: `Here is a summary of our previous conversation for context:\n\n${summary}`
+    },
+    {
+      role: 'assistant',
+      content: 'Understood. I will use this context as we continue.'
+    }
+  ]
+}
+
+// Compact `messages` in place: the system prompt stays (it carries the agent
+// instructions and guardrails), everything the summary covers is dropped.
+// In place because the agent loop holds this exact array for its next request.
+export function applySummary (messages, summary) {
+  if (!Array.isArray(messages) || !summary) {
+    return messages
+  }
+  const system = messages.find(m => m && m.role === 'system')
+  messages.length = 0
+  if (system) {
+    messages.push(system)
+  }
+  messages.push(...summaryMessages(summary))
+  return messages
+}
+
+// The ask-mode counterpart, returning a new list: the memoized session messages
+// this turn was built from must not be modified, and the live prompt has to be
+// re-attached after the summary.
+export function compactAskMessages (messages, summary) {
+  if (!Array.isArray(messages) || !summary) {
+    return messages
+  }
+  const { pending } = splitPendingTurn(messages)
+  const system = messages.find(m => m && m.role === 'system')
+  const next = []
+  if (system) {
+    next.push(system)
+  }
+  next.push(...summaryMessages(summary))
+  if (pending) {
+    next.push(pending)
+  }
+  return next
+}