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.
78 lines
2.4 KiB
Go
78 lines
2.4 KiB
Go
package builtin
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestRunWithContext_ReturnsFnResult(t *testing.T) {
|
|
err := runWithContext(context.Background(), func() error { return nil })
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
sentinel := errors.New("boom")
|
|
err = runWithContext(context.Background(), func() error { return sentinel })
|
|
if !errors.Is(err, sentinel) {
|
|
t.Fatalf("expected sentinel error, got %v", err)
|
|
}
|
|
}
|
|
|
|
// TestRunWithContext_ReturnsCtxErrOnAlreadyExpired verifies that when the
|
|
// context is already done before runWithContext is called, no goroutine is
|
|
// spawned and the context error is returned immediately.
|
|
func TestRunWithContext_ReturnsCtxErrOnAlreadyExpired(t *testing.T) {
|
|
ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(-time.Second))
|
|
defer cancel()
|
|
|
|
spawned := make(chan struct{})
|
|
err := runWithContext(ctx, func() error {
|
|
close(spawned)
|
|
return nil
|
|
})
|
|
|
|
if !errors.Is(err, context.DeadlineExceeded) {
|
|
t.Fatalf("expected context.DeadlineExceeded, got %v", err)
|
|
}
|
|
|
|
// The goroutine must NOT have been spawned because the context
|
|
// was already expired. Give it a short grace period to prove the
|
|
// negative.
|
|
select {
|
|
case <-spawned:
|
|
t.Fatal("fn was spawned even though the context was already expired — goroutine leak")
|
|
case <-time.After(50 * time.Millisecond):
|
|
// Expected: fn was never called.
|
|
}
|
|
}
|
|
|
|
// TestRunWithContext_ReturnsCtxErrOnTimeout is the core regression coverage
|
|
// for tau-6wa: fn blocks forever (simulating a hung filesystem call); the
|
|
// caller must get control back once ctx expires rather than waiting for fn.
|
|
func TestRunWithContext_ReturnsCtxErrOnTimeout(t *testing.T) {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
|
|
defer cancel()
|
|
|
|
fnStarted := make(chan struct{})
|
|
blockForever := make(chan struct{}) // deliberately never closed
|
|
|
|
start := time.Now()
|
|
err := runWithContext(ctx, func() error {
|
|
close(fnStarted)
|
|
<-blockForever
|
|
return nil
|
|
})
|
|
elapsed := time.Since(start)
|
|
|
|
<-fnStarted // make sure fn actually started (and is now hung) before checking the result
|
|
|
|
if !errors.Is(err, context.DeadlineExceeded) {
|
|
t.Fatalf("expected context.DeadlineExceeded, got %v", err)
|
|
}
|
|
if elapsed > 500*time.Millisecond {
|
|
t.Fatalf("runWithContext took %v to return after the deadline, expected it to return promptly instead of waiting on the hung fn", elapsed)
|
|
}
|
|
}
|