Files
archie/internal/gateway/task_tools_test.go
T
sam 5e240721e2 feat(logging): cursor pagination and filtering for task_logs
task_logs could only read the newest N entries with no way to walk the
rest, so a task's log beyond the page cap was unreachable and the agent
had no honest way to say what was missing. Add logging.Page -- a
byte-offset cursor over the tail-most 8 MiB scan window -- plus
Query.Since/Until time bounds, and wire the gateway's task_logs tool to
expose level/since/until/after_id with cursor and more_available in the
result.

The reader now reads the scan window into a single in-memory buffer and
walks it by exact slice offsets. Offsets into a contiguous buffer are
trivially correct, which an incremental reader over the file is not:
bufio.Reader buffers ahead, so its underlying file position runs one
buffer past its logical position and cannot be used as a cursor. The
same rewrite removes f.Read in favour of f.ReadAt (full-or-error), since
a silent short read would drop the newest entries and still report
success.

The scan window is a documented hard ceiling: for a log over 8 MiB the
oldest bytes are unreachable by any cursor -- that is what Truncated
reports, and send_file remains the path for a complete archive. The
tool description teaches the model the difference between more_available
(more this call did not return) and truncated (older entries the scan
cap hides).

Closes archie-core-vq92 (#625).
2026-08-26 02:02:36 +10:00

527 lines
17 KiB
Go

package gateway
import (
"context"
"errors"
"fmt"
"strings"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/tools"
)
type fakeLister struct {
tasks []ChatTaskSummary
err error
gotIdentity string
gotLimit int
}
func (f *fakeLister) ListChatTasks(_ context.Context, identity string, limit int) ([]ChatTaskSummary, error) {
f.gotIdentity, f.gotLimit = identity, limit
return f.tasks, f.err
}
type fakeCreator struct {
id int64
err error
got SpawnRequest
}
func (f *fakeCreator) CreateTask(_ context.Context, req SpawnRequest) (int64, error) {
f.got = req
return f.id, f.err
}
// toolNamed pulls one entry out of the built set.
func toolNamed(t *testing.T, entries []tools.ToolEntry, name string) tools.ToolEntry {
t.Helper()
for _, e := range entries {
if e.Name == name {
return e
}
}
t.Fatalf("TaskTools() has no %q entry", name)
return tools.ToolEntry{}
}
func TestTaskToolsValidate(t *testing.T) {
entries := TaskTools(&fakeLister{}, &fakeCreator{}, nil, nil, "archie")
if len(entries) == 0 {
t.Fatal("TaskTools() returned nothing")
}
for _, e := range entries {
if err := e.Validate(); err != nil {
t.Errorf("entry %q: %v", e.Name, err)
}
}
}
// TestTaskToolsOmitNilBackends checks that a daemon without chat task support
// advertises nothing, rather than offering a tool that always fails.
func TestTaskToolsOmitNilBackends(t *testing.T) {
tests := []struct {
name string
lister ChatTaskLister
creator TaskCreator
want []string
}{
{name: "both", lister: &fakeLister{}, creator: &fakeCreator{}, want: []string{"task_list", "task_spawn"}},
{name: "lister only", lister: &fakeLister{}, want: []string{"task_list"}},
{name: "creator only", creator: &fakeCreator{}, want: []string{"task_spawn"}},
{name: "neither"},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
entries := TaskTools(tc.lister, tc.creator, nil, nil, "archie")
var got []string
for _, e := range entries {
got = append(got, e.Name)
}
if strings.Join(got, ",") != strings.Join(tc.want, ",") {
t.Errorf("tools = %v, want %v", got, tc.want)
}
})
}
}
// TestTaskListUsesBoundIdentity is the authorization property: the identity
// comes from the gateway that built the tool, never from the model. A model
// that could name an identity could read another instance's work.
func TestTaskListUsesBoundIdentity(t *testing.T) {
lister := &fakeLister{tasks: []ChatTaskSummary{{ID: 7, Title: "wire the thing", Status: "running"}}}
entry := toolNamed(t, TaskTools(lister, nil, nil, nil, "archie"), "task_list")
// The model supplies an identity; it must be ignored.
if _, err := entry.Handler(context.Background(), map[string]any{"identity": "someone-else"}); err != nil {
t.Fatal(err)
}
if lister.gotIdentity != "archie" {
t.Errorf("listed identity %q, want the bound %q", lister.gotIdentity, "archie")
}
}
func TestTaskListLimit(t *testing.T) {
tests := []struct {
name string
input map[string]any
want int
}{
{name: "default when absent", input: map[string]any{}, want: defaultTaskListLimit},
{name: "explicit", input: map[string]any{"limit": float64(5)}, want: 5},
{name: "clamped to the maximum", input: map[string]any{"limit": float64(10_000)}, want: maxTaskListLimit},
{name: "non-positive falls back to the default", input: map[string]any{"limit": float64(0)}, want: defaultTaskListLimit},
{name: "negative falls back to the default", input: map[string]any{"limit": float64(-3)}, want: defaultTaskListLimit},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
lister := &fakeLister{}
entry := toolNamed(t, TaskTools(lister, nil, nil, nil, "archie"), "task_list")
if _, err := entry.Handler(context.Background(), tc.input); err != nil {
t.Fatal(err)
}
if lister.gotLimit != tc.want {
t.Errorf("limit = %d, want %d", lister.gotLimit, tc.want)
}
})
}
}
func TestTaskListFiltersByStatus(t *testing.T) {
lister := &fakeLister{tasks: []ChatTaskSummary{
{ID: 1, Status: "running"},
{ID: 2, Status: "queued"},
{ID: 3, Status: "running"},
}}
entry := toolNamed(t, TaskTools(lister, nil, nil, nil, "archie"), "task_list")
out, err := entry.Handler(context.Background(), map[string]any{"status": "running"})
if err != nil {
t.Fatal(err)
}
result, ok := out.(TaskListResult)
if !ok {
t.Fatalf("handler returned %T, want TaskListResult", out)
}
if len(result.Tasks) != 2 {
t.Fatalf("got %d tasks, want the 2 running ones", len(result.Tasks))
}
for _, task := range result.Tasks {
if task.Status != "running" {
t.Errorf("task %d has status %q, want only running", task.ID, task.Status)
}
}
}
// TestTaskListEmptyIsNotAnError guards against the model reading an empty
// queue as a broken tool and retrying.
func TestTaskListEmptyIsNotAnError(t *testing.T) {
entry := toolNamed(t, TaskTools(&fakeLister{}, nil, nil, nil, "archie"), "task_list")
out, err := entry.Handler(context.Background(), map[string]any{})
if err != nil {
t.Fatalf("empty list returned an error: %v", err)
}
result, ok := out.(TaskListResult)
if !ok {
t.Fatalf("handler returned %T, want TaskListResult", out)
}
if result.Tasks == nil {
t.Error("Tasks is nil, want an empty slice so it marshals as [] not null")
}
}
func TestTaskListPropagatesStoreError(t *testing.T) {
lister := &fakeLister{err: errors.New("database is gone")}
entry := toolNamed(t, TaskTools(lister, nil, nil, nil, "archie"), "task_list")
if _, err := entry.Handler(context.Background(), map[string]any{}); err == nil {
t.Fatal("handler error = nil, want the store failure surfaced")
}
}
func TestTaskSpawn(t *testing.T) {
tests := []struct {
name string
input map[string]any
creator *fakeCreator
wantErr bool
wantTitle string
wantRepo string
}{
{
name: "title only",
input: map[string]any{"title": "fix the parser"},
creator: &fakeCreator{id: 42},
wantTitle: "fix the parser",
},
{
name: "with repo and workflow",
input: map[string]any{"title": "port it", "repo": "acme/app", "workflow": "tdd"},
creator: &fakeCreator{id: 43},
wantTitle: "port it",
wantRepo: "acme/app",
},
{
name: "missing title is refused",
input: map[string]any{},
creator: &fakeCreator{id: 44},
wantErr: true,
},
{
name: "blank title is refused",
input: map[string]any{"title": " "},
creator: &fakeCreator{id: 45},
wantErr: true,
},
{
name: "creator rejection surfaces",
input: map[string]any{"title": "x", "repo": "not/allowed"},
creator: &fakeCreator{err: fmt.Errorf("repo %q is not configured for this identity", "not/allowed")},
wantErr: true,
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
entry := toolNamed(t, TaskTools(nil, tc.creator, nil, nil, "archie"), "task_spawn")
out, err := entry.Handler(context.Background(), tc.input)
if tc.wantErr {
if err == nil {
t.Fatal("handler error = nil, want a refusal")
}
return
}
if err != nil {
t.Fatal(err)
}
if tc.creator.got.Title != tc.wantTitle {
t.Errorf("title = %q, want %q", tc.creator.got.Title, tc.wantTitle)
}
if tc.creator.got.Repo != tc.wantRepo {
t.Errorf("repo = %q, want %q", tc.creator.got.Repo, tc.wantRepo)
}
// Identity is bound, never taken from the model.
if tc.creator.got.Identity != "archie" {
t.Errorf("identity = %q, want the bound %q", tc.creator.got.Identity, "archie")
}
result, ok := out.(TaskSpawnResult)
if !ok {
t.Fatalf("handler returned %T, want TaskSpawnResult", out)
}
if result.ID != tc.creator.id {
t.Errorf("id = %d, want %d", result.ID, tc.creator.id)
}
})
}
}
// TestTaskSpawnIgnoresModelIdentity is the counterpart to the list case: a
// model must not be able to file work under another instance's identity.
func TestTaskSpawnIgnoresModelIdentity(t *testing.T) {
creator := &fakeCreator{id: 1}
entry := toolNamed(t, TaskTools(nil, creator, nil, nil, "archie"), "task_spawn")
if _, err := entry.Handler(context.Background(), map[string]any{
"title": "sneaky",
"identity": "other-archie",
}); err != nil {
t.Fatal(err)
}
if creator.got.Identity != "archie" {
t.Errorf("identity = %q, want the bound %q", creator.got.Identity, "archie")
}
}
// TestTaskToolsExcludeApprovalTools records a deliberate omission: approving a
// waiting_human task is the one human checkpoint in the lifecycle, and chat is
// an untrusted input path. If these are ever added they must be a considered
// decision, not an accident.
func TestTaskToolsExcludeApprovalTools(t *testing.T) {
entries := TaskTools(&fakeLister{}, &fakeCreator{}, nil, nil, "archie")
for _, e := range entries {
switch e.Name {
case "task_approve", "task_cancel":
t.Errorf("%q is exposed to the model; approval must stay a human action", e.Name)
}
}
}
// ── task_logs tests ──────────────────────────────────────────────────────
type fakeLogReader struct {
result ChatTaskLogResult
err error
gotIdentity string
gotTaskID int64
gotAttempt int
gotQuery ChatTaskLogQuery
}
func (f *fakeLogReader) ReadChatTaskLogs(_ context.Context, identity string, taskID int64, attempt int, q ChatTaskLogQuery) (ChatTaskLogResult, error) {
f.gotIdentity = identity
f.gotTaskID = taskID
f.gotAttempt = attempt
f.gotQuery = q
return f.result, f.err
}
func TestTaskLogsUsesBoundIdentity(t *testing.T) {
reader := &fakeLogReader{result: ChatTaskLogResult{Attempt: 1}}
entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs")
if _, err := entry.Handler(context.Background(), map[string]any{
"task_id": float64(7), "identity": "someone-else",
}); err != nil {
t.Fatal(err)
}
if reader.gotIdentity != "archie" {
t.Errorf("identity = %q, want the bound %q", reader.gotIdentity, "archie")
}
}
func TestTaskLogsRequiresTaskID(t *testing.T) {
reader := &fakeLogReader{}
entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs")
if _, err := entry.Handler(context.Background(), map[string]any{}); err == nil {
t.Error("expected error for missing task_id, got nil")
}
}
func TestTaskLogsDefaultsAttemptToZero(t *testing.T) {
reader := &fakeLogReader{result: ChatTaskLogResult{Attempt: 0}}
entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs")
if _, err := entry.Handler(context.Background(), map[string]any{
"task_id": float64(7),
}); err != nil {
t.Fatal(err)
}
if reader.gotAttempt != 0 {
t.Errorf("attempt = %d, want 0 (zero = 'latest', resolved by the adapter)", reader.gotAttempt)
}
}
// TestTaskLogsForwardsPaginationQuery pins the schema fields the issue
// adds: Levels, Since, Until, AfterID, and Limit flow through to the
// adapter exactly as supplied. The reader fake records the query it
// received so a regression that drops or rewrites one of these would
// fail here.
func TestTaskLogsForwardsPaginationQuery(t *testing.T) {
reader := &fakeLogReader{}
entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs")
since := "2026-08-04T01:00:00Z"
until := "2026-08-04T01:59:59Z"
if _, err := entry.Handler(context.Background(), map[string]any{
"task_id": float64(7),
"attempt": float64(3),
"level": []any{"ERROR", "WARN"},
"since": since,
"until": until,
"after_id": float64(12345),
"limit": float64(500),
}); err != nil {
t.Fatal(err)
}
got := reader.gotQuery
if got.Component != "" {
t.Errorf("Component = %q, want empty (none supplied)", got.Component)
}
if len(got.Levels) != 2 || got.Levels[0] != "ERROR" || got.Levels[1] != "WARN" {
t.Errorf("Levels = %v, want [ERROR WARN]", got.Levels)
}
if got.Since.Format(time.RFC3339) != since {
t.Errorf("Since = %v, want %s", got.Since, since)
}
if got.Until.Format(time.RFC3339) != until {
t.Errorf("Until = %v, want %s", got.Until, until)
}
if got.AfterID != 12345 {
t.Errorf("AfterID = %d, want 12345", got.AfterID)
}
if got.Limit != 500 {
t.Errorf("Limit = %d, want 500", got.Limit)
}
}
// TestTaskLogsAcceptsSingleLevelString confirms the JSON flexibility: a
// model that emits a single string instead of an array still gets a
// single-element Levels list. The schema declares array but real models
// are inconsistent.
func TestTaskLogsAcceptsSingleLevelString(t *testing.T) {
reader := &fakeLogReader{}
entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs")
if _, err := entry.Handler(context.Background(), map[string]any{
"task_id": float64(1), "level": "ERROR",
}); err != nil {
t.Fatal(err)
}
if len(reader.gotQuery.Levels) != 1 || reader.gotQuery.Levels[0] != "ERROR" {
t.Errorf("Levels = %v, want [ERROR]", reader.gotQuery.Levels)
}
}
// TestTaskLogsRejectsInvalidTimestamp pins the boundary: a malformed
// since/until is rejected so the model cannot accidentally get the
// entire log back by emitting nonsense.
func TestTaskLogsRejectsInvalidTimestamp(t *testing.T) {
for field, key := range map[string]string{"since": "since", "until": "until"} {
t.Run(field, func(t *testing.T) {
reader := &fakeLogReader{}
entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs")
_, err := entry.Handler(context.Background(), map[string]any{
"task_id": float64(1),
key: "not a timestamp",
})
if err == nil {
t.Errorf("%s: expected error on malformed timestamp, got nil", field)
}
})
}
}
// TestTaskLogsResultSurfacesCursorAndMoreAvailable confirms the response
// shape: the cursor and more_available fields are passed through to the
// caller so the model can continue paging without re-deriving them.
func TestTaskLogsResultSurfacesCursorAndMoreAvailable(t *testing.T) {
reader := &fakeLogReader{result: ChatTaskLogResult{
Attempt: 2,
Cursor: 9999,
MoreAvailable: true,
Truncated: true,
Entries: []ChatTaskLogEntry{{Level: "INFO", Message: "x"}},
}}
entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs")
out, err := entry.Handler(context.Background(), map[string]any{"task_id": float64(7)})
if err != nil {
t.Fatal(err)
}
got, ok := out.(ChatTaskLogResult)
if !ok {
t.Fatalf("output type = %T, want ChatTaskLogResult", out)
}
if got.Cursor != 9999 || !got.MoreAvailable || !got.Truncated {
t.Errorf("page flags = (cursor=%d, more=%v, trunc=%v), want 9999/true/true",
got.Cursor, got.MoreAvailable, got.Truncated)
}
}
func TestTaskLogsHonoursExplicitAttempt(t *testing.T) {
reader := &fakeLogReader{result: ChatTaskLogResult{Attempt: 2}}
entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs")
if _, err := entry.Handler(context.Background(), map[string]any{
"task_id": float64(7), "attempt": float64(2),
}); err != nil {
t.Fatal(err)
}
if reader.gotAttempt != 2 {
t.Errorf("attempt = %d, want 2", reader.gotAttempt)
}
}
func TestTaskLogsLimit(t *testing.T) {
tests := []struct {
name string
input map[string]any
want int
}{
{name: "default when absent", input: map[string]any{"task_id": float64(1)}, want: defaultTaskLogLimit},
{name: "explicit", input: map[string]any{"task_id": float64(1), "limit": float64(5)}, want: 5},
{name: "clamped to the maximum", input: map[string]any{"task_id": float64(1), "limit": float64(10_000)}, want: maxTaskLogLimit},
{name: "non-positive falls back to the default", input: map[string]any{"task_id": float64(1), "limit": float64(0)}, want: defaultTaskLogLimit},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
reader := &fakeLogReader{result: ChatTaskLogResult{}}
entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs")
if _, err := entry.Handler(context.Background(), tc.input); err != nil {
t.Fatal(err)
}
if reader.gotQuery.Limit != tc.want {
t.Errorf("limit = %d, want %d", reader.gotQuery.Limit, tc.want)
}
})
}
}
func TestTaskLogsForwardsComponentAndContains(t *testing.T) {
reader := &fakeLogReader{result: ChatTaskLogResult{}}
entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs")
if _, err := entry.Handler(context.Background(), map[string]any{
"task_id": float64(7), "component": "gate", "q": "build failed",
}); err != nil {
t.Fatal(err)
}
if reader.gotQuery.Component != "gate" {
t.Errorf("Component = %q, want gate", reader.gotQuery.Component)
}
if reader.gotQuery.Contains != "build failed" {
t.Errorf("Contains = %q, want build failed", reader.gotQuery.Contains)
}
}
func TestTaskLogsOmittedWhenReaderIsNil(t *testing.T) {
entries := TaskTools(&fakeLister{}, &fakeCreator{}, nil, nil, "archie")
for _, e := range entries {
if e.Name == "task_logs" {
t.Fatal("task_logs is in the tool set when reader is nil -- a tool that always fails must not be advertised")
}
}
}
func TestTaskLogsAppearsWhenReaderIsNonNil(t *testing.T) {
entries := TaskTools(nil, nil, &fakeLogReader{}, nil, "archie")
toolNamed(t, entries, "task_logs") // fails the test if absent
}