A tool call rendered as a label line plus a ```text fence. Telegram draws a fenced block as a full code widget (language header bar, copy button, panel), and the block parser inserts a spacer paragraph before every block, so one call cost four rendered elements. Three calls filled the screen to show three word counts. Every toolPreview path already summarises to a single line, so the fence was never wrapping more than one. Drop it and put the preview on the header line. Tool lines now join with a hard break rather than a bare newline: a soft break would space-join them into one run-on paragraph, and a blank line would put the spacer back. Three calls are now three consecutive blocks. Two hardcoded values go with it. The status word is printed only when the outcome is not success, since every line otherwise read "done" and distinguished nothing. The icon is no longer a literal in the renderer: each builtin declares its own on tools.Tool (not on Schema, which is the model's contract), the provider carries it into ToolEntry, and the turn snapshots the registry's icons alongside its tool set. A tool that declares none renders without one rather than borrowing a generic wrench. Carries a dependency upgrade (go.mod, go.sum, tools/go.mod, tools/go.sum).
159 lines
4.9 KiB
Go
159 lines
4.9 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",
|
|
Emoji: "📝",
|
|
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.
|
|
oldContent, block := checkExistingFile(path, cwd, p.Path, p.Overwrite, rt)
|
|
if block != nil {
|
|
result = *block
|
|
return nil
|
|
}
|
|
|
|
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
|
|
}
|
|
}
|
|
|
|
// isRegularFile reports whether path exists and is a regular file. A missing
|
|
// file, a directory, a symlink, or any other non-regular entry returns false,
|
|
// which lets new files skip the overwrite and read-before-write checks.
|
|
func isRegularFile(path string) bool {
|
|
info, err := os.Stat(path)
|
|
return err == nil && info.Mode().IsRegular()
|
|
}
|
|
|
|
// checkExistingFile returns the prior content of an existing regular file and,
|
|
// when a write should not proceed, a blocking error result. It enforces the
|
|
// read-before-write rule and overwrite opt-in, returning nil when the file may
|
|
// be written. Non-regular or missing paths return an empty content and no
|
|
// block.
|
|
func checkExistingFile(path, cwd, relPath string, overwrite bool, rt *ReadTracker) (string, *Result) {
|
|
if !isRegularFile(path) {
|
|
return "", nil
|
|
}
|
|
if rt != nil {
|
|
if err := rt.CheckRead(cwd, relPath); err != nil {
|
|
return "", &Result{Content: err.Error(), IsError: true}
|
|
}
|
|
}
|
|
if !overwrite {
|
|
return "", &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,
|
|
}
|
|
}
|
|
if data, err := os.ReadFile(path); err == nil {
|
|
return string(data), nil
|
|
}
|
|
return "", nil
|
|
}
|