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.
140 lines
4.3 KiB
Go
140 lines
4.3 KiB
Go
// Lifted from tau internal/agent/tools/write.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 (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
)
|
|
|
|
// WriteParams are the parameters for the write tool.
|
|
type WriteParams struct {
|
|
Path string `json:"path"`
|
|
Content string `json:"content"`
|
|
Overwrite bool `json:"overwrite,omitempty"`
|
|
}
|
|
|
|
var writeSchema = Schema{
|
|
Name: "write",
|
|
Description: "Create or overwrite a file with the given content. Creates parent directories as needed. Set overwrite to true to replace an existing file; otherwise the tool will refuse to overwrite.",
|
|
Parameters: json.RawMessage(`{
|
|
"type": "object",
|
|
"properties": {
|
|
"path": {
|
|
"type": "string",
|
|
"description": "Absolute or relative file path to write"
|
|
},
|
|
"content": {
|
|
"type": "string",
|
|
"description": "The full file content to write"
|
|
},
|
|
"overwrite": {
|
|
"type": "boolean",
|
|
"description": "Allow overwriting an existing file. Defaults to false - the tool will error if the file already exists unless this is true."
|
|
}
|
|
},
|
|
"required": ["path", "content"]
|
|
}`),
|
|
}
|
|
|
|
// NewWriteTool creates the built-in write tool.
|
|
func NewWriteTool(cwd string, mq *MutationQueue, rt *ReadTracker) Tool {
|
|
return Tool{
|
|
Schema: writeSchema,
|
|
Source: "builtin",
|
|
Execute: makeWriteExecutor(cwd, mq, rt),
|
|
}
|
|
}
|
|
|
|
func makeWriteExecutor(cwd string, mq *MutationQueue, rt *ReadTracker) Executor {
|
|
return func(ctx context.Context, params json.RawMessage, _ UIBridge) (Result, error) {
|
|
var p WriteParams
|
|
if err := json.Unmarshal(params, &p); err != nil {
|
|
return Result{Content: fmt.Sprintf("invalid parameters: %v", err), IsError: true}, nil
|
|
}
|
|
|
|
if len(p.Content) > maxWriteBytes {
|
|
return Result{Content: fmt.Sprintf("content too large (%s > %s)", FormatSize(len(p.Content)), FormatSize(maxWriteBytes)), IsError: true}, nil
|
|
}
|
|
|
|
path := resolvePath(cwd, p.Path)
|
|
|
|
if !isConfined(cwd, path) {
|
|
return Result{Content: "path escapes working directory", IsError: true}, nil
|
|
}
|
|
|
|
writeCtx, cancel := context.WithTimeout(ctx, DefaultToolTimeout)
|
|
defer cancel()
|
|
|
|
var result Result
|
|
err := runWithContext(writeCtx, func() error {
|
|
// Check for accidental overwrite and enforce read-before-write.
|
|
// Both checks only apply when the file already exists; new files
|
|
// are always allowed.
|
|
var oldContent string
|
|
if info, err := os.Stat(path); err == nil && info.Mode().IsRegular() {
|
|
// Read-before-write: model must have read the file before mutating it.
|
|
if rt != nil {
|
|
if err := rt.CheckRead(cwd, p.Path); err != nil {
|
|
result = Result{Content: err.Error(), IsError: true}
|
|
return nil
|
|
}
|
|
}
|
|
// Overwrite protection: require explicit opt-in.
|
|
if !p.Overwrite {
|
|
result = Result{
|
|
Content: fmt.Sprintf(
|
|
"file %q already exists - set overwrite to true to replace it, or use the edit tool for partial changes",
|
|
path,
|
|
),
|
|
IsError: true,
|
|
}
|
|
return nil
|
|
}
|
|
if data, err := os.ReadFile(path); err == nil {
|
|
oldContent = string(data)
|
|
}
|
|
}
|
|
|
|
release := mq.Acquire(path)
|
|
defer release()
|
|
|
|
dir := filepath.Dir(path)
|
|
if err := os.MkdirAll(dir, 0o755); err != nil {
|
|
result = Result{Content: fmt.Sprintf("error creating directory: %v", err), IsError: true}
|
|
return nil
|
|
}
|
|
|
|
if err := writeFileAtomic(path, []byte(p.Content), 0o644); err != nil {
|
|
result = Result{Content: fmt.Sprintf("error writing file: %v", err), IsError: true}
|
|
return nil
|
|
}
|
|
|
|
result = Result{
|
|
Content: fmt.Sprintf("wrote %d bytes to %s", len(p.Content), path),
|
|
Details: DiffDetails{Path: path, OldContent: oldContent, NewContent: p.Content},
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
if errors.Is(err, context.DeadlineExceeded) {
|
|
return Result{Content: fmt.Sprintf("write timed out after %v", DefaultToolTimeout), IsError: true}, nil
|
|
}
|
|
return Result{Content: fmt.Sprintf("write failed: %v", err), IsError: true}, nil
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
}
|