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.
97 lines
2.6 KiB
Go
97 lines
2.6 KiB
Go
// Lifted from tau internal/agent/tools/mutation.go
|
|
// tau commit f5289ea3782c099339c2d26fe3af8ebcf42ba52d (2026-07-27).
|
|
//
|
|
// Mutations from upstream:
|
|
// - package renamed tools -> builtin (archie-core already has an
|
|
// internal/tools package holding the registry these are registered into).
|
|
//
|
|
// Refresh by diffing against that path at a newer tau commit. Do not
|
|
// edit without recording the change above.
|
|
package builtin
|
|
|
|
import (
|
|
"sync"
|
|
)
|
|
|
|
// MutationQueue serializes write operations to the same file path,
|
|
// preventing concurrent edits from clobbering each other during
|
|
// parallel tool execution.
|
|
//
|
|
// A sync.RWMutex coordinates between shell commands and file-mutation
|
|
// tools. File mutations (write, edit) take a read lock so they
|
|
// can run concurrently with each other. Shell commands take the write
|
|
// lock, blocking all file mutations for the duration of the command.
|
|
type MutationQueue struct {
|
|
mu sync.Mutex
|
|
locks map[string]*mutexEntry
|
|
|
|
globalMu sync.RWMutex
|
|
}
|
|
|
|
// mutexEntry tracks a per-file mutex and its active holder count.
|
|
type mutexEntry struct {
|
|
mu sync.Mutex
|
|
holders int
|
|
}
|
|
|
|
// NewMutationQueue creates a new per-file mutation queue.
|
|
func NewMutationQueue() *MutationQueue {
|
|
return &MutationQueue{
|
|
locks: make(map[string]*mutexEntry),
|
|
}
|
|
}
|
|
|
|
// GlobalLock blocks until all in-flight per-file mutations complete, then
|
|
// prevents new per-file Acquire calls from proceeding until GlobalUnlock
|
|
// is called. Used by the shell tool to ensure no race between shell
|
|
// commands and file-mutation tools.
|
|
func (q *MutationQueue) GlobalLock() {
|
|
q.globalMu.Lock()
|
|
}
|
|
|
|
// GlobalUnlock releases the global lock, allowing per-file mutations to
|
|
// proceed again.
|
|
func (q *MutationQueue) GlobalUnlock() {
|
|
q.globalMu.Unlock()
|
|
}
|
|
|
|
// Acquire returns a lock for the given file path. The caller must call
|
|
// the returned release function when done with the mutation.
|
|
//
|
|
// Acquire blocks while the global write lock is held (i.e. while a shell
|
|
// command is running).
|
|
//
|
|
// Usage:
|
|
//
|
|
// release := q.Acquire("/path/to/file.go")
|
|
// defer release()
|
|
// // ... perform read-modify-write ...
|
|
func (q *MutationQueue) Acquire(path string) (release func()) {
|
|
// Take a read lock so shell commands (which take the write lock)
|
|
// block until we're done, and we block while a shell command runs.
|
|
q.globalMu.RLock()
|
|
|
|
q.mu.Lock()
|
|
entry, ok := q.locks[path]
|
|
if !ok {
|
|
entry = &mutexEntry{}
|
|
q.locks[path] = entry
|
|
}
|
|
entry.holders++
|
|
q.mu.Unlock()
|
|
|
|
entry.mu.Lock()
|
|
return func() {
|
|
entry.mu.Unlock()
|
|
|
|
q.mu.Lock()
|
|
entry.holders--
|
|
if entry.holders == 0 {
|
|
delete(q.locks, path)
|
|
}
|
|
q.mu.Unlock()
|
|
|
|
q.globalMu.RUnlock()
|
|
}
|
|
}
|