The chat agent had two tools -- memory_edit and skill_activate -- so it
could not read a file, search a tree or run a command. ai-sdk's runtime
already drives a tool loop for it (MaxSteps 8, toolExecute wired as the
executor), so the loop was never the missing piece: the registry was empty
of anything useful.
Lifted from tau internal/agent/tools at commit f5289ea, per the recorded
copy-and-mutate strategy: every file carries a provenance header naming its
tau source path, the commit, and the mutations made, so refreshing from
upstream is a diff rather than archaeology.
internal/tools/builtin/ the lifted tools, ~3.1k lines
internal/tools/provider/builtin/ the adapter to tools.ToolEntry
Six tools: read, write, edit, shell, grep, find. Tau's own tests came with
them and pass unmodified, which is the evidence that the lift is faithful.
Deliberately not lifted:
- agent.go (1214 lines): subagent spawning, and the only real coupling in
the package -- 10 tau packages including chat, sessions, store and
registry. Nothing the chat agent needs to do work.
- skill.go: depends on tau's skills package; archie has internal/skill and
already exposes skill_activate.
- docs.go: serves tau's own embedded documentation via tau/docs.
Not lifting the coordinator either. It is tau's agent loop (6.4k lines over
ten packages) and archie already has one in the ai-sdk runtime; porting it
would leave two loops competing. Its cancellation and tool events are worth
having, but they are a few hundred lines built against the existing path
rather than six thousand lifted onto a second one.
The adapter bridges two shape differences: archie hands handlers decoded
arguments where tau's executor takes raw JSON, and tau reports tool-level
failure in Result.IsError rather than as an error -- surfaced as a real
error so the runtime and the guardrail engine both see it. Tools are
classified idempotent or mutating for guardrails and budgets; that is
categorisation, not a jail.
chat.workspace roots the tools and defaults to empty, which registers none
of them. They read, write and execute, so the directory has to be a
deliberate choice rather than whatever the daemon started in -- in the
container that is /.
Verified: go build, go vet, gofmt clean; full suite passes.
110 lines
2.6 KiB
Go
110 lines
2.6 KiB
Go
package builtin_test
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/samcharles93/archie-core/internal/tools/builtin"
|
|
)
|
|
|
|
func TestTruncateHead_NoTruncation(t *testing.T) {
|
|
content := "line1\nline2\nline3"
|
|
result := builtin.TruncateHead(content, 100, 100000)
|
|
|
|
if result.Truncated {
|
|
t.Fatal("should not be truncated")
|
|
}
|
|
if result.Content != content {
|
|
t.Fatalf("content mismatch: got %q", result.Content)
|
|
}
|
|
}
|
|
|
|
func TestTruncateHead_ByLines(t *testing.T) {
|
|
lines := make([]string, 100)
|
|
for i := range lines {
|
|
lines[i] = "x"
|
|
}
|
|
content := strings.Join(lines, "\n")
|
|
|
|
result := builtin.TruncateHead(content, 10, 100000)
|
|
|
|
if !result.Truncated {
|
|
t.Fatal("should be truncated")
|
|
}
|
|
if result.OriginalLine != 100 {
|
|
t.Fatalf("expected 100 original lines, got %d", result.OriginalLine)
|
|
}
|
|
if !strings.Contains(result.Content, "[truncated:") {
|
|
t.Fatal("should contain truncation notice")
|
|
}
|
|
if !strings.Contains(result.Content, "10/100 lines") {
|
|
t.Fatalf("truncation notice should mention line counts, got: %s", result.Content)
|
|
}
|
|
}
|
|
|
|
func TestTruncateHead_ByBytes(t *testing.T) {
|
|
content := strings.Repeat("a", 1000)
|
|
|
|
result := builtin.TruncateHead(content, 10000, 100)
|
|
|
|
if !result.Truncated {
|
|
t.Fatal("should be truncated by bytes")
|
|
}
|
|
if result.OriginalSize != 1000 {
|
|
t.Fatalf("expected 1000 original bytes, got %d", result.OriginalSize)
|
|
}
|
|
}
|
|
|
|
func TestTruncateTail_NoTruncation(t *testing.T) {
|
|
content := "line1\nline2\nline3"
|
|
result := builtin.TruncateTail(content, 100, 100000)
|
|
|
|
if result.Truncated {
|
|
t.Fatal("should not be truncated")
|
|
}
|
|
if result.Content != content {
|
|
t.Fatalf("content mismatch")
|
|
}
|
|
}
|
|
|
|
func TestTruncateTail_ByLines(t *testing.T) {
|
|
lines := make([]string, 100)
|
|
for i := range lines {
|
|
lines[i] = "x"
|
|
}
|
|
content := strings.Join(lines, "\n")
|
|
|
|
result := builtin.TruncateTail(content, 10, 100000)
|
|
|
|
if !result.Truncated {
|
|
t.Fatal("should be truncated")
|
|
}
|
|
if !strings.Contains(result.Content, "last 10/100 lines") {
|
|
t.Fatalf("truncation notice should mention line counts, got: %s", result.Content)
|
|
}
|
|
// The kept content should be the last 10 lines (all "x").
|
|
kept := strings.Split(strings.TrimSpace(result.Content), "\n")
|
|
// Last 10 lines + truncation notice line + blank line = 12.
|
|
if len(kept) < 10 {
|
|
t.Fatalf("expected at least 10 kept lines, got %d", len(kept))
|
|
}
|
|
}
|
|
|
|
func TestFormatSize(t *testing.T) {
|
|
cases := []struct {
|
|
input int
|
|
expected string
|
|
}{
|
|
{500, "500B"},
|
|
{1024, "1.0KB"},
|
|
{51200, "50.0KB"},
|
|
{1048576, "1.0MB"},
|
|
}
|
|
for _, tc := range cases {
|
|
got := builtin.FormatSize(tc.input)
|
|
if got != tc.expected {
|
|
t.Errorf("FormatSize(%d) = %q, want %q", tc.input, got, tc.expected)
|
|
}
|
|
}
|
|
}
|