21b5e6b0d4
- Introduced a new design document for research backend integration, outlining scope, architecture, and API specifications. - Added frontend API service functions for managing research agents, nodes, and reports. - Extended existing Go backend packages to support new research functionalities. feat: Implement PicoClaw context window improvements - Created a design document detailing seven context-window improvements to enhance performance and prevent errors. - Improvements include token estimation fixes, structured error handling, and proactive context management strategies. fix: Document known issues and resolutions - Added a known issues document detailing a critical compile error related to invalid Unicode escapes in Go, including the fix applied. docs: Add context management skill documentation - Introduced a new skill for context management, detailing usage scenarios, project mapping, state persistence, and integration with PicoClaw.
121 lines
3.8 KiB
Go
121 lines
3.8 KiB
Go
// PicoClaw - Ultra-lightweight personal AI agent
|
|
// License: MIT
|
|
//
|
|
// Copyright (c) 2026 PicoClaw contributors
|
|
|
|
package agent
|
|
|
|
import (
|
|
"github.com/sipeed/picoclaw/pkg/providers"
|
|
"github.com/sipeed/picoclaw/pkg/tokenizer"
|
|
)
|
|
|
|
// parseTurnBoundaries returns the starting index of each Turn in the history.
|
|
// A Turn is a complete "user input → LLM iterations → final response" cycle
|
|
// (as defined in #1316). Each Turn begins at a user message and extends
|
|
// through all subsequent assistant/tool messages until the next user message.
|
|
//
|
|
// Cutting at a Turn boundary guarantees that no tool-call sequence
|
|
// (assistant+ToolCalls → tool results) is split across the cut.
|
|
func parseTurnBoundaries(history []providers.Message) []int {
|
|
var starts []int
|
|
for i, msg := range history {
|
|
if msg.Role == "user" {
|
|
starts = append(starts, i)
|
|
}
|
|
}
|
|
return starts
|
|
}
|
|
|
|
// isSafeBoundary reports whether index is a valid Turn boundary — i.e.,
|
|
// a position where the kept portion (history[index:]) begins at a user
|
|
// message, so no tool-call sequence is torn apart.
|
|
func isSafeBoundary(history []providers.Message, index int) bool {
|
|
if index <= 0 || index >= len(history) {
|
|
return true
|
|
}
|
|
return history[index].Role == "user"
|
|
}
|
|
|
|
// findSafeBoundary locates the nearest Turn boundary to targetIndex.
|
|
// It prefers the boundary at or before targetIndex (preserving more recent
|
|
// context). Falls back to the nearest boundary after targetIndex, and
|
|
// returns targetIndex unchanged only when no Turn boundary exists at all.
|
|
func findSafeBoundary(history []providers.Message, targetIndex int) int {
|
|
if len(history) == 0 {
|
|
return 0
|
|
}
|
|
if targetIndex <= 0 {
|
|
return 0
|
|
}
|
|
if targetIndex >= len(history) {
|
|
return len(history)
|
|
}
|
|
|
|
turns := parseTurnBoundaries(history)
|
|
if len(turns) == 0 {
|
|
return targetIndex
|
|
}
|
|
|
|
// Find the last Turn boundary at or before targetIndex.
|
|
// Prefer backward: keeps more recent messages.
|
|
backward := -1
|
|
for _, t := range turns {
|
|
if t <= targetIndex {
|
|
backward = t
|
|
}
|
|
}
|
|
if backward > 0 {
|
|
return backward
|
|
}
|
|
|
|
// No valid Turn boundary before target (or only at index 0 which
|
|
// would keep everything). Use the first Turn after targetIndex.
|
|
for _, t := range turns {
|
|
if t > targetIndex {
|
|
return t
|
|
}
|
|
}
|
|
|
|
// No Turn boundary after targetIndex either. The only boundary is at
|
|
// index 0, meaning the entire history is a single Turn. Return 0 to
|
|
// signal that safe compression is not possible — callers check for
|
|
// mid <= 0 and skip compression in that case.
|
|
return 0
|
|
}
|
|
|
|
// EstimateMessageTokens estimates the token count for a single message.
|
|
// Delegates to the shared tokenizer package for consistency across agent and seahorse.
|
|
func EstimateMessageTokens(msg providers.Message) int {
|
|
return tokenizer.EstimateMessageTokens(msg)
|
|
}
|
|
|
|
// EstimateToolDefsTokens estimates the total token cost of tool definitions
|
|
// as they appear in the LLM request. Delegates to the shared tokenizer package.
|
|
func EstimateToolDefsTokens(defs []providers.ToolDefinition) int {
|
|
return tokenizer.EstimateToolDefsTokens(defs)
|
|
}
|
|
|
|
// isOverContextBudget checks whether the assembled messages plus tool definitions
|
|
// and output reserve would exceed the model's context window. This enables
|
|
// proactive compression before calling the LLM, rather than reacting to 400 errors.
|
|
// Includes a configurable safety buffer (matching OpenCode's COMPACTION_BUFFER).
|
|
func isOverContextBudget(
|
|
contextWindow int,
|
|
messages []providers.Message,
|
|
toolDefs []providers.ToolDefinition,
|
|
maxTokens int,
|
|
safetyBuffer int,
|
|
) bool {
|
|
msgTokens := 0
|
|
for _, m := range messages {
|
|
msgTokens += EstimateMessageTokens(m)
|
|
}
|
|
|
|
toolTokens := EstimateToolDefsTokens(toolDefs)
|
|
// Add safety buffer (matching OpenCode's approach)
|
|
// This ensures room for output tokens and prevents edge cases
|
|
total := msgTokens + toolTokens + maxTokens + safetyBuffer
|
|
|
|
return total > contextWindow
|
|
}
|