Completes the objective deletion gate for the UI Service (archie-core-8cda.5.6): go list -deps ./cmd/archie-ui now links zero banned packages -- no modernc.org/sqlite, no internal/store, gateway, channels, memory, secret, agentexec, tools, skill, yaegiutil, curator, or the workflow engine. The closure shrinks from 68 to 26 archie-core packages. Each cut is a producer-side move; no consumer-side defensive shims. - Store contracts (TaskStore family, value types, sentinels) moved from internal/store to internal/domain/storecontract -- the approved contract location per state-store-contract rev. 2d, and NOT internal/contracts: that tree is buf generate output and tools/proto.sh check deletes hand-written files there. internal/store keeps aliases; sentinel message strings are byte-identical and remain the wire contract. - Chat contracts (ChatContract, sessions, turns, streaming, commands) moved from internal/gateway to internal/domain/messaging; gateway keeps aliases. ToolCallEvent rendering helpers become gateway functions (methods cannot live on alias types). - Task vocabulary (Task, statuses, mid-run Store, Definition) split into internal/domain/workflow/task; the pipeline engine stays in package workflow with aliases, so daemon-side callers are unchanged. - overlay.DeniedKeys moved to internal/infrastructure/configuration: webui referenced the constant and that dragged the overlay SQLite store in. - webui.Server's concrete runtime handles become webui-owned view interfaces with daemon-side bootstrap adapters: channel lifecycle (internal/channels/status), MemoryStatus, CuratorStatus, and a SkillCatalog seam replacing the direct skill.DefaultRoots/CatalogRoots calls. Each degrades to an empty page when unwired. - config.SecretRef moved into internal/config (config vocabulary); internal/secret keeps an alias and Registry.Resolve absorbs the zero-value short-circuit. Docs: state-store-contract rev. 2d relocation record; ui-service-boundary deletion gate marked satisfied; ARCHITECTURE.md package map rows.
295 lines
8.8 KiB
Go
295 lines
8.8 KiB
Go
package gateway
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
// toolSummaryMaxRunes bounds a rendered tool summary. Tool output is
|
|
// unbounded -- a grep can return thousands of lines -- and the summary is
|
|
// one line in a chat transcript, so it is cut rather than allowed to bury the
|
|
// answer it precedes.
|
|
const (
|
|
toolSummaryMaxRunes = 80
|
|
toolParametersMaxRunes = 120
|
|
redactedParameterValue = "[redacted]"
|
|
)
|
|
|
|
// RenderToolCall returns the channel-neutral compact representation used by
|
|
// chat surfaces. Parameters are intentionally omitted: JSON/schema-shaped
|
|
// inputs are noisy, often contain secrets, and are not useful progress text.
|
|
// Results are reduced semantically instead of clipped blindly: file contents,
|
|
// listings and structured envelopes are described, never echoed.
|
|
// RenderToolCall returns the channel-neutral compact representation used by
|
|
// chat surfaces. (A function rather than a method because ToolCallEvent is a
|
|
// messaging alias: see chat_contract_aliases.go.)
|
|
func RenderToolCall(e ToolCallEvent) string {
|
|
if limit, ok := legacyTurnBudgetLimit(e.Err); ok {
|
|
return toolProgressBlock("tools", "stopped", fmt.Sprintf("tool-output limit reached (%s chars); further results suppressed", limit))
|
|
}
|
|
if line := cleanToolError(e.Name, e.Err); line != "" {
|
|
return toolProgressBlock(e.Name, "failed", line)
|
|
}
|
|
return toolProgressBlock(e.Name, "done", toolPreview(e.Name, e.Output))
|
|
}
|
|
|
|
// FailureKey identifies equivalent failures for channel adapters that collapse
|
|
// retries. Legacy aggregate-output-limit errors deliberately share one key
|
|
// across tool names: they are one obsolete turn-level condition, not five
|
|
// independently useful failures.
|
|
// FailureKey identifies equivalent failures for channel adapters that
|
|
// collapse retries. (A function rather than a method because ToolCallEvent
|
|
// is a messaging alias: see chat_contract_aliases.go.)
|
|
func FailureKey(e ToolCallEvent) string {
|
|
if _, ok := legacyTurnBudgetLimit(e.Err); ok {
|
|
return "legacy-turn-output-limit"
|
|
}
|
|
if line := cleanToolError(e.Name, e.Err); line != "" {
|
|
return strings.TrimSpace(e.Name) + "\x00" + line
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func toolProgressBlock(name, status, preview string) string {
|
|
name = strings.TrimSpace(name)
|
|
if name == "" {
|
|
name = "tool"
|
|
}
|
|
preview = strings.ReplaceAll(strings.TrimSpace(preview), "```", "''' ")
|
|
if preview == "" {
|
|
preview = "completed"
|
|
}
|
|
return "🔧 " + name + " — " + status + "\n```text\n" + truncateRunes(preview, 180) + "\n```"
|
|
}
|
|
|
|
func toolPreview(name, output string) string {
|
|
content, _ := unwrapToolContent(output)
|
|
preview, skipped := compactToolPreview(content)
|
|
if preview == "" {
|
|
if strings.TrimSpace(content) == "" {
|
|
return "completed"
|
|
}
|
|
return "completed with no printable preview"
|
|
}
|
|
remaining := max(countNonEmptyOrContentLines(content)-1-skipped, 0)
|
|
if remaining > 0 {
|
|
return fmt.Sprintf("%s\n… %d more lines", preview, remaining)
|
|
}
|
|
_ = name
|
|
return preview
|
|
}
|
|
|
|
func compactToolPreview(output string) (string, int) {
|
|
skipped := 0
|
|
for line := range strings.SplitSeq(output, "\n") {
|
|
line = strings.TrimSpace(line)
|
|
if line == "" {
|
|
continue
|
|
}
|
|
if strings.Contains(line, "/pkg/mod/") {
|
|
skipped++
|
|
continue
|
|
}
|
|
return truncateRunes(line, 120), skipped
|
|
}
|
|
return "", skipped
|
|
}
|
|
|
|
func unwrapToolContent(output string) (string, bool) {
|
|
trimmed := strings.TrimSpace(output)
|
|
if trimmed == "" {
|
|
return "", false
|
|
}
|
|
var envelope struct {
|
|
Content string `json:"content"`
|
|
}
|
|
if json.Unmarshal([]byte(trimmed), &envelope) == nil && envelope.Content != "" {
|
|
return envelope.Content, true
|
|
}
|
|
var quoted string
|
|
if json.Unmarshal([]byte(trimmed), "ed) == nil {
|
|
return quoted, true
|
|
}
|
|
return output, false
|
|
}
|
|
|
|
func countNonEmptyOrContentLines(s string) int {
|
|
if strings.TrimSpace(s) == "" {
|
|
return 0
|
|
}
|
|
trimmed := strings.TrimRight(s, "\r\n")
|
|
return strings.Count(trimmed, "\n") + 1
|
|
}
|
|
|
|
func cleanToolError(name, raw string) string {
|
|
line := firstNonEmptyLine(raw)
|
|
prefix := "tool " + strings.TrimSpace(name) + ": "
|
|
line = strings.TrimPrefix(line, prefix)
|
|
return truncateRunes(strings.TrimSpace(line), toolSummaryMaxRunes)
|
|
}
|
|
|
|
func legacyTurnBudgetLimit(raw string) (string, bool) {
|
|
const marker = "turn budget exceeded ("
|
|
_, after, ok := strings.Cut(raw, marker)
|
|
if !ok {
|
|
return "", false
|
|
}
|
|
rest := after
|
|
end := strings.Index(rest, " chars)")
|
|
if end < 1 {
|
|
return "", false
|
|
}
|
|
return rest[:end], true
|
|
}
|
|
|
|
// SummarizeToolParameters returns a bounded JSON shape of tool input. Every
|
|
// string value is replaced rather than echoed because credentials can appear
|
|
// inside ordinary parameters such as command, content, or body. Values under
|
|
// secret-bearing keys use an explicit redaction marker; other strings retain
|
|
// only their type. Invalid JSON is never echoed.
|
|
func SummarizeToolParameters(input string) string {
|
|
if strings.TrimSpace(input) == "" {
|
|
return ""
|
|
}
|
|
decoder := json.NewDecoder(strings.NewReader(input))
|
|
decoder.UseNumber()
|
|
var value any
|
|
if err := decoder.Decode(&value); err != nil {
|
|
return "[unavailable]"
|
|
}
|
|
value = redactToolParameters(value, false)
|
|
encoded, err := json.Marshal(value)
|
|
if err != nil {
|
|
return "[unavailable]"
|
|
}
|
|
return truncateRunesWithinLimit(string(encoded), toolParametersMaxRunes)
|
|
}
|
|
|
|
func redactToolParameters(value any, sensitive bool) any {
|
|
if sensitive {
|
|
return redactedParameterValue
|
|
}
|
|
switch typed := value.(type) {
|
|
case map[string]any:
|
|
for key, child := range typed {
|
|
typed[key] = redactToolParameters(child, sensitiveParameterKey(key))
|
|
}
|
|
return typed
|
|
case []any:
|
|
for i, child := range typed {
|
|
typed[i] = redactToolParameters(child, sensitive)
|
|
}
|
|
return typed
|
|
case string:
|
|
return "[string]"
|
|
default:
|
|
return value
|
|
}
|
|
}
|
|
|
|
func sensitiveParameterKey(key string) bool {
|
|
normalized := strings.NewReplacer("-", "_", " ", "_").Replace(strings.ToLower(key))
|
|
for _, marker := range []string{
|
|
"token", "secret", "password", "passwd", "pwd", "passphrase",
|
|
"api_key", "apikey", "api_secret", "client_secret", "private_key", "secret_key",
|
|
"signing_key", "authorization", "bearer", "credential", "cookie", "session",
|
|
"access_token", "refresh_token", "id_token", "bot_token", "webhook_secret",
|
|
"x_api_key", "x_auth_token", "jwt", "oauth", "csrf", "otp", "signature",
|
|
} {
|
|
if strings.Contains(normalized, marker) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func truncateRunesWithinLimit(s string, limit int) string {
|
|
runes := []rune(s)
|
|
if len(runes) <= limit {
|
|
return s
|
|
}
|
|
if limit <= 1 {
|
|
return "…"
|
|
}
|
|
return string(runes[:limit-1]) + "…"
|
|
}
|
|
|
|
// DeltaFunc adapts a plain text-delta callback to TurnStream for callers that
|
|
// render text only. Tool events are discarded. A nil DeltaFunc is inert, so
|
|
// DeltaFunc(nil) is a usable "stream nothing" sink.
|
|
type DeltaFunc func(string)
|
|
|
|
// Delta forwards the fragment to the wrapped callback.
|
|
func (f DeltaFunc) Delta(text string) {
|
|
if f == nil {
|
|
return
|
|
}
|
|
f(text)
|
|
}
|
|
|
|
// ToolCall discards the event: a text-only caller has nowhere to put it.
|
|
func (f DeltaFunc) ToolCall(ToolCallEvent) {}
|
|
|
|
// Media discards the event: a text-only caller has nowhere to put it.
|
|
func (f DeltaFunc) Media(MediaEvent) {}
|
|
|
|
// toolCallRecorder wraps a TurnStream, forwarding every event to it
|
|
// unchanged while also recording the tool calls in arrival order. The
|
|
// recording happens regardless of whether next is nil (a non-streaming
|
|
// caller, e.g. Router.LLM) so a turn's tool activity is captured for
|
|
// persistence and later replay even when nothing rendered it live the first
|
|
// time.
|
|
type toolCallRecorder struct {
|
|
next TurnStream
|
|
events []ToolCallEvent
|
|
}
|
|
|
|
// Delta forwards the fragment to the wrapped stream, if any.
|
|
func (r *toolCallRecorder) Delta(text string) {
|
|
if r.next != nil {
|
|
r.next.Delta(text)
|
|
}
|
|
}
|
|
|
|
// ToolCall records the event, then forwards it to the wrapped stream, if
|
|
// any.
|
|
func (r *toolCallRecorder) ToolCall(event ToolCallEvent) {
|
|
r.events = append(r.events, event)
|
|
if r.next != nil {
|
|
r.next.ToolCall(event)
|
|
}
|
|
}
|
|
|
|
// Media forwards the event to the wrapped stream, if any. Unlike ToolCall,
|
|
// it is not recorded: media persistence and replay are not yet a supported
|
|
// path (see archie-core-1786748942243-6-f109697e), so recording it here
|
|
// would create a ledger field nothing reads.
|
|
func (r *toolCallRecorder) Media(event MediaEvent) {
|
|
if r.next != nil {
|
|
r.next.Media(event)
|
|
}
|
|
}
|
|
|
|
// firstNonEmptyLine returns the first line of s that holds something other
|
|
// than whitespace, trimmed. It returns "" when there is no such line.
|
|
func firstNonEmptyLine(s string) string {
|
|
for line := range strings.SplitSeq(s, "\n") {
|
|
if trimmed := strings.TrimSpace(line); trimmed != "" {
|
|
return trimmed
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// truncateRunes shortens s to at most maxRunes runes, marking the cut with an
|
|
// ellipsis. Counting runes rather than bytes keeps multi-byte text from being
|
|
// cut mid-character.
|
|
func truncateRunes(s string, maxRunes int) string {
|
|
runes := []rune(s)
|
|
if len(runes) <= maxRunes {
|
|
return s
|
|
}
|
|
return string(runes[:maxRunes]) + "…"
|
|
}
|