Job 01625d11-37b7-4ab9-9867-0be1358ded11

{"path": ".", "recursive": true}

/project/README.md
/project/cmd
/project/cmd/zoo
/project/cmd/zoo/main.go
/project/docker
/project/docker/Dockerfile
/project/docker/group
/project/docker/passwd
/project/docker/shadow
/project/docker/uid1000-sudo
/project/go.mod
/project/go.sum
/project/internal
/project/internal/agentrun
/project/internal/agentrun/context.go
/project/internal/agentrun/docker.go
/project/internal/agentrun/docker_integration_test.go
/project/internal/agentrun/forgejo.go
/project/internal/agentrun/loop.go
/project/internal/agentrun/roster.go
/project/internal/agentrun/roster_test.go
/project/internal/agentrun/run.go
/project/internal/agentrun/sandboxgit.go
/project/internal/agentrun/sandboxgit_test.go
/project/internal/agentrun/seed_test.go
/project/internal/agentrun/system.md
/project/internal/config
/project/internal/config/config.go
/project/internal/config/config_test.go
/project/internal/forgejo
/project/internal/forgejo/client.go
/project/internal/forgejo/client_test.go
/project/internal/forgejo/event.go
/project/internal/forgejo/poll.go
/project/internal/forgejo/poll_test.go
/project/internal/forgejo/repo_filter.go
/project/internal/forgejo/repo_filter_test.go
/project/internal/forgejo/watcher.go
/project/internal/forgejo/watcher_test.go
/project/internal/forgejo/webhook.go
/project/internal/forgejo/webhook_test.go
/project/internal/livelog
/project/internal/livelog/hub.go
/project/internal/livelog/hub_test.go
/project/internal/llm
/project/internal/llm/client.go
/project/internal/llm/streamer.go
/project/internal/llm/streamer_test.go
/project/internal/llm/types.go
/project/internal/scheduler
/project/internal/scheduler/scheduler.go
/project/internal/scheduler/scheduler_test.go
/project/internal/store
/project/internal/store/schema.sql
/project/internal/store/store.go
/project/internal/store/store_test.go
/project/internal/tools
/project/internal/tools/bash.go
/project/internal/tools/context.go
/project/internal/tools/edit-file.go
/project/internal/tools/forgejo.go
/project/internal/tools/grep_search.go
/project/internal/tools/list_files.go
/project/internal/tools/move_file.go
/project/internal/tools/read_file.go
/project/internal/tools/registry.go
/project/internal/tools/remove_file.go
/project/internal/tools/shell.go
/project/internal/tools/tools_test.go
/project/internal/tools/write_file.go
/project/internal/web
/project/internal/web/templates.go
/project/internal/web/web.go
/project/internal/web/web_test.go
/project/zoo.hcl.example

{"command": "cd /project && git log --oneline -5 && git status"}

98298f6 Merge pull request 'Fix excessive vertical space in job view blocks (#53)' (#55) from issue-53-greg into main
b75b64d Fix excessive vertical space in job view blocks
10c3dce Better Docker/git inter.
315f993 Add docker image build.
5717258 Merge pull request 'forgejo: repository allowlist with wildcard patterns' (#40) from issue-39-greg into main
On branch issue-59-greg
nothing to commit, working tree clean

{"end_line": 400, "path": "internal/agentrun/loop.go", "start_line": 1}

{"path":"internal/agentrun/loop.go","content":"package agentrun\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"io\"\n\n\t\"github.com/abrander/zoo/internal/llm\"\n\t\"github.com/abrander/zoo/internal/tools\"\n)\n\n// Hooks lets a caller observe a runLoop invocation live, as the model\n// streams and tool calls execute, in addition to the final []llm.Message\n// it returns. Any of these may be nil.\ntype Hooks struct {\n\t// OnReasoningDelta and OnContentDelta fire with just the newly\n\t// streamed text for the current turn, not the accumulated total.\n\tOnReasoningDelta func(delta string)\n\tOnContentDelta   func(delta string)\n\n\t// OnTurnEnd fires once per completed streamer round-trip, after the\n\t// model's message for that turn is fully received and before any of\n\t// its tool calls run.\n\tOnTurnEnd func()\n\n\t// OnTool fires once per tool call, after it has run.\n\tOnTool func(name, arguments, result string, toolErr bool)\n}\n\n// runLoop is a headless port of ../a's App.generate(): send messages +\n// tool defs, get a completion, run any tool_calls and append their\n// results, repeat until a plain finish or ctx is done.\nfunc runLoop(ctx context.Context, client *llm.Client, toolsCtx tools.Context, messages []llm.Message, hooks Hooks) ([]llm.Message, error) {\n\tfor {\n\t\tif err := ctx.Err(); err != nil {\n\t\t\treturn messages, err\n\t\t}\n\n\t\tstreamer, err := client.StreamChatCompletion(ctx, \u0026llm.ChatCompletionRequest{\n\t\t\tMessages: messages,\n\t\t\tStream:   true,\n\t\t\tTools:    tools.All(),\n\t\t})\n\t\tif err != nil {\n\t\t\treturn messages, fmt.Errorf(\"chat completion: %w\", err)\n\t\t}\n\n\t\tvar completion *llm.ChatCompletion\n\n\t\tvar prevContent, prevReasoning string\n\n\t\tfor {\n\t\t\tc, err := streamer.Get()\n\t\t\tif err == io.EOF {\n\t\t\t\tbreak\n\t\t\t}\n\n\t\t\tif err != nil {\n\t\t\t\treturn messages, fmt.Errorf(\"stream completion: %w\", err)\n\t\t\t}\n\n\t\t\tcompletion = c\n\n\t\t\tif len(c.Choices) \u003e 0 {\n\t\t\t\tmsg := c.Choices[0].Message\n\n\t\t\t\tif hooks.OnReasoningDelta != nil \u0026\u0026 len(msg.ReasoningContent) \u003e len(prevReasoning) {\n\t\t\t\t\thooks.OnReasoningDelta(msg.ReasoningContent[len(prevReasoning):])\n\t\t\t\t}\n\t\t\t\tprevReasoning = msg.ReasoningContent\n\n\t\t\t\tif hooks.OnContentDelta != nil \u0026\u0026 len(msg.Content) \u003e len(prevContent) {\n\t\t\t\t\thooks.OnContentDelta(msg.Content[len(prevContent):])\n\t\t\t\t}\n\t\t\t\tprevContent = msg.Content\n\t\t\t}\n\t\t}\n\n\t\tif hooks.OnTurnEnd != nil {\n\t\t\thooks.OnTurnEnd()\n\t\t}\n\n\t\tif completion == nil || len(completion.Choices) == 0 {\n\t\t\treturn messages, fmt.Errorf(\"model returned an empty completion\")\n\t\t}\n\n\t\tchoice := completion.Choices[0]\n\t\tmessages = append(messages, choice.Message)\n\n\t\tif choice.FinishReason != \"tool_calls\" || len(choice.Message.ToolCalls) == 0 {\n\t\t\treturn messages, nil\n\t\t}\n\n\t\tfor _, tc := range choice.Message.ToolCalls {\n\t\t\tif err := ctx.Err(); err != nil {\n\t\t\t\treturn messages, err\n\t\t\t}\n\n\t\t\tresult, err := tools.Call(toolsCtx, tc.FunctionCall)\n\n\t\t\ttoolErr := err != nil\n\t\t\tif toolErr {\n\t\t\t\tresult = fmt.Sprintf(\"ERROR CALLING TOOL: %s\", err.Error())\n\t\t\t}\n\n\t\t\tif hooks.OnTool != nil {\n\t\t\t\thooks.OnTool(tc.FunctionCall.Name, tc.FunctionCall.Arguments, result, toolErr)\n\t\t\t}\n\n\t\t\tmessages = append(messages, llm.Message{\n\t\t\t\tRole:       \"tool\",\n\t\t\t\tContent:    result,\n\t\t\t\tToolCallID: tc.Id,\n\t\t\t\tName:       tc.FunctionCall.Name,\n\t\t\t})\n\t\t}\n\t}\n}","start_line":1,"end_line":118,"total_lines":118,"truncated":false}

{"end_line": 200, "path": "internal/llm/client.go", "start_line": 1}

{"path":"internal/llm/client.go","content":"package llm\n\nimport (\n\t\"bytes\"\n\t\"context\"\n\t\"encoding/json\"\n\t\"net/http\"\n\n\t\"github.com/abrander/zoo/internal/config\"\n)\n\ntype Client struct {\n\tendpoint string\n\ttoken    string\n\tmodel    string\n\n\thttpClient *http.Client\n}\n\n// NewClient builds a Client from a configured llm block.\nfunc NewClient(cfg config.LLM) *Client {\n\treturn \u0026Client{\n\t\tendpoint:   cfg.OpenAI,\n\t\ttoken:      cfg.Token,\n\t\tmodel:      cfg.Model,\n\t\thttpClient: http.DefaultClient,\n\t}\n}\n\nfunc (c *Client) StreamChatCompletion(ctx context.Context, req *ChatCompletionRequest) (*Streamer, error) {\n\treq2 := *req\n\n\tif req2.Model == \"\" {\n\t\treq2.Model = c.model\n\t}\n\n\treq2.Stream = true\n\treq2.Seed = 5\n\treq2.Temperature = 0.6\n\treq2.TopP = 0.95\n\n\tbody, err := json.Marshal(req2)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\t// Bound to ctx so a stalled connection or silent server (headers or\n\t// stream body never arriving) is unblocked by the run's deadline\n\t// instead of hanging the goroutine forever — http.DefaultClient has\n\t// no timeout of its own.\n\tr, err := http.NewRequestWithContext(ctx, http.MethodPost, c.endpoint+\"/chat/completions\", bytes.NewBuffer(body))\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tr.Header.Set(\"Authorization\", \"Bearer \"+c.token)\n\tr.Header.Set(\"Content-Type\", \"application/json\")\n\n\tresp, err := c.httpClient.Do(r)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\treturn NewStreamer(resp)\n}","start_line":1,"end_line":65,"total_lines":65,"truncated":false}

{"end_line": 200, "path": "internal/llm/streamer.go", "start_line": 1}

{"path":"internal/llm/streamer.go","content":"package llm\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"io\"\n\t\"net/http\"\n)\n\ntype Streamer struct {\n\tcompletion ChatCompletion\n\tresp       *http.Response\n\tscanner    *bufio.Scanner\n\teof        bool\n}\n\nfunc NewStreamer(resp *http.Response) (*Streamer, error) {\n\tif resp.StatusCode != http.StatusOK {\n\t\tbody, _ := io.ReadAll(resp.Body)\n\t\tresp.Body.Close()\n\t\treturn nil, fmt.Errorf(\"status: %d: %s\", resp.StatusCode, body)\n\t}\n\n\treturn \u0026Streamer{\n\t\tresp:    resp,\n\t\tscanner: bufio.NewScanner(resp.Body),\n\t}, nil\n}\n\n// Get returns the accumulated completion after merging in the next SSE\n// chunk. Callers should keep calling Get until it returns io.EOF.\nfunc (s *Streamer) Get() (*ChatCompletion, error) {\n\tif s.eof {\n\t\treturn nil, io.EOF\n\t}\n\n\tprefix := []byte(\"data: \")\n\n\tvar buf []byte\n\n\tfor s.scanner.Scan() {\n\t\tif err := s.scanner.Err(); err != nil {\n\t\t\treturn nil, err\n\t\t}\n\n\t\tbuf = bytes.TrimSpace(s.scanner.Bytes())\n\n\t\tif len(buf) == 0 {\n\t\t\tcontinue\n\t\t}\n\n\t\tif bytes.HasPrefix(buf, prefix) {\n\t\t\tbreak\n\t\t}\n\t}\n\n\tbuf = bytes.TrimPrefix(buf, prefix)\n\n\tif bytes.Equal(buf, []byte(\"[DONE]\")) {\n\t\ts.resp.Body.Close()\n\t\ts.eof = true\n\t\treturn nil, io.EOF\n\t}\n\n\tvar completion ChatCompletion\n\n\t// Unknown fields are tolerated on purpose: servers (e.g. newer\n\t// llama.cpp builds) may add fields we don't know about yet, and\n\t// failing on them would break compatibility.\n\tif err := json.Unmarshal(buf, \u0026completion); err != nil {\n\t\treturn nil, fmt.Errorf(\"decode completion chunk: %w: %s\", err, buf)\n\t}\n\n\ts.completion.Merge(\u0026completion)\n\n\treturn \u0026s.completion, nil\n}","start_line":1,"end_line":79,"total_lines":79,"truncated":false}

{"end_line": 250, "path": "internal/agentrun/run.go", "start_line": 1}

{"path":"internal/agentrun/run.go","content":"// Package agentrun creates the throwaway per-job environment an agent\n// runs in: a Docker container with the agent's git working tree cloned\n// inside it (authenticated with the agent's own Forgejo token), the\n// triggering event written to /event, and the tool-calling loop\n// (internal/llm + internal/tools) driven against it.\npackage agentrun\n\nimport (\n\t\"context\"\n\t_ \"embed\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"log/slog\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"strings\"\n\t\"sync\"\n\t\"time\"\n\n\t\"github.com/abrander/zoo/internal/config\"\n\t\"github.com/abrander/zoo/internal/forgejo\"\n\t\"github.com/abrander/zoo/internal/livelog\"\n\t\"github.com/abrander/zoo/internal/llm\"\n\t\"github.com/abrander/zoo/internal/store\"\n)\n\n//go:embed system.md\nvar defaultSystemPrompt string\n\n// DefaultTimeout bounds a single agent run's wall-clock time if the\n// caller doesn't override it.\nconst DefaultTimeout = 120 * time.Minute\n\ntype Runner struct {\n\tdocker        *dockerRuntime\n\tforgejo       *forgejo.Client\n\tstore         *store.Store\n\thub           *livelog.Hub\n\tcfg           *config.Config\n\tlogger        *slog.Logger\n\ttimeout       time.Duration\n\tkeepOnFailure bool\n\n\tagentClientsMu sync.Mutex\n\tagentClients   map[string]*forgejo.Client\n}\n\nfunc NewRunner(cfg *config.Config, fg *forgejo.Client, st *store.Store, hub *livelog.Hub, logger *slog.Logger, timeout time.Duration, keepOnFailure bool) (*Runner, error) {\n\tdocker, err := newDockerRuntime()\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tif timeout \u003c= 0 {\n\t\ttimeout = DefaultTimeout\n\t}\n\n\treturn \u0026Runner{\n\t\tdocker:        docker,\n\t\tforgejo:       fg,\n\t\tstore:         st,\n\t\thub:           hub,\n\t\tcfg:           cfg,\n\t\tlogger:        logger,\n\t\ttimeout:       timeout,\n\t\tkeepOnFailure: keepOnFailure,\n\t\tagentClients:  make(map[string]*forgejo.Client),\n\t}, nil\n}\n\n// forgejoAs returns a Forgejo client that authenticates as the given\n// agent (using the agent's own token from config). This lets each agent\n// act as themselves on Forgejo without needing a global token with sudo\n// privileges. Clients are built once per agent and cached, since\n// constructing one costs an extra API round trip.\n//\n// If the agent has no token configured, falls back to the shared zoo\n// identity so existing deployments without per-agent tokens still work.\nfunc (r *Runner) forgejoAs(agentName, token string) *forgejo.Client {\n\tr.agentClientsMu.Lock()\n\tdefer r.agentClientsMu.Unlock()\n\n\tif c, ok := r.agentClients[agentName]; ok {\n\t\treturn c\n\t}\n\n\tvar c *forgejo.Client\n\tif token != \"\" {\n\t\tc = r.forgejo.As(token)\n\t} else {\n\t\t// Fallback: use shared identity. Optionally log a warning\n\t\t// if we ever want to enforce per-agent tokens.\n\t\tc = r.forgejo\n\t}\n\n\tr.agentClients[agentName] = c\n\n\treturn c\n}\n\n// Run implements scheduler.Runner.\nfunc (r *Runner) Run(ctx context.Context, jobID string, agent config.AgentConfig, llmCfg config.LLM, dockerImage string, ev forgejo.Event) error {\n\tctx, cancel := context.WithTimeout(ctx, r.timeout)\n\tdefer cancel()\n\n\tlogger := r.logger.With(\"job\", jobID, \"agent\", agent.Name)\n\n\trepoInfo, err := r.forgejo.RepositoryInfo(ev.Owner, ev.Repo)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"look up repository: %w\", err)\n\t}\n\n\tworkDir, err := os.MkdirTemp(\"\", \"zoo-run-*\")\n\tif err != nil {\n\t\treturn fmt.Errorf(\"create work dir: %w\", err)\n\t}\n\n\tsucceeded := false\n\n\tdefer func() {\n\t\tif succeeded || !r.keepOnFailure {\n\t\t\tos.RemoveAll(workDir)\n\t\t} else {\n\t\t\tlogger.Warn(\"keeping work dir after failure\", \"dir\", workDir)\n\t\t}\n\t}()\n\n\t// The container bind-mounts projectDir as /project and does the\n\t// initial clone into it, so the (empty) directory must exist on the\n\t// host before the container is created — otherwise Docker would\n\t// create it itself, root-owned.\n\tprojectDir := filepath.Join(workDir, \"project\")\n\n\tif err := os.MkdirAll(projectDir, 0o755); err != nil {\n\t\treturn fmt.Errorf(\"create project dir: %w\", err)\n\t}\n\n\t// A pr:review run works on the PR's own head branch, so the agent's\n\t// commits push straight to the PR. Every other event kind branches\n\t// off the default branch as usual.\n\tvar review *forgejo.ReviewDetail\n\tbranch := fmt.Sprintf(\"issue-%d-%s\", ev.Index, agent.Name)\n\n\tif ev.Kind == forgejo.EventPRReview {\n\t\t// Always fetch the current head ref, not just when the event\n\t\t// lacks one (the polling path doesn't carry it): the webhook's\n\t\t// copy could be stale if the PR's head branch was renamed since\n\t\t// the review, and the push target depends on it.\n\t\theadRef := ev.HeadRef\n\n\t\tif prInfo, err := r.forgejo.PullRequestInfo(ev.Owner, ev.Repo, ev.Index); err != nil {\n\t\t\tlogger.Warn(\"fetch pull request head failed; falling back to the event's head ref\", \"error\", err)\n\t\t} else if prInfo.HeadRef != \"\" {\n\t\t\theadRef = prInfo.HeadRef\n\t\t}\n\n\t\tif headRef == \"\" {\n\t\t\treturn fmt.Errorf(\"pr:review event has no pull request head branch to check out\")\n\t\t}\n\n\t\tbranch = headRef\n\n\t\t// Fetch the full review (verdict, body, inline comments) so the\n\t\t// agent sees all the feedback, not just the triggering event. A\n\t\t// failure degrades to no review detail rather than failing the\n\t\t// run: the agent can still do its job, just without the inline\n\t\t// comments.\n\t\treview, err = r.forgejo.ReviewDetail(ev.Owner, ev.Repo, ev.Index, ev.ReviewID)\n\t\tif err != nil {\n\t\t\tlogger.Warn(\"fetch review detail failed; agent will not see inline review comments\", \"error\", err)\n\t\t\treview = nil\n\t\t}\n\t}\n\n\troster := buildRoster(r.forgejo, r.cfg.Agents, logger)\n\tgitName, gitEmail := gitIdentity(agent.Name, roster)\n\n\t// The credential the sandbox's git uses for remote operations: the\n\t// agent's own Forgejo token when configured, so its git activity is\n\t// attributed to its own account, falling back to the shared zoo\n\t// identity for deployments without per-agent tokens (mirroring\n\t// forgejoAs).\n\tgitUser, gitToken := \"zoo\", r.forgejo.Token()\n\n\tif agent.Token != \"\" {\n\t\tgitUser, gitToken = agent.Name, agent.Token\n\t}\n\n\teventPath := filepath.Join(workDir, \"event.json\")\n\tif err := os.WriteFile(eventPath, ev.Raw, 0o644); err != nil {\n\t\treturn fmt.Errorf(\"write event file: %w\", err)\n\t}\n\n\tcontainerID, err := r.docker.createContainer(ctx, dockerImage, []string{\n\t\tprojectDir + \":/project\",\n\t\teventPath + \":/event:ro\",\n\t}, fmt.Sprintf(\"zoo-issue-%d-%s\", ev.Index, agent.Name))\n\tif err != nil {\n\t\treturn fmt.Errorf(\"start container: %w\", err)\n\t}\n\n\tdefer func() {\n\t\tcleanupCtx, cleanupCancel := context.WithTimeout(context.Background(), 30*time.Second)\n\t\tdefer cleanupCancel()\n\t\tif err := r.docker.remove(cleanupCtx, containerID); err != nil {\n\t\t\tlogger.Warn(\"failed to remove container\", \"container\", containerID, \"error\", err)\n\t\t}\n\t}()\n\n\t// Git must simply work inside the sandbox: safe.directory, commit\n\t// identity, and the remote credential all go into the container's\n\t// system gitconfig (see configureSandboxGit).\n\tif err := configureSandboxGit(ctx, r.docker, containerID, repoInfo.CloneURL, gitUser, gitToken, gitName, gitEmail); err != nil {\n\t\treturn fmt.Errorf(\"configure git in container: %w\", err)\n\t}\n\n\t// The initial clone happens inside the sandbox, so the working tree\n\t// is owned by the container's user and git never runs on the host.\n\tif ev.Kind == forgejo.EventPRReview {\n\t\tif err := clonePRHead(ctx, r.docker, containerID, repoInfo.CloneURL, repoInfo.DefaultBranch, branch, ev.Index); err != nil {\n\t\t\treturn fmt.Errorf(\"prepare git working tree: %w\", err)\n\t\t}\n\t} else {\n\t\tif err := cloneAndBranch(ctx, r.docker, containerID, repoInfo.CloneURL, repoInfo.DefaultBranch, branch); err != nil {\n\t\t\treturn fmt.Errorf(\"prepare git working tree: %w\", err)\n\t\t}\n\t}\n\n\tlogAppend := func(stream, line string) {\n\t\tif err := r.store.AppendLog(context.Background(), jobID, stream, line); err != nil {\n\t\t\tlogger.Warn(\"failed to append log\", \"error\", err)\n\t\t}\n\t}\n\n\trunCtx := \u0026runContext{\n\t\tdocker:      r.docker,\n\t\tcontainerID: containerID,\n\t\tforgejo: \u0026runForgejoActions{\n\t\t\tclient: r.forgejoAs(agent.Name, agent.Token),\n\t\t\towner:  ev.Owner,\n\t\t\trepo:   ev.Repo,\n\t\t\tindex:  ev.Index,\n\t\t\tlogger: logger,\n\t\t},\n\t}\n\n\tllmClient := llm.NewClient(llmCfg)\n\n\tsystemPrompt := defaultSystemPrompt + identitySection(agent.Name, roster)\n","start_line":1,"end_line":250,"total_lines":437,"truncated":true}

{"end_line": 437, "path": "internal/agentrun/run.go", "start_line": 250}

{"path":"internal/agentrun/run.go","content":"\n\tinstructions := r.cfg.EventInstructions(ev.Kind)\n\n\t// Fetch the full comment thread so the agent sees everything that's\n\t// been said on the issue/PR, not just the triggering event (which\n\t// only carries the latest comment, if any). A failure degrades to\n\t// no comments rather than failing the run: the agent can still do\n\t// its job, just without prior context.\n\tcomments, err := r.forgejo.ListIssueComments(ev.Owner, ev.Repo, ev.Index)\n\tif err != nil {\n\t\tlogger.Warn(\"fetch issue comments failed; agent will not see prior comments\", \"error\", err)\n\t\tcomments = nil\n\t}\n\n\tmessages := []llm.Message{\n\t\t{Role: \"system\", Content: systemPrompt},\n\t\t{Role: \"user\", Content: seedMessage(ev, branch, repoInfo.DefaultBranch, instructions, comments, review)},\n\t}\n\n\thooks := r.streamHooks(jobID, logAppend)\n\n\t_, err = runLoop(ctx, llmClient, runCtx, messages, hooks)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"agent loop: %w\", err)\n\t}\n\n\tsucceeded = true\n\n\treturn nil\n}\n\n// streamHooks builds the Hooks a single Run passes to runLoop: every\n// delta is published live to the hub for connected dashboard viewers,\n// and once a reasoning/content block or tool call is complete, it's\n// persisted to the store as one row and the hub's replay buffer for\n// jobID is checkpointed — so a viewer connecting from this point on\n// sees it via the persisted history instead of a live replay, and is\n// never shown it twice.\nfunc (r *Runner) streamHooks(jobID string, logAppend func(stream, line string)) Hooks {\n\tvar reasoningBuf, contentBuf strings.Builder\n\n\treasoningOpen, contentOpen := false, false\n\n\treturn Hooks{\n\t\tOnReasoningDelta: func(delta string) {\n\t\t\tif !reasoningOpen {\n\t\t\t\treasoningOpen = true\n\t\t\t\treasoningBuf.Reset()\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningStart})\n\t\t\t}\n\n\t\t\treasoningBuf.WriteString(delta)\n\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningDelta, Text: delta})\n\t\t},\n\t\tOnContentDelta: func(delta string) {\n\t\t\tif !contentOpen {\n\t\t\t\tcontentOpen = true\n\t\t\t\tcontentBuf.Reset()\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ContentStart})\n\t\t\t}\n\n\t\t\tcontentBuf.WriteString(delta)\n\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ContentDelta, Text: delta})\n\t\t},\n\t\tOnTurnEnd: func() {\n\t\t\tif reasoningOpen {\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningEnd})\n\t\t\t\tlogAppend(\"reasoning\", reasoningBuf.String())\n\t\t\t\tr.hub.Checkpoint(jobID)\n\t\t\t\treasoningOpen = false\n\t\t\t}\n\n\t\t\tif contentOpen {\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ContentEnd})\n\t\t\t\tlogAppend(\"content\", contentBuf.String())\n\t\t\t\tr.hub.Checkpoint(jobID)\n\t\t\t\tcontentOpen = false\n\t\t\t}\n\t\t},\n\t\tOnTool: func(name, arguments, result string, toolErr bool) {\n\t\t\tr.hub.Publish(jobID, livelog.Event{\n\t\t\t\tType:      livelog.Tool,\n\t\t\t\tName:      name,\n\t\t\t\tArguments: arguments,\n\t\t\t\tResult:    result,\n\t\t\t\tError:     toolErr,\n\t\t\t})\n\n\t\t\tline, err := json.Marshal(store.ToolLogEntry{Name: name, Arguments: arguments, Result: result, Error: toolErr})\n\t\t\tif err != nil {\n\t\t\t\tr.logger.Warn(\"failed to marshal tool log entry\", \"job\", jobID, \"error\", err)\n\t\t\t} else {\n\t\t\t\tlogAppend(\"tool\", string(line))\n\t\t\t}\n\n\t\t\tr.hub.Checkpoint(jobID)\n\t\t},\n\t}\n}\n\nfunc seedMessage(ev forgejo.Event, branch, defaultBranch, instructions string, comments []forgejo.IssueComment, review *forgejo.ReviewDetail) string {\n\traw, _ := json.MarshalIndent(json.RawMessage(ev.Raw), \"\", \"  \")\n\n\tvar instructionsSection string\n\tif instructions != \"\" {\n\t\tinstructionsSection = fmt.Sprintf(\"Instructions for this event, from zoo.hcl:\\n%s\\n\\n\", instructions)\n\t}\n\n\t// A pr:review run works on the PR's own head branch, not a fresh\n\t// branch off the default branch.\n\tbranchLine := fmt.Sprintf(\"Your working branch is %q, checked out from the default branch %q.\\n\\n\", branch, defaultBranch)\n\tif ev.Kind == forgejo.EventPRReview {\n\t\tbranchLine = fmt.Sprintf(\"Your working branch is %q, the pull request's head branch — commits you push here update the pull request directly.\\n\\n\", branch)\n\t}\n\n\tvar reviewSection string\n\tif review != nil {\n\t\treviewSection = renderReviewSection(review)\n\t}\n\n\tvar commentsSection string\n\tif len(comments) \u003e 0 {\n\t\tvar b strings.Builder\n\t\tfmt.Fprintf(\u0026b, \"Comments (%d):\\n\\n\", len(comments))\n\n\t\tfor i, c := range comments {\n\t\t\tfmt.Fprintf(\u0026b, \"%d. %s (%s):\\n%s\\n\\n\", i+1, c.Author, c.Created.Format(time.RFC3339), c.Body)\n\t\t}\n\n\t\tcommentsSection = b.String()\n\t}\n\n\treturn fmt.Sprintf(\n\t\t\"You were triggered by a %q event on %s/%s.\\n\\n\"+\n\t\t\t\"%s%s\"+\n\t\t\t\"%sTitle: %s\\n\\nBody:\\n%s\\n\\n%sFull event payload:\\n```json\\n%s\\n```\",\n\t\tev.Kind, ev.Owner, ev.Repo, instructionsSection, branchLine, reviewSection, ev.Title, ev.Body, commentsSection, raw)\n}\n\n// renderReviewSection renders the submitted review as a briefing\n// section: the verdict, the review body, and each inline comment with\n// its location and id (the id lets the agent refer to a specific\n// comment in its reply).\nfunc renderReviewSection(review *forgejo.ReviewDetail) string {\n\tvar b strings.Builder\n\n\tfmt.Fprintf(\u0026b, \"Review submitted by %s:\\n\", review.Reviewer)\n\tfmt.Fprintf(\u0026b, \"  Verdict: %s\\n\", humanReviewState(review.State))\n\n\tif review.Body != \"\" {\n\t\tb.WriteString(\"  Review body:\\n\")\n\t\tfor _, line := range strings.Split(review.Body, \"\\n\") {\n\t\t\tfmt.Fprintf(\u0026b, \"  %s\\n\", line)\n\t\t}\n\t}\n\n\tif len(review.Comments) \u003e 0 {\n\t\tfmt.Fprintf(\u0026b, \"  Inline comments (%d):\\n\", len(review.Comments))\n\n\t\tfor i, c := range review.Comments {\n\t\t\twhere := c.Path\n\t\t\tif c.Line \u003e 0 {\n\t\t\t\twhere = fmt.Sprintf(\"%s:%d\", c.Path, c.Line)\n\t\t\t}\n\n\t\t\tfmt.Fprintf(\u0026b, \"  %d. [%s] %s (comment id %d):\\n\", i+1, where, c.Author, c.ID)\n\t\t\tfor _, line := range strings.Split(c.Body, \"\\n\") {\n\t\t\t\tfmt.Fprintf(\u0026b, \"     %s\\n\", line)\n\t\t\t}\n\t\t}\n\t}\n\n\treturn b.String() + \"\\n\"\n}\n\n// humanReviewState maps a Forgejo review state to a readable verdict.\nfunc humanReviewState(state string) string {\n\tswitch state {\n\tcase \"APPROVED\":\n\t\treturn \"approved\"\n\tcase \"REQUEST_CHANGES\":\n\t\treturn \"changes requested\"\n\tcase \"COMMENT\":\n\t\treturn \"comment\"\n\tdefault:\n\t\treturn state\n\t}\n}","start_line":250,"end_line":437,"total_lines":437,"truncated":false}

{"end_line": 200, "path": "internal/llm/types.go", "start_line": 1}

{"path":"internal/llm/types.go","content":"// Package llm is an OpenAI-compatible chat completions client with\n// streaming and tool-call support, ported from ../a's llamacpp package.\npackage llm\n\nimport \"fmt\"\n\ntype Message struct {\n\tContent          string     `json:\"content\"`\n\tRole             string     `json:\"role\"`\n\tReasoningContent string     `json:\"reasoning_content,omitempty\"`\n\tToolCalls        []ToolCall `json:\"tool_calls,omitempty\"`\n\tToolCallID       string     `json:\"tool_call_id,omitempty\"`\n\tName             string     `json:\"name,omitempty\"`\n}\n\nfunc (m *Message) String() string {\n\tstr := fmt.Sprintf(\"Role: %s, Content: %s ReasoningContent: %s\", m.Role, m.Content, m.ReasoningContent)\n\n\tfor _, call := range m.ToolCalls {\n\t\tstr += fmt.Sprintf(\"\\n  ToolCall: %s\", call.String())\n\t}\n\n\treturn str\n}\n\n// Merge folds a streamed delta into the accumulated message.\nfunc (m *Message) Merge(next *Message) {\n\tm.Content += next.Content\n\n\tif next.Role != \"\" {\n\t\tm.Role = next.Role\n\t}\n\n\tm.ReasoningContent += next.ReasoningContent\n\n\tminLength := 0\n\tfor _, choice := range next.ToolCalls {\n\t\tif choice.Index+1 \u003e minLength {\n\t\t\tminLength = choice.Index + 1\n\t\t}\n\t}\n\n\tif len(m.ToolCalls) \u003c minLength {\n\t\tnewToolCalls := make([]ToolCall, minLength)\n\t\tcopy(newToolCalls, m.ToolCalls)\n\t\tm.ToolCalls = newToolCalls\n\t}\n\n\tfor _, nextChoice := range next.ToolCalls {\n\t\tm.ToolCalls[nextChoice.Index].Merge(\u0026nextChoice)\n\t}\n}\n\ntype FunctionCall struct {\n\tName      string `json:\"name\"`\n\tArguments string `json:\"arguments\"`\n}\n\ntype ToolCall struct {\n\tType         string       `json:\"type\"`\n\tId           string       `json:\"id\"`\n\tIndex        int          `json:\"index\"`\n\tName         string       `json:\"name\"`\n\tFunctionCall FunctionCall `json:\"function\"`\n}\n\nfunc (t *ToolCall) String() string {\n\treturn fmt.Sprintf(\"Type: %s, Id: %s, Index: %d, Name: %s, FunctionCall: {Name: %s, Arguments: %s}\",\n\t\tt.Type, t.Id, t.Index, t.Name, t.FunctionCall.Name, t.FunctionCall.Arguments)\n}\n\nfunc (t *ToolCall) Merge(next *ToolCall) {\n\tif next.Type != \"\" {\n\t\tt.Type = next.Type\n\t}\n\n\tif next.Id != \"\" {\n\t\tt.Id = next.Id\n\t}\n\n\tif next.Name != \"\" {\n\t\tt.Name = next.Name\n\t}\n\n\tt.Index = next.Index\n\n\tif next.FunctionCall.Name != \"\" {\n\t\tt.FunctionCall.Name = next.FunctionCall.Name\n\t}\n\n\tt.FunctionCall.Arguments += next.FunctionCall.Arguments\n}\n\ntype Property struct {\n\tType        string    `json:\"type\"`\n\tDescription string    `json:\"description,omitempty\"`\n\tEnum        []string  `json:\"enum,omitempty\"`\n\tItems       *Property `json:\"items,omitempty\"`\n}\n\ntype Parameters struct {\n\tType       string              `json:\"type\"` // object\n\tProperties map[string]Property `json:\"properties,omitempty\"`\n\tRequired   []string            `json:\"required,omitempty\"`\n}\n\ntype Function struct {\n\tName        string     `json:\"name\"`\n\tDescription string     `json:\"description,omitempty\"`\n\tParameters  Parameters `json:\"parameters,omitempty\"`\n\tStrict      bool       `json:\"strict\"`\n}\n\ntype Tool struct {\n\tType     string   `json:\"type\"`\n\tFunction Function `json:\"function\"`\n}\n\nfunc NewTool(name, description string) Tool {\n\treturn Tool{\n\t\tType: \"function\",\n\t\tFunction: Function{\n\t\t\tName:        name,\n\t\t\tDescription: description,\n\t\t\tStrict:      true,\n\t\t},\n\t}\n}\n\nfunc (t *Tool) AddProperty(name string, property Property, required bool) *Tool {\n\tif t.Function.Parameters.Properties == nil {\n\t\tt.Function.Parameters.Properties = make(map[string]Property)\n\t} else if _, exists := t.Function.Parameters.Properties[name]; exists {\n\t\tpanic(\"property already exists: \" + name)\n\t}\n\n\tt.Function.Parameters.Properties[name] = property\n\n\tif required {\n\t\tt.Function.Parameters.Required = append(t.Function.Parameters.Required, name)\n\t}\n\n\treturn t\n}\n\nfunc (t *Tool) AddStringProperty(name, description string, required bool) *Tool {\n\treturn t.AddProperty(name, Property{Type: \"string\", Description: description}, required)\n}\n\nfunc (t *Tool) AddBooleanProperty(name, description string, required bool) *Tool {\n\treturn t.AddProperty(name, Property{Type: \"boolean\", Description: description}, required)\n}\n\nfunc (t *Tool) AddIntegerProperty(name, description string, required bool) *Tool {\n\treturn t.AddProperty(name, Property{Type: \"integer\", Description: description}, required)\n}\n\nfunc (t *Tool) AddEnumProperty(name, description string, values []string, required bool) *Tool {\n\treturn t.AddProperty(name, Property{Type: \"string\", Description: description, Enum: values}, required)\n}\n\nfunc (t *Tool) AddArrayProperty(name, itemType, description string, required bool) *Tool {\n\treturn t.AddProperty(name, Property{\n\t\tType:        \"array\",\n\t\tDescription: description,\n\t\tItems:       \u0026Property{Type: itemType},\n\t}, required)\n}\n\nfunc (t *Tool) AddStringArrayProperty(name, description string, required bool) *Tool {\n\treturn t.AddArrayProperty(name, \"string\", description, required)\n}\n\ntype ChatCompletionRequest struct {\n\tModel       string    `json:\"model\"`\n\tMessages    []Message `json:\"messages,omitempty\"`\n\tStream      bool      `json:\"stream\"`\n\tTools       []Tool    `json:\"tools,omitempty\"`\n\tSeed        int       `json:\"seed,omitempty\"`\n\tTemperature float64   `json:\"temperature,omitempty\"`\n\tTopP        float64   `json:\"top_p,omitempty\"`\n}\n\ntype Choice struct {\n\tDelta        Message `json:\"delta\"`\n\tFinishReason string  `json:\"finish_reason,omitempty\"`\n\tIndex        int     `json:\"index\"`\n\tMessage      Message `json:\"message\"`\n\tRole         string  `json:\"role\"`\n}\n\nfunc (c *Choice) String() string {\n\treturn fmt.Sprintf(\"Index: %d, Role: %s, FinishReason: %v, Delta: %s, Message: %s\",\n\t\tc.Index, c.Role, c.FinishReason, c.Delta.String(), c.Message.String())\n}\n\nfunc (c *Choice) Merge(next *Choice) {\n\tc.Message.Merge(\u0026next.Delta)\n\n\tif next.FinishReason != \"\" {","start_line":1,"end_line":200,"total_lines":267,"truncated":true}

{"end_line": 200, "path": "internal/config/config.go", "start_line": 1}

{"path":"internal/config/config.go","content":"// Package config loads and validates zoo's HCL configuration file.\npackage config\n\nimport (\n\t\"fmt\"\n\t\"strings\"\n\n\t\"github.com/hashicorp/hcl/v2/hclsimple\"\n)\n\n// Known event kinds. issue:assigned and pr:review are resolved\n// dynamically (agent name must match the Forgejo assignee's username,\n// or the pull request author's username, respectively) so they never\n// carry an `agent` attribute; the rest map statically to one\n// configured agent.\nconst (\n\tEventIssueNew      = \"issue:new\"\n\tEventIssueComment  = \"issue:comment\"\n\tEventIssueAssigned = \"issue:assigned\"\n\tEventPRNew         = \"pr:new\"\n\tEventPRReview      = \"pr:review\"\n)\n\nvar staticEventKinds = map[string]bool{\n\tEventIssueNew:     true,\n\tEventIssueComment: true,\n\tEventPRNew:        true,\n}\n\ntype Config struct {\n\tLLMs        []LLM       `hcl:\"llm,block\"`\n\tForgejo     Forgejo     `hcl:\"forgejo,block\"`\n\tEnvironment Environment `hcl:\"environment,block\"`\n\tAgents      []Agent     `hcl:\"agent,block\"`\n\tEvents      []Event     `hcl:\"event,block\"`\n\tWeb         *Web        `hcl:\"web,block\"`\n}\n\n// Web configures the dashboard's optional bearer-token gate. Leave the\n// block out of zoo.hcl entirely to run without one (fine on localhost;\n// put a real gate or a proxy in front for anything else).\ntype Web struct {\n\tToken string `hcl:\"token,optional\"`\n}\n\ntype LLM struct {\n\tName   string `hcl:\"name,label\"`\n\tOpenAI string `hcl:\"openai\"`\n\tToken  string `hcl:\"token\"`\n\tModel  string `hcl:\"model\"`\n}\n\ntype Forgejo struct {\n\tURL           string `hcl:\"url\"`\n\tToken         string `hcl:\"token\"`\n\tWebhookSecret string `hcl:\"webhook_secret,optional\"`\n\n\t// Repos is the allowlist of repository patterns to watch, e.g.\n\t// [\"acme/*\", \"acme/widgets\"]. Patterns are \"owner/repo\" pairs with\n\t// glob wildcards; \"*\" watches everything on the instance. An empty\n\t// list keeps the historical behavior of watching every repository\n\t// the token can see.\n\tRepos []string `hcl:\"repos,optional\"`\n}\n\ntype Environment struct {\n\tDockerImage string `hcl:\"docker_image\"`\n\tMaxLive     int    `hcl:\"max_live_agents\"`\n}\n\ntype Agent struct {\n\tName  string `hcl:\"name,label\"`\n\tLLM   string `hcl:\"llm\"`\n\tToken string `hcl:\"token,optional\"`\n}\n\ntype Event struct {\n\tKind         string `hcl:\"name,label\"`\n\tAgent        string `hcl:\"agent,optional\"`\n\tInstructions string `hcl:\"instructions,optional\"`\n}\n\n// Load reads and validates the config file at path.\nfunc Load(path string) (*Config, error) {\n\tvar cfg Config\n\n\tif err := hclsimple.DecodeFile(path, nil, \u0026cfg); err != nil {\n\t\treturn nil, fmt.Errorf(\"parse config: %w\", err)\n\t}\n\n\tif err := cfg.Validate(); err != nil {\n\t\treturn nil, fmt.Errorf(\"invalid config: %w\", err)\n\t}\n\n\treturn \u0026cfg, nil\n}\n\n// Validate checks that the config is internally consistent: every\n// reference between blocks resolves, and required values are set.\nfunc (c *Config) Validate() error {\n\tllmNames := make(map[string]bool, len(c.LLMs))\n\tfor _, l := range c.LLMs {\n\t\tif l.OpenAI == \"\" || l.Token == \"\" || l.Model == \"\" {\n\t\t\treturn fmt.Errorf(\"llm %q: openai, token, and model are required\", l.Name)\n\t\t}\n\t\tllmNames[l.Name] = true\n\t}\n\n\tif c.Forgejo.URL == \"\" || c.Forgejo.Token == \"\" {\n\t\treturn fmt.Errorf(\"forgejo: url and token are required\")\n\t}\n\n\tfor _, p := range c.Forgejo.Repos {\n\t\tif err := validRepoPattern(p); err != nil {\n\t\t\treturn fmt.Errorf(\"forgejo: %w\", err)\n\t\t}\n\t}\n\n\tif c.Environment.MaxLive \u003c 1 {\n\t\treturn fmt.Errorf(\"environment: max_live_agents must be \u003e= 1, got %d\", c.Environment.MaxLive)\n\t}\n\n\tif c.Environment.DockerImage == \"\" {\n\t\treturn fmt.Errorf(\"environment: docker_image is required\")\n\t}\n\n\tagentNames := make(map[string]bool, len(c.Agents))\n\tfor _, a := range c.Agents {\n\t\tif !llmNames[a.LLM] {\n\t\t\treturn fmt.Errorf(\"agent %q: references undeclared llm %q\", a.Name, a.LLM)\n\t\t}\n\t\tagentNames[a.Name] = true\n\t}\n\n\tseenEventKinds := make(map[string]bool, len(c.Events))\n\tfor _, e := range c.Events {\n\t\tif seenEventKinds[e.Kind] {\n\t\t\treturn fmt.Errorf(\"event %q: declared more than once\", e.Kind)\n\t\t}\n\t\tseenEventKinds[e.Kind] = true\n\n\t\tswitch {\n\t\tcase e.Kind == EventIssueAssigned:\n\t\t\tif e.Agent != \"\" {\n\t\t\t\treturn fmt.Errorf(\"event %q: must not set agent; the agent whose name matches the Forgejo assignee's username is triggered dynamically\", e.Kind)\n\t\t\t}\n\n\t\tcase e.Kind == EventPRReview:\n\t\t\tif e.Agent != \"\" {\n\t\t\t\treturn fmt.Errorf(\"event %q: must not set agent; the agent whose name matches the pull request author's username is triggered dynamically\", e.Kind)\n\t\t\t}\n\n\t\tcase staticEventKinds[e.Kind]:\n\t\t\tif e.Agent == \"\" {\n\t\t\t\treturn fmt.Errorf(\"event %q: agent is required\", e.Kind)\n\t\t\t}\n\t\t\tif !agentNames[e.Agent] {\n\t\t\t\treturn fmt.Errorf(\"event %q: references undeclared agent %q\", e.Kind, e.Agent)\n\t\t\t}\n\n\t\tdefault:\n\t\t\treturn fmt.Errorf(\"event %q: unknown event kind\", e.Kind)\n\t\t}\n\t}\n\n\treturn nil\n}\n\n// validRepoPattern checks the shape of a forgejo `repos` entry. It must\n// be a non-empty \"owner/repo\" pair (or a bare owner name, or \"*\") — at\n// most one slash, none at either end. Glob syntax within the segments\n// is validated later by forgejo.NewRepoFilter.\nfunc validRepoPattern(p string) error {\n\tif p == \"\" {\n\t\treturn fmt.Errorf(\"repos: pattern must not be empty\")\n\t}\n\n\tif strings.Count(p, \"/\") \u003e 1 {\n\t\treturn fmt.Errorf(\"repos: pattern %q must be \\\"owner/repo\\\" (at most one \\\"/\\\")\", p)\n\t}\n\n\tif strings.HasPrefix(p, \"/\") || strings.HasSuffix(p, \"/\") {\n\t\treturn fmt.Errorf(\"repos: pattern %q must not start or end with \\\"/\\\"\", p)\n\t}\n\n\treturn nil\n}\n\n// AgentConfig holds an agent's full configuration including its\n// Forgejo token (if configured).\ntype AgentConfig struct {\n\tName  string\n\tLLM   string\n\tToken string\n}\n\n// AgentByName returns the agent config with the given name, if declared.\nfunc (c *Config) AgentByName(name string) (AgentConfig, bool) {\n\tfor _, a := range c.Agents {\n\t\tif a.Name == name {","start_line":1,"end_line":200,"total_lines":246,"truncated":true}

{"end_line": 267, "path": "internal/llm/types.go", "start_line": 200}

{"path":"internal/llm/types.go","content":"\tif next.FinishReason != \"\" {\n\t\tc.FinishReason = next.FinishReason\n\t}\n\n\tif next.Role != \"\" {\n\t\tc.Role = next.Role\n\t}\n}\n\n// Timings mirrors llama.cpp's /chat/completions timing block. The\n// streamer tolerates unknown fields, so extra fields from the server\n// are simply ignored.\ntype Timings struct {\n\tCacheN              int     `json:\"cache_n\"`\n\tDraftN              int     `json:\"draft_n\"`\n\tDraftNAccepted      int     `json:\"draft_n_accepted\"`\n\tPromptN             int     `json:\"prompt_n\"`\n\tPromptMs            float64 `json:\"prompt_ms\"`\n\tPromptPerTokenMs    float64 `json:\"prompt_per_token_ms\"`\n\tPromptPerSecond     float64 `json:\"prompt_per_second\"`\n\tPredictedN          int     `json:\"predicted_n\"`\n\tPredictedMs         float64 `json:\"predicted_ms\"`\n\tPredictedPerTokenMs float64 `json:\"predicted_per_token_ms\"`\n\tPredictedPerSecond  float64 `json:\"predicted_per_second\"`\n}\n\ntype ChatCompletion struct {\n\tChoices           []Choice `json:\"choices\"`\n\tCreated           int64    `json:\"created\"`\n\tId                string   `json:\"id\"`\n\tModel             string   `json:\"model\"`\n\tSystemFingerprint string   `json:\"system_fingerprint\"`\n\tObject            string   `json:\"object\"`\n\tTimings           Timings  `json:\"timings\"`\n}\n\nfunc (c *ChatCompletion) String() string {\n\ts := fmt.Sprintf(\"Id: %s, Model: %s, Created: %d, SystemFingerprint: %s, Object: %s\\n\",\n\t\tc.Id, c.Model, c.Created, c.SystemFingerprint, c.Object)\n\n\tfor _, choice := range c.Choices {\n\t\ts += fmt.Sprintf(\"  Choice: %s\\n\", choice.String())\n\t}\n\n\treturn s\n}\n\n// Merge folds a streamed chunk into the accumulated completion.\nfunc (c *ChatCompletion) Merge(next *ChatCompletion) {\n\tminLength := 0\n\tfor _, choice := range next.Choices {\n\t\tif choice.Index+1 \u003e minLength {\n\t\t\tminLength = choice.Index + 1\n\t\t}\n\t}\n\n\tif len(c.Choices) \u003c minLength {\n\t\tnewChoices := make([]Choice, minLength)\n\t\tcopy(newChoices, c.Choices)\n\t\tc.Choices = newChoices\n\t}\n\n\tfor _, nextChoice := range next.Choices {\n\t\tc.Choices[nextChoice.Index].Merge(\u0026nextChoice)\n\t}\n\n\tc.Timings = next.Timings\n}","start_line":200,"end_line":267,"total_lines":267,"truncated":false}

{"end_line": 150, "path": "internal/livelog/hub.go", "start_line": 1}

{"path":"internal/livelog/hub.go","content":"// Package livelog is an in-memory pub/sub hub that lets agentrun publish\n// fine-grained, not-yet-persisted events (reasoning/content deltas, tool\n// calls) for a running job, and lets the web dashboard subscribe to them\n// live over SSE. It carries only the tail of a run that hasn't made it\n// into SQLite yet — see Hub.Checkpoint.\npackage livelog\n\nimport \"sync\"\n\ntype Type string\n\nconst (\n\tReasoningStart Type = \"reasoning_start\"\n\tReasoningDelta Type = \"reasoning_delta\"\n\tReasoningEnd   Type = \"reasoning_end\"\n\tContentStart   Type = \"content_start\"\n\tContentDelta   Type = \"content_delta\"\n\tContentEnd     Type = \"content_end\"\n\tTool           Type = \"tool\"\n\tStatus         Type = \"status\"\n)\n\ntype Event struct {\n\tType      Type   `json:\"type\"`\n\tText      string `json:\"text,omitempty\"`\n\tName      string `json:\"name,omitempty\"`\n\tArguments string `json:\"arguments,omitempty\"`\n\tResult    string `json:\"result,omitempty\"`\n\tError     bool   `json:\"error,omitempty\"`\n\tStatus    string `json:\"status,omitempty\"`\n}\n\n// subChanBuffer bounds how many events a slow subscriber can lag behind\n// by before new events are dropped for it. Generous for a single-user\n// local dashboard; a dropped event just means a subscriber's browser\n// tab misses a chunk and catches up on the next one, never a hang.\nconst subChanBuffer = 256\n\n// maxBufferedEvents caps the per-job replay buffer as a safety net\n// against unbounded growth if a caller forgets to Checkpoint. Ordinary\n// operation clears the buffer far below this on every persisted block.\nconst maxBufferedEvents = 10000\n\ntype stream struct {\n\tmu   sync.Mutex\n\tbuf  []Event\n\tsubs map[chan Event]struct{}\n}\n\n// Hub fans out per-job Events to any number of live subscribers.\ntype Hub struct {\n\tmu   sync.Mutex\n\tjobs map[string]*stream\n}\n\nfunc NewHub() *Hub {\n\treturn \u0026Hub{jobs: make(map[string]*stream)}\n}\n\nfunc (h *Hub) get(jobID string) *stream {\n\th.mu.Lock()\n\tdefer h.mu.Unlock()\n\n\ts, ok := h.jobs[jobID]\n\tif !ok {\n\t\ts = \u0026stream{subs: make(map[chan Event]struct{})}\n\t\th.jobs[jobID] = s\n\t}\n\n\treturn s\n}\n\n// Publish appends ev to jobID's replay buffer and fans it out to every\n// current subscriber. Never blocks: a subscriber whose channel is full\n// simply misses this event.\nfunc (h *Hub) Publish(jobID string, ev Event) {\n\ts := h.get(jobID)\n\n\ts.mu.Lock()\n\tdefer s.mu.Unlock()\n\n\ts.buf = append(s.buf, ev)\n\tif len(s.buf) \u003e maxBufferedEvents {\n\t\ts.buf = s.buf[len(s.buf)-maxBufferedEvents:]\n\t}\n\n\tfor ch := range s.subs {\n\t\tselect {\n\t\tcase ch \u003c- ev:\n\t\tdefault:\n\t\t}\n\t}\n}\n\n// Checkpoint clears jobID's replay buffer. Call this right after a\n// block derived from buffered events has been durably written to\n// storage, so a subscriber that connects afterward — and therefore\n// already sees that block via the persisted history — is never replayed\n// it a second time over the live channel.\nfunc (h *Hub) Checkpoint(jobID string) {\n\ts := h.get(jobID)\n\n\ts.mu.Lock()\n\tdefer s.mu.Unlock()\n\n\ts.buf = nil\n}\n\n// Subscribe returns the events currently buffered for jobID (i.e. not\n// yet checkpointed) plus a channel of everything published from this\n// point on. The returned cancel func must be called when the caller is\n// done reading, to unregister and close the channel.\nfunc (h *Hub) Subscribe(jobID string) (buffered []Event, ch \u003c-chan Event, cancel func()) {\n\ts := h.get(jobID)\n\n\ts.mu.Lock()\n\tdefer s.mu.Unlock()\n\n\tbuffered = append([]Event(nil), s.buf...)\n\n\tc := make(chan Event, subChanBuffer)\n\ts.subs[c] = struct{}{}\n\n\tvar once sync.Once\n\n\tcancelFn := func() {\n\t\tonce.Do(func() {\n\t\t\ts.mu.Lock()\n\t\t\tdefer s.mu.Unlock()\n\n\t\t\tif _, ok := s.subs[c]; ok {\n\t\t\t\tdelete(s.subs, c)\n\t\t\t\tclose(c)\n\t\t\t}\n\t\t})\n\t}\n\n\treturn buffered, c, cancelFn\n}\n\n// Close publishes a terminal Status event, disconnects every current\n// subscriber, and drops jobID's state. Call this exactly once, when the\n// job's run has finished.\nfunc (h *Hub) Close(jobID string) {\n\th.Publish(jobID, Event{Type: Status, Status: \"done\"})\n\n\th.mu.Lock()\n\ts, ok := h.jobs[jobID]\n\tdelete(h.jobs, jobID)\n\th.mu.Unlock()","start_line":1,"end_line":150,"total_lines":164,"truncated":true}

{"end_line": 120, "path": "internal/scheduler/scheduler.go", "start_line": 1}

{"path":"internal/scheduler/scheduler.go","content":"// Package scheduler resolves incoming Forgejo events to configured\n// agents and runs them, bounded by max_live_agents.\npackage scheduler\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"log/slog\"\n\t\"sync\"\n\n\t\"github.com/google/uuid\"\n\n\t\"github.com/abrander/zoo/internal/config\"\n\t\"github.com/abrander/zoo/internal/forgejo\"\n\t\"github.com/abrander/zoo/internal/livelog\"\n\t\"github.com/abrander/zoo/internal/store\"\n)\n\n// forgejoActions is the narrow slice of Client the scheduler needs for\n// its own failure-reporting side effects (defined here, not in\n// internal/forgejo, so tests can inject a fake).\ntype forgejoActions interface {\n\tCreateIssueComment(owner, repo string, index int64, body string) error\n\tAddLabel(owner, repo string, index int64, name string) error\n}\n\n// FailureLabel is applied to the triggering issue/PR, alongside a\n// comment, whenever an agent run fails or times out.\nconst FailureLabel = \"zoo:failed\"\n\n// Runner runs a single agent invocation to completion. Implemented by\n// internal/agentrun.Run; a narrow interface here so the scheduler is\n// testable without Docker.\ntype Runner interface {\n\tRun(ctx context.Context, jobID string, agent config.AgentConfig, llm config.LLM, dockerImage string, ev forgejo.Event) error\n}\n\ntype Scheduler struct {\n\tcfg     *config.Config\n\tstore   *store.Store\n\tforgejo forgejoActions\n\trunner  Runner\n\thub     *livelog.Hub\n\tlogger  *slog.Logger\n\n\tsem chan struct{}\n\twg  sync.WaitGroup\n}\n\nfunc New(cfg *config.Config, st *store.Store, fg forgejoActions, runner Runner, hub *livelog.Hub, logger *slog.Logger) *Scheduler {\n\treturn \u0026Scheduler{\n\t\tcfg:     cfg,\n\t\tstore:   st,\n\t\tforgejo: fg,\n\t\trunner:  runner,\n\t\thub:     hub,\n\t\tlogger:  logger,\n\t\tsem:     make(chan struct{}, cfg.Environment.MaxLive),\n\t}\n}\n\n// resolveAgent returns the name of the agent that should handle ev, if\n// any. Two kinds resolve dynamically: issue:assigned to the agent whose\n// config label matches the Forgejo assignee's username, and pr:review to\n// the agent whose config label matches the pull request author's\n// username (the agent that opened the PR reacts to the review of it).\n// Every other event kind uses the static event-\u003eagent mapping from\n// config.\nfunc resolveAgent(cfg *config.Config, ev forgejo.Event) (string, bool) {\n\tswitch ev.Kind {\n\tcase config.EventIssueAssigned:\n\t\tif _, ok := cfg.AgentByName(ev.Assignee); ok {\n\t\t\treturn ev.Assignee, true\n\t\t}\n\n\t\treturn \"\", false\n\n\tcase config.EventPRReview:\n\t\tif _, ok := cfg.AgentByName(ev.PRAuthor); ok {\n\t\t\treturn ev.PRAuthor, true\n\t\t}\n\n\t\treturn \"\", false\n\t}\n\n\treturn cfg.EventAgent(ev.Kind)\n}\n\n// Run consumes events until ctx is canceled or the channel closes,\n// dispatching each to its resolved agent and blocking on the\n// max_live_agents semaphore before starting a run.\nfunc (s *Scheduler) Run(ctx context.Context, events \u003c-chan forgejo.Event) {\n\tfor {\n\t\tselect {\n\t\tcase \u003c-ctx.Done():\n\t\t\treturn\n\n\t\tcase ev, ok := \u003c-events:\n\t\t\tif !ok {\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\ts.handle(ctx, ev)\n\t\t}\n\t}\n}\n\nfunc (s *Scheduler) handle(ctx context.Context, ev forgejo.Event) {\n\tagentName, ok := resolveAgent(s.cfg, ev)\n\tif !ok {\n\t\ts.logger.Debug(\"no agent resolved for event, dropping\", \"kind\", ev.Kind, \"owner\", ev.Owner, \"repo\", ev.Repo, \"index\", ev.Index)\n\t\treturn\n\t}\n\n\t// An agent's own actions (e.g. a comment posted via the `comment`\n\t// tool, authenticated with its own per-agent token) can themselves\n\t// show up as new events. Don't let an agent trigger itself off its\n\t// own activity — that's a self-reinforcing loop, not new work.\n\tif ev.Author != \"\" \u0026\u0026 ev.Author == agentName {","start_line":1,"end_line":120,"total_lines":252,"truncated":true}

{"end_line": 120, "path": "internal/llm/streamer_test.go", "start_line": 1}

{"path":"internal/llm/streamer_test.go","content":"package llm\n\nimport (\n\t\"encoding/json\"\n\t\"io\"\n\t\"net/http\"\n\t\"strings\"\n\t\"testing\"\n)\n\nfunc sseChunk(t *testing.T, delta Message, finish string) string {\n\tt.Helper()\n\n\tbody, err := json.Marshal(ChatCompletion{\n\t\tChoices: []Choice{{Delta: delta, FinishReason: finish}},\n\t})\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\treturn \"data: \" + string(body) + \"\\n\\n\"\n}\n\nfunc newTestResponse(body string) *http.Response {\n\treturn \u0026http.Response{\n\t\tStatusCode: http.StatusOK,\n\t\tBody:       io.NopCloser(strings.NewReader(body)),\n\t}\n}\n\nfunc TestStreamerMergesChunksAndStops(t *testing.T) {\n\tsse := sseChunk(t, Message{Content: \"Hel\", Role: \"assistant\"}, \"\") +\n\t\tsseChunk(t, Message{Content: \"lo\"}, \"stop\") +\n\t\t\"data: [DONE]\\n\\n\"\n\n\ts, err := NewStreamer(newTestResponse(sse))\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\tvar last *ChatCompletion\n\tfor {\n\t\tc, err := s.Get()\n\t\tif err == io.EOF {\n\t\t\tbreak\n\t\t}\n\t\tif err != nil {\n\t\t\tt.Fatal(err)\n\t\t}\n\t\tlast = c\n\t}\n\n\tif last == nil {\n\t\tt.Fatal(\"expected at least one completion\")\n\t}\n\tif len(last.Choices) != 1 {\n\t\tt.Fatalf(\"expected 1 choice, got %d\", len(last.Choices))\n\t}\n\tif last.Choices[0].Message.Content != \"Hello\" {\n\t\tt.Fatalf(\"expected merged content %q, got %q\", \"Hello\", last.Choices[0].Message.Content)\n\t}\n\tif last.Choices[0].FinishReason != \"stop\" {\n\t\tt.Fatalf(\"expected finish_reason stop, got %q\", last.Choices[0].FinishReason)\n\t}\n\tif last.Choices[0].Message.Role != \"assistant\" {\n\t\tt.Fatalf(\"expected role to stick from first chunk, got %q\", last.Choices[0].Message.Role)\n\t}\n}\n\nfunc TestStreamerNonOKStatus(t *testing.T) {\n\tresp := newTestResponse(\"boom\")\n\tresp.StatusCode = http.StatusInternalServerError\n\n\t_, err := NewStreamer(resp)\n\tif err == nil {\n\t\tt.Fatal(\"expected error for non-200 response\")\n\t}\n}\n\nfunc TestStreamerToleratesUnknownFields(t *testing.T) {\n\t// Servers may add fields we don't know about; decoding must not fail.\n\tchunk := `data: {\"id\":\"x\",\"model\":\"m\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"hi\",\"new_field\":\"boom\"},\"finish_reason\":null,\"extra\":\"y\"}],\"timings\":{\"prompt_n\":1,\"brand_new_timing\":42},\"surprise\":true}\n\n`\n\n\ts, err := NewStreamer(newTestResponse(chunk))\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\tc, err := s.Get()\n\tif err != nil {\n\t\tt.Fatalf(\"expected unknown fields to be tolerated, got error: %v\", err)\n\t}\n\tif c.Choices[0].Message.Content != \"hi\" {\n\t\tt.Fatalf(\"expected content %q, got %q\", \"hi\", c.Choices[0].Message.Content)\n\t}\n}\n\nfunc TestToolCallMerge(t *testing.T) {\n\tsse := sseChunk(t, Message{ToolCalls: []ToolCall{{Index: 0, Id: \"call1\", FunctionCall: FunctionCall{Name: \"bash\", Arguments: `{\"command\":`}}}}, \"\") +\n\t\tsseChunk(t, Message{ToolCalls: []ToolCall{{Index: 0, FunctionCall: FunctionCall{Arguments: `\"ls\"}`}}}}, \"tool_calls\") +\n\t\t\"data: [DONE]\\n\\n\"\n\n\ts, err := NewStreamer(newTestResponse(sse))\n\tif err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\tvar last *ChatCompletion\n\tfor {\n\t\tc, err := s.Get()\n\t\tif err == io.EOF {\n\t\t\tbreak\n\t\t}\n\t\tif err != nil {\n\t\t\tt.Fatal(err)\n\t\t}\n\t\tlast = c\n\t}","start_line":1,"end_line":120,"total_lines":132,"truncated":true}

{"context_after": 3, "query": "func Test"}

/project/internal/config/config_test.go:64:func TestLoadValid(t *testing.T) {
/project/internal/config/config_test.go-65-	cfg, err := load(t, validConfig)
/project/internal/config/config_test.go-66-	if err != nil {
/project/internal/config/config_test.go-67-		t.Fatalf("unexpected error: %v", err)
--
/project/internal/config/config_test.go:100:func TestValidatePRReviewRejectsAgent(t *testing.T) {
/project/internal/config/config_test.go-101-	_, err := load(t, `
/project/internal/config/config_test.go-102-llm "qwen" { openai = "https://example.com" token = "tok" model = "qwen3" }
/project/internal/config/config_test.go-103-forgejo { url = "https://example.com" token = "tok" }
--
/project/internal/config/config_test.go:113:func TestValidateUndeclaredLLM(t *testing.T) {
/project/internal/config/config_test.go-114-	_, err := load(t, `
/project/internal/config/config_test.go-115-forgejo { url = "https://example.com" token = "tok" }
/project/internal/config/config_test.go-116-environment { docker_image = "debian:unstable" max_live_agents = 1 }
--
/project/internal/config/config_test.go:124:func TestValidateUndeclaredEventAgent(t *testing.T) {
/project/internal/config/config_test.go-125-	_, err := load(t, `
/project/internal/config/config_test.go-126-llm "qwen" { openai = "https://example.com" token = "tok" model = "qwen3" }
/project/internal/config/config_test.go-127-forgejo { url = "https://example.com" token = "tok" }
--
/project/internal/config/config_test.go:137:func TestValidateIssueAssignedRejectsAgent(t *testing.T) {
/project/internal/config/config_test.go-138-	_, err := load(t, `
/project/internal/config/config_test.go-139-llm "qwen" { openai = "https://example.com" token = "tok" model = "qwen3" }
/project/internal/config/config_test.go-140-forgejo { url = "https://example.com" token = "tok" }
--
/project/internal/config/config_test.go:150:func TestValidateMaxLiveAgents(t *testing.T) {
/project/internal/config/config_test.go-151-	_, err := load(t, `
/project/internal/config/config_test.go-152-llm "qwen" { openai = "https://example.com" token = "tok" model = "qwen3" }
/project/internal/config/config_test.go-153-forgejo { url = "https://example.com" token = "tok" }
--
/project/internal/config/config_test.go:161:func TestValidateMissingDockerImage(t *testing.T) {
/project/internal/config/config_test.go-162-	_, err := load(t, `
/project/internal/config/config_test.go-163-llm "qwen" { openai = "https://example.com" token = "tok" model = "qwen3" }
/project/internal/config/config_test.go-164-forgejo { url = "https://example.com" token = "tok" }
--
/project/internal/config/config_test.go:199:func TestLoadRepos(t *testing.T) {
/project/internal/config/config_test.go-200-	cfg, err := load(t, fmt.Sprintf(reposConfigTemplate, `["acme/*", "bob/widgets"]`))
/project/internal/config/config_test.go-201-	if err != nil {
/project/internal/config/config_test.go-202-		t.Fatalf("unexpected error: %v", err)
--
/project/internal/config/config_test.go:210:func TestValidateReposEmptyList(t *testing.T) {
/project/internal/config/config_test.go-211-	cfg, err := load(t, fmt.Sprintf(reposConfigTemplate, `[]`))
/project/internal/config/config_test.go-212-	if err != nil {
/project/internal/config/config_test.go-213-		t.Fatalf("unexpected error: %v", err)
--
/project/internal/config/config_test.go:221:func TestValidateReposRejectsMalformedPatterns(t *testing.T) {
/project/internal/config/config_test.go-222-	for _, bad := range []string{`""`, `"acme/widgets/extra"`, `"/acme"`, `"acme/"`, `"acme//widgets"`} {
/project/internal/config/config_test.go-223-		_, err := load(t, fmt.Sprintf(reposConfigTemplate, `[`+bad+`]`))
/project/internal/config/config_test.go-224-		if err == nil {
--
/project/internal/config/config_test.go:230:func TestValidateUnknownEventKind(t *testing.T) {
/project/internal/config/config_test.go-231-	_, err := load(t, `
/project/internal/config/config_test.go-232-llm "qwen" { openai = "https://example.com" token = "tok" model = "qwen3" }
/project/internal/config/config_test.go-233-forgejo { url = "https://example.com" token = "tok" }
--
/project/internal/web/web_test.go:19:func testServer(t *testing.T) (*Server, *store.Store) {
/project/internal/web/web_test.go-20-	t.Helper()
/project/internal/web/web_test.go-21-
/project/internal/web/web_test.go-22-	st, err := store.Open(filepath.Join(t.TempDir(), "zoo.db"))
--
/project/internal/web/web_test.go:39:func TestIndexRenders(t *testing.T) {
/project/internal/web/web_test.go-40-	s, _ := testServer(t)
/project/internal/web/web_test.go-41-
/project/internal/web/web_test.go-42-	rr := httptest.NewRecorder()
--
/project/internal/web/web_test.go:53:func TestJobsAndDetail(t *testing.T) {
/project/internal/web/web_test.go-54-	s, st := testServer(t)
/project/internal/web/web_test.go-55-	ctx := context.Background()
/project/internal/web/web_test.go-56-
--
/project/internal/web/web_test.go:112:func TestJobDetailTrimsBlockWhitespace(t *testing.T) {
/project/internal/web/web_test.go-113-	s, st := testServer(t)
/project/internal/web/web_test.go-114-	ctx := context.Background()
/project/internal/web/web_test.go-115-
--
/project/internal/web/web_test.go:154:func TestAuthGate(t *testing.T) {
/project/internal/web/web_test.go-155-	st, err := store.Open(filepath.Join(t.TempDir(), "zoo.db"))
/project/internal/web/web_test.go-156-	if err != nil {
/project/internal/web/web_test.go-157-		t.Fatal(err)
--
/project/internal/web/web_test.go:182:func TestJobsShowAgentAvatars(t *testing.T) {
/project/internal/web/web_test.go-183-	// Minimal in-test Forgejo API: the version probe the SDK makes when
/project/internal/web/web_test.go-184-	// the client is constructed, plus per-user profile lookups.
/project/internal/web/web_test.go-185-	avatars := map[string]string{
--
/project/internal/livelog/hub_test.go:25:func TestSubscribeReplaysBufferedEvents(t *testing.T) {
/project/internal/livelog/hub_test.go-26-	h := NewHub()
/project/internal/livelog/hub_test.go-27-
/project/internal/livelog/hub_test.go-28-	h.Publish("job-1", Event{Type: ContentStart})
--
/project/internal/livelog/hub_test.go:49:func TestCheckpointClearsBuffer(t *testing.T) {
/project/internal/livelog/hub_test.go-50-	h := NewHub()
/project/internal/livelog/hub_test.go-51-
/project/internal/livelog/hub_test.go-52-	h.Publish("job-1", Event{Type: ContentStart})
--
/project/internal/livelog/hub_test.go:64:func TestCloseTerminatesSubscribers(t *testing.T) {
/project/internal/livelog/hub_test.go-65-	h := NewHub()
/project/internal/livelog/hub_test.go-66-
/project/internal/livelog/hub_test.go-67-	_, ch, cancel := h.Subscribe("job-1")
--

{"context_after": 15, "context_before": 5, "query": "reasoning_delta|content_delta"}

/project/internal/web/templates.go-962-
/project/internal/web/templates.go-963-        switch (ev.type) {
/project/internal/web/templates.go-964-          case "reasoning_start":
/project/internal/web/templates.go-965-            reasoningBody = newBlock("reasoning", "Thinking");
/project/internal/web/templates.go-966-            break;
/project/internal/web/templates.go:967:          case "reasoning_delta":
/project/internal/web/templates.go-968-            if (reasoningBody) reasoningBody.textContent += ev.text;
/project/internal/web/templates.go-969-            break;
/project/internal/web/templates.go-970-          case "reasoning_end":
/project/internal/web/templates.go-971-            // Model output routinely starts/ends with newlines; drop them
/project/internal/web/templates.go-972-            // so the finished block matches the static (trimmed) view.
/project/internal/web/templates.go-973-            if (reasoningBody) reasoningBody.textContent = reasoningBody.textContent.trim();
/project/internal/web/templates.go-974-            reasoningBody = null;
/project/internal/web/templates.go-975-            break;
/project/internal/web/templates.go-976-          case "content_start":
/project/internal/web/templates.go-977-            contentBody = newBlock("content", null);
/project/internal/web/templates.go-978-            break;
/project/internal/web/templates.go:979:          case "content_delta":
/project/internal/web/templates.go-980-            if (contentBody) contentBody.textContent += ev.text;
/project/internal/web/templates.go-981-            break;
/project/internal/web/templates.go-982-          case "content_end":
/project/internal/web/templates.go-983-            if (contentBody) contentBody.textContent = contentBody.textContent.trim();
/project/internal/web/templates.go-984-            contentBody = null;
/project/internal/web/templates.go-985-            break;
/project/internal/web/templates.go-986-          case "tool":
/project/internal/web/templates.go-987-            newToolBlock(ev);
/project/internal/web/templates.go-988-            break;
/project/internal/web/templates.go-989-          case "status":
/project/internal/web/templates.go-990-            es.close();
/project/internal/web/templates.go-991-            location.reload();
/project/internal/web/templates.go-992-            return;
/project/internal/web/templates.go-993-        }
/project/internal/web/templates.go-994-
--
/project/internal/livelog/hub.go-9-
/project/internal/livelog/hub.go-10-type Type string
/project/internal/livelog/hub.go-11-
/project/internal/livelog/hub.go-12-const (
/project/internal/livelog/hub.go-13-	ReasoningStart Type = "reasoning_start"
/project/internal/livelog/hub.go:14:	ReasoningDelta Type = "reasoning_delta"
/project/internal/livelog/hub.go-15-	ReasoningEnd   Type = "reasoning_end"
/project/internal/livelog/hub.go-16-	ContentStart   Type = "content_start"
/project/internal/livelog/hub.go:17:	ContentDelta   Type = "content_delta"
/project/internal/livelog/hub.go-18-	ContentEnd     Type = "content_end"
/project/internal/livelog/hub.go-19-	Tool           Type = "tool"
/project/internal/livelog/hub.go-20-	Status         Type = "status"
/project/internal/livelog/hub.go-21-)
/project/internal/livelog/hub.go-22-
/project/internal/livelog/hub.go-23-type Event struct {
/project/internal/livelog/hub.go-24-	Type      Type   `json:"type"`
/project/internal/livelog/hub.go-25-	Text      string `json:"text,omitempty"`
/project/internal/livelog/hub.go-26-	Name      string `json:"name,omitempty"`
/project/internal/livelog/hub.go-27-	Arguments string `json:"arguments,omitempty"`
/project/internal/livelog/hub.go-28-	Result    string `json:"result,omitempty"`
/project/internal/livelog/hub.go-29-	Error     bool   `json:"error,omitempty"`
/project/internal/livelog/hub.go-30-	Status    string `json:"status,omitempty"`
/project/internal/livelog/hub.go-31-}
/project/internal/livelog/hub.go-32-

{"end_line": 1000, "path": "internal/web/templates.go", "start_line": 880}

{"path":"internal/web/templates.go","content":"  \u003cscript\u003e\n    (function() {\n      var jobID = {{.Job.ID}};\n      var log = document.getElementById(\"log\");\n      var reasoningBody = null;\n      var contentBody = null;\n\n      function nearBottom() {\n        return (window.innerHeight + window.scrollY) \u003e= (document.body.offsetHeight - 80);\n      }\n\n      function newBlock(kind, label) {\n        var div = document.createElement(\"div\");\n        div.className = \"block block-\" + kind;\n        if (label) {\n          var l = document.createElement(\"div\");\n          l.className = \"block-label\";\n          l.textContent = label;\n          div.appendChild(l);\n        }\n        var body = document.createElement(\"div\");\n        body.className = \"block-body\";\n        div.appendChild(body);\n        log.appendChild(div);\n        return body;\n      }\n\n      function newToolBlock(ev) {\n        var details = document.createElement(\"details\");\n        details.className = \"block block-tool\" + (ev.error ? \" block-tool-error\" : \"\");\n\n        var summary = document.createElement(\"summary\");\n\n        var badge = document.createElement(\"span\");\n        badge.className = \"tool-badge\";\n        badge.textContent = \"Tool\";\n\n        var text = document.createElement(\"span\");\n        text.className = \"tool-summary-text\";\n\n        var name = document.createElement(\"span\");\n        name.className = \"tool-name\";\n        name.textContent = \"🔧 \" + ev.name;\n\n        var preview = document.createElement(\"span\");\n        preview.className = \"tool-args-preview\";\n        preview.textContent = ev.arguments;\n\n        text.appendChild(name);\n        text.appendChild(preview);\n        summary.appendChild(badge);\n        summary.appendChild(text);\n        details.appendChild(summary);\n\n        var body = document.createElement(\"div\");\n        body.className = \"block-body\";\n\n        var argsLabel = document.createElement(\"div\");\n        argsLabel.className = \"tool-section-label\";\n        argsLabel.textContent = \"Arguments\";\n        var argsPre = document.createElement(\"pre\");\n        argsPre.textContent = ev.arguments;\n\n        var resultLabel = document.createElement(\"div\");\n        resultLabel.className = \"tool-section-label\";\n        resultLabel.textContent = \"Result\";\n        var resultPre = document.createElement(\"pre\");\n        resultPre.textContent = ev.result;\n\n        body.appendChild(argsLabel);\n        body.appendChild(argsPre);\n        body.appendChild(resultLabel);\n        body.appendChild(resultPre);\n        details.appendChild(body);\n        log.appendChild(details);\n      }\n\n      var es = new EventSource(\"/jobs/\" + jobID + \"/events\");\n\n      es.onmessage = function(e) {\n        var ev = JSON.parse(e.data);\n        var shouldScroll = nearBottom();\n\n        switch (ev.type) {\n          case \"reasoning_start\":\n            reasoningBody = newBlock(\"reasoning\", \"Thinking\");\n            break;\n          case \"reasoning_delta\":\n            if (reasoningBody) reasoningBody.textContent += ev.text;\n            break;\n          case \"reasoning_end\":\n            // Model output routinely starts/ends with newlines; drop them\n            // so the finished block matches the static (trimmed) view.\n            if (reasoningBody) reasoningBody.textContent = reasoningBody.textContent.trim();\n            reasoningBody = null;\n            break;\n          case \"content_start\":\n            contentBody = newBlock(\"content\", null);\n            break;\n          case \"content_delta\":\n            if (contentBody) contentBody.textContent += ev.text;\n            break;\n          case \"content_end\":\n            if (contentBody) contentBody.textContent = contentBody.textContent.trim();\n            contentBody = null;\n            break;\n          case \"tool\":\n            newToolBlock(ev);\n            break;\n          case \"status\":\n            es.close();\n            location.reload();\n            return;\n        }\n\n        if (shouldScroll) window.scrollTo(0, document.body.scrollHeight);\n      };\n    })();\n  \u003c/script\u003e\n  {{end}}\n\u003c/div\u003e","start_line":880,"end_line":1000,"total_lines":1004,"truncated":true}

{"end_line": 30, "path": "go.mod", "start_line": 1}

{"path":"go.mod","content":"module github.com/abrander/zoo\n\ngo 1.26.4\n\nrequire (\n\tcodeberg.org/mvdkleijn/forgejo-sdk/forgejo/v2 v2.2.0\n\tgithub.com/docker/docker v28.5.2+incompatible\n\tgithub.com/google/uuid v1.6.0\n\tgithub.com/hashicorp/hcl/v2 v2.24.0\n\tmodernc.org/sqlite v1.56.0\n)\n\nrequire (\n\tgithub.com/42wim/httpsig v1.2.3 // indirect\n\tgithub.com/Microsoft/go-winio v0.6.2 // indirect\n\tgithub.com/agext/levenshtein v1.2.1 // indirect\n\tgithub.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect\n\tgithub.com/cespare/xxhash/v2 v2.3.0 // indirect\n\tgithub.com/containerd/errdefs v1.0.0 // indirect\n\tgithub.com/containerd/errdefs/pkg v0.3.0 // indirect\n\tgithub.com/containerd/log v0.1.0 // indirect\n\tgithub.com/davidmz/go-pageant v1.0.2 // indirect\n\tgithub.com/distribution/reference v0.6.0 // indirect\n\tgithub.com/docker/go-connections v0.8.1 // indirect\n\tgithub.com/docker/go-units v0.5.0 // indirect\n\tgithub.com/dustin/go-humanize v1.0.1 // indirect\n\tgithub.com/felixge/httpsnoop v1.1.0 // indirect\n\tgithub.com/go-fed/httpsig v1.1.0 // indirect\n\tgithub.com/go-logr/logr v1.4.4 // indirect\n\tgithub.com/go-logr/stdr v1.2.2 // indirect","start_line":1,"end_line":30,"total_lines":62,"truncated":true}

{"query": "runLoop|StreamChatCompletion|Hooks\\{"}

/project/internal/llm/client.go:30:func (c *Client) StreamChatCompletion(ctx context.Context, req *ChatCompletionRequest) (*Streamer, error) {
/project/internal/agentrun/loop.go:12:// Hooks lets a caller observe a runLoop invocation live, as the model
/project/internal/agentrun/loop.go:30:// runLoop is a headless port of ../a's App.generate(): send messages +
/project/internal/agentrun/loop.go:33:func runLoop(ctx context.Context, client *llm.Client, toolsCtx tools.Context, messages []llm.Message, hooks Hooks) ([]llm.Message, error) {
/project/internal/agentrun/loop.go:39:		streamer, err := client.StreamChatCompletion(ctx, &llm.ChatCompletionRequest{
/project/internal/agentrun/run.go:271:	_, err = runLoop(ctx, llmClient, runCtx, messages, hooks)
/project/internal/agentrun/run.go:281:// streamHooks builds the Hooks a single Run passes to runLoop: every
/project/internal/agentrun/run.go:293:	return Hooks{

{"end_line": 80, "path": "internal/tools/context.go", "start_line": 1}

{"path":"internal/tools/context.go","content":"// Package tools is the registry of functions an agent's tool-calling\n// loop can invoke, ported from ../a/tools but retargeted at a Docker\n// container (via Exec) and the Forgejo issue/PR that triggered the run\n// (via Forgejo()) instead of a local sandboxed filesystem.\npackage tools\n\nimport \"context\"\n\n// Context is bound to a single agent run (job), unlike ../a's single\n// global Context, since multiple agents run concurrently in zoo.\ntype Context interface {\n\t// Exec runs command inside the run's container via `sh -c` and\n\t// returns combined stdout+stderr.\n\tExec(ctx context.Context, command string) (string, error)\n\n\t// Forgejo returns the actions bound to the issue/PR that triggered\n\t// this run, so tools don't need to be told which repo/issue to act\n\t// on.\n\tForgejo() ForgejoActions\n}\n\n// ForgejoActions are the actions available to an agent against the\n// triggering issue/PR. Implemented by internal/agentrun, backed by\n// internal/forgejo.Client plus the run's owner/repo/issue.\ntype ForgejoActions interface {\n\tComment(body string) error\n\tOpenPullRequest(head, base, title, body string) error\n\tRequestReview(reviewers []string) error\n\tAddLabel(name string) error\n\tRemoveLabel(name string) error\n\tCloseIssue() error\n\tReopenIssue() error\n\n\t// AssignIssue hands the triggering issue/PR off to another agent by\n\t// their name (which doubles as their Forgejo username); the\n\t// resulting issue:assigned event triggers that agent's run.\n\tAssignIssue(agentName string) error\n\n\t// SubmitReview submits a review on the triggering pull request with\n\t// the given verdict (forgejo.ReviewStateApproved,\n\t// ReviewStateChangesRequest, or ReviewStateComment) and body.\n\tSubmitReview(state, body string) error\n}","start_line":1,"end_line":43,"total_lines":43,"truncated":false}

{"end_line": 60, "path": "internal/tools/registry.go", "start_line": 1}

{"path":"internal/tools/registry.go","content":"package tools\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\n\t\"github.com/abrander/zoo/internal/llm\"\n)\n\ntype toolFunc[P any] func(Context, P) (string, error)\n\ntype tool struct {\n\ttool llm.Tool\n\tcall func(ctx Context, args string) (string, error)\n}\n\nvar registry = map[string]tool{}\n\n// All lists all known tools.\nfunc All() []llm.Tool {\n\tts := make([]llm.Tool, 0, len(registry))\n\n\tfor _, t := range registry {\n\t\tts = append(ts, t.tool)\n\t}\n\n\treturn ts\n}\n\n// Register registers a tool function with the given definition. The\n// registry is a stateless name-\u003efunc map shared across concurrent runs;\n// all per-run state lives in the Context passed to Call.\nfunc Register[P any](def llm.Tool, fun toolFunc[P]) {\n\tif def.Type != \"function\" {\n\t\tpanic(\"tool must be a function\")\n\t}\n\n\tif def.Function.Name == \"\" {\n\t\tpanic(\"tool function must have a name\")\n\t}\n\n\tif _, found := registry[def.Function.Name]; found {\n\t\tpanic(fmt.Sprintf(\"tool with name %q already registered\", def.Function.Name))\n\t}\n\n\tregistry[def.Function.Name] = tool{\n\t\ttool: def,\n\t\tcall: func(ctx Context, args string) (string, error) {\n\t\t\tvar params P\n\n\t\t\tif err := json.Unmarshal([]byte(args), \u0026params); err != nil {\n\t\t\t\treturn \"\", err\n\t\t\t}\n\n\t\t\treturn fun(ctx, params)\n\t\t},\n\t}\n}\n\n// Call invokes a registered tool by name with the given (raw JSON)","start_line":1,"end_line":60,"total_lines":69,"truncated":true}

{"end_line": 40, "path": "internal/agentrun/docker_integration_test.go", "start_line": 1}

{"path":"internal/agentrun/docker_integration_test.go","content":"//go:build docker\n\n// Run with: go test -tags docker ./internal/agentrun/...\n// Requires a reachable Docker daemon (DOCKER_HOST or the default socket).\npackage agentrun\n\nimport (\n\t\"context\"\n\t\"os\"\n\t\"os/exec\"\n\t\"path/filepath\"\n\t\"strings\"\n\t\"testing\"\n\t\"time\"\n)\n\nfunc TestDockerRuntimeExecRoundTrip(t *testing.T) {\n\trt, err := newDockerRuntime()\n\tif err != nil {\n\t\tt.Fatalf(\"docker client: %v\", err)\n\t}\n\n\tctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)\n\tdefer cancel()\n\n\tcontainerID, err := rt.createContainer(ctx, \"debian:unstable\", nil, \"zoo-test-run\")\n\tif err != nil {\n\t\tt.Fatalf(\"create container: %v\", err)\n\t}\n\tdefer rt.remove(context.Background(), containerID)\n\n\toutput, exitCode, err := rt.exec(ctx, containerID, \"echo hello-from-zoo\")\n\tif err != nil {\n\t\tt.Fatalf(\"exec: %v\", err)\n\t}\n\tif exitCode != 0 {\n\t\tt.Fatalf(\"expected exit code 0, got %d\", exitCode)\n\t}\n\tif !strings.Contains(output, \"hello-from-zoo\") {\n\t\tt.Fatalf(\"unexpected output: %q\", output)","start_line":1,"end_line":40,"total_lines":224,"truncated":true}

{"end_line": 69, "path": "internal/tools/registry.go", "start_line": 56}

{"path":"internal/tools/registry.go","content":"\t\t},\n\t}\n}\n\n// Call invokes a registered tool by name with the given (raw JSON)\n// arguments, against the given run's Context.\nfunc Call(ctx Context, fcall llm.FunctionCall) (string, error) {\n\tt, found := registry[fcall.Name]\n\tif !found {\n\t\treturn \"\", fmt.Errorf(\"unknown function: %s\", fcall.Name)\n\t}\n\n\treturn t.call(ctx, fcall.Arguments)\n}","start_line":56,"end_line":69,"total_lines":69,"truncated":false}

{"end_line": 60, "path": "internal/tools/forgejo.go", "start_line": 1}

{"path":"internal/tools/forgejo.go","content":"package tools\n\nimport (\n\t\"fmt\"\n\t\"strings\"\n\n\t\"github.com/abrander/zoo/internal/llm\"\n)\n\ntype commentParams struct {\n\tBody string `json:\"body\"`\n}\n\nfunc init() {\n\ttool := llm.NewTool(\n\t\t\"comment\",\n\t\t\"Post a comment on the issue or pull request that triggered this run.\")\n\n\ttool.AddStringProperty(\"body\", \"The comment text, in Markdown\", true)\n\n\tRegister(tool, comment)\n}\n\nfunc comment(ctx Context, params commentParams) (string, error) {\n\tif err := ctx.Forgejo().Comment(params.Body); err != nil {\n\t\treturn \"\", err\n\t}\n\n\treturn \"Comment posted\", nil\n}\n\ntype openPullRequestParams struct {\n\tHead  string `json:\"head\"`\n\tBase  string `json:\"base\"`\n\tTitle string `json:\"title\"`\n\tBody  string `json:\"body\"`\n}\n\nfunc init() {\n\ttool := llm.NewTool(\n\t\t\"open_pull_request\",\n\t\t\"Open a pull request from a branch you've pushed into the repository's default branch (or another base branch).\")\n\n\ttool.AddStringProperty(\"head\", \"The branch containing your changes (usually the run's own branch)\", true)\n\ttool.AddStringProperty(\"base\", \"The branch to merge into, e.g. the repository's default branch\", true)\n\ttool.AddStringProperty(\"title\", \"The pull request title\", true)\n\ttool.AddStringProperty(\"body\", \"The pull request description, in Markdown\", true)\n\n\tRegister(tool, openPullRequest)\n}\n\nfunc openPullRequest(ctx Context, params openPullRequestParams) (string, error) {\n\tif err := ctx.Forgejo().OpenPullRequest(params.Head, params.Base, params.Title, params.Body); err != nil {\n\t\treturn \"\", err\n\t}\n\n\treturn \"Pull request opened\", nil\n}\n\ntype requestReviewParams struct {","start_line":1,"end_line":60,"total_lines":204,"truncated":true}

{"end_line": 80, "path": "internal/store/schema.sql", "start_line": 1}

{"path":"internal/store/schema.sql","content":"CREATE TABLE IF NOT EXISTS watermark (\n    key   TEXT PRIMARY KEY,\n    value TEXT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS seen_events (\n    id      TEXT PRIMARY KEY,\n    seen_at DATETIME NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS jobs (\n    id          TEXT PRIMARY KEY,\n    event_kind  TEXT NOT NULL,\n    agent       TEXT NOT NULL,\n    owner       TEXT NOT NULL,\n    repo        TEXT NOT NULL,\n    issue_index INTEGER NOT NULL,\n    title       TEXT NOT NULL DEFAULT '',\n    status      TEXT NOT NULL,\n    created_at  DATETIME NOT NULL,\n    started_at  DATETIME,\n    finished_at DATETIME,\n    error       TEXT NOT NULL DEFAULT ''\n);\n\nCREATE INDEX IF NOT EXISTS idx_jobs_created_at ON jobs (created_at DESC);\n\nCREATE TABLE IF NOT EXISTS job_logs (\n    job_id TEXT NOT NULL,\n    seq    INTEGER NOT NULL,\n    stream TEXT NOT NULL,\n    line   TEXT NOT NULL,\n    ts     DATETIME NOT NULL,\n    PRIMARY KEY (job_id, seq)\n);\n\n-- Last-known assignee set per issue, used by the poller to tell a real\n-- (re-)assignment apart from any other update to an already-assigned\n-- issue. Webhooks say \"assigned\" outright; polling only ever sees state.\nCREATE TABLE IF NOT EXISTS issue_assignees (\n    issue_id INTEGER NOT NULL,\n    assignee TEXT NOT NULL,\n    PRIMARY KEY (issue_id, assignee)\n);","start_line":1,"end_line":44,"total_lines":44,"truncated":false}

{"context_after": 8, "query": "status: %d|decode completion chunk"}

/project/internal/llm/streamer.go:23:		return nil, fmt.Errorf("status: %d: %s", resp.StatusCode, body)
/project/internal/llm/streamer.go-24-	}
/project/internal/llm/streamer.go-25-
/project/internal/llm/streamer.go-26-	return &Streamer{
/project/internal/llm/streamer.go-27-		resp:    resp,
/project/internal/llm/streamer.go-28-		scanner: bufio.NewScanner(resp.Body),
/project/internal/llm/streamer.go-29-	}, nil
/project/internal/llm/streamer.go-30-}
/project/internal/llm/streamer.go-31-
--
/project/internal/llm/streamer.go:73:		return nil, fmt.Errorf("decode completion chunk: %w: %s", err, buf)
/project/internal/llm/streamer.go-74-	}
/project/internal/llm/streamer.go-75-
/project/internal/llm/streamer.go-76-	s.completion.Merge(&completion)
/project/internal/llm/streamer.go-77-
/project/internal/llm/streamer.go-78-	return &s.completion, nil
/project/internal/llm/streamer.go-79-}

{"context_after": 10, "context_before": 3, "query": "case \"tool\"|stream ==|Stream =="}

/project/internal/web/templates.go-983-            if (contentBody) contentBody.textContent = contentBody.textContent.trim();
/project/internal/web/templates.go-984-            contentBody = null;
/project/internal/web/templates.go-985-            break;
/project/internal/web/templates.go:986:          case "tool":
/project/internal/web/templates.go-987-            newToolBlock(ev);
/project/internal/web/templates.go-988-            break;
/project/internal/web/templates.go-989-          case "status":
/project/internal/web/templates.go-990-            es.close();
/project/internal/web/templates.go-991-            location.reload();
/project/internal/web/templates.go-992-            return;
/project/internal/web/templates.go-993-        }
/project/internal/web/templates.go-994-
/project/internal/web/templates.go-995-        if (shouldScroll) window.scrollTo(0, document.body.scrollHeight);
/project/internal/web/templates.go-996-      };
--
/project/internal/web/web.go-222-			}
/project/internal/web/web.go-223-			blocks = append(blocks, block{Kind: l.Stream, Text: text})
/project/internal/web/web.go-224-
/project/internal/web/web.go:225:		case "tool":
/project/internal/web/web.go-226-			var entry store.ToolLogEntry
/project/internal/web/web.go-227-			if err := json.Unmarshal([]byte(l.Line), &entry); err != nil {
/project/internal/web/web.go-228-				blocks = append(blocks, block{Kind: "system", Text: l.Line})
/project/internal/web/web.go-229-
/project/internal/web/web.go-230-				continue
/project/internal/web/web.go-231-			}
/project/internal/web/web.go-232-
/project/internal/web/web.go-233-			blocks = append(blocks, block{Kind: "tool", Tool: &toolBlock{
/project/internal/web/web.go-234-				Name:      entry.Name,
/project/internal/web/web.go-235-				Arguments: entry.Arguments,
--
/project/internal/store/store.go-314-}
/project/internal/store/store.go-315-
/project/internal/store/store.go-316-// ToolLogEntry is the JSON shape stored in a LogLine's Line field for
/project/internal/store/store.go:317:// Stream == "tool": one complete tool call and its result.
/project/internal/store/store.go-318-type ToolLogEntry struct {
/project/internal/store/store.go-319-	Name      string `json:"name"`
/project/internal/store/store.go-320-	Arguments string `json:"arguments"`
/project/internal/store/store.go-321-	Result    string `json:"result"`
/project/internal/store/store.go-322-	Error     bool   `json:"error"`
/project/internal/store/store.go-323-}
/project/internal/store/store.go-324-
/project/internal/store/store.go-325-// AppendLog appends one log line for a job, assigning it the next
/project/internal/store/store.go-326-// sequence number for that job.
/project/internal/store/store.go-327-func (s *Store) AppendLog(ctx context.Context, jobID, stream, line string) error {

{"end_line": 245, "path": "internal/web/web.go", "start_line": 190}

{"path":"internal/web/web.go","content":"type toolBlock struct {\n\tName      string\n\tArguments string\n\tResult    string\n\tError     bool\n}\n\n// block is one self-contained, already-complete unit of job output: a\n// finished reasoning or assistant-message block, a finished tool call,\n// or a misc system note. Unlike the old flat log view, one store.LogLine\n// maps to exactly one block — grouping/streaming happens upstream, when\n// agentrun persists the row.\ntype block struct {\n\tKind string // \"reasoning\" | \"content\" | \"tool\" | \"system\"\n\tText string\n\tTool *toolBlock\n}\n\nfunc buildBlocks(logs []store.LogLine) []block {\n\tblocks := make([]block, 0, len(logs))\n\n\tfor _, l := range logs {\n\t\tswitch l.Stream {\n\t\tcase \"reasoning\", \"content\":\n\t\t\t// Model output routinely starts/ends with newlines. The block\n\t\t\t// body renders with white-space: pre-wrap, so those would show\n\t\t\t// up as visible blank lines inflating the block's height. Trim\n\t\t\t// them for display (internal newlines are kept) and drop\n\t\t\t// blocks that are nothing but whitespace.\n\t\t\ttext := strings.TrimSpace(l.Line)\n\t\t\tif text == \"\" {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tblocks = append(blocks, block{Kind: l.Stream, Text: text})\n\n\t\tcase \"tool\":\n\t\t\tvar entry store.ToolLogEntry\n\t\t\tif err := json.Unmarshal([]byte(l.Line), \u0026entry); err != nil {\n\t\t\t\tblocks = append(blocks, block{Kind: \"system\", Text: l.Line})\n\n\t\t\t\tcontinue\n\t\t\t}\n\n\t\t\tblocks = append(blocks, block{Kind: \"tool\", Tool: \u0026toolBlock{\n\t\t\t\tName:      entry.Name,\n\t\t\t\tArguments: entry.Arguments,\n\t\t\t\tResult:    entry.Result,\n\t\t\t\tError:     entry.Error,\n\t\t\t}})\n\n\t\tdefault:\n\t\t\tblocks = append(blocks, block{Kind: \"system\", Text: l.Line})\n\t\t}\n\t}\n\n\treturn blocks","start_line":190,"end_line":245,"total_lines":374,"truncated":true}

{"context_after": 6, "context_before": 2, "query": "logAppend\\(|block-system"}

/project/internal/web/templates.go-477-  }
/project/internal/web/templates.go-478-
/project/internal/web/templates.go:479:  .block-system {
/project/internal/web/templates.go-480-    padding: 0.35rem 0.75rem;
/project/internal/web/templates.go-481-    color: var(--text-muted);
/project/internal/web/templates.go-482-    font-family: var(--mono);
/project/internal/web/templates.go-483-    font-size: 0.8rem;
/project/internal/web/templates.go-484-  }
/project/internal/web/templates.go-485-
--
/project/internal/web/templates.go-872-      </details>
/project/internal/web/templates.go-873-      {{else}}
/project/internal/web/templates.go:874:      <div class="block block-system">{{.Text}}</div>
/project/internal/web/templates.go-875-      {{end}}
/project/internal/web/templates.go-876-    {{end}}
/project/internal/web/templates.go-877-  </div>
/project/internal/web/templates.go-878-
/project/internal/web/templates.go-879-  {{if .Live}}
/project/internal/web/templates.go-880-  <script>
--
/project/internal/agentrun/run.go-315-			if reasoningOpen {
/project/internal/agentrun/run.go-316-				r.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningEnd})
/project/internal/agentrun/run.go:317:				logAppend("reasoning", reasoningBuf.String())
/project/internal/agentrun/run.go-318-				r.hub.Checkpoint(jobID)
/project/internal/agentrun/run.go-319-				reasoningOpen = false
/project/internal/agentrun/run.go-320-			}
/project/internal/agentrun/run.go-321-
/project/internal/agentrun/run.go-322-			if contentOpen {
/project/internal/agentrun/run.go-323-				r.hub.Publish(jobID, livelog.Event{Type: livelog.ContentEnd})
/project/internal/agentrun/run.go:324:				logAppend("content", contentBuf.String())
/project/internal/agentrun/run.go-325-				r.hub.Checkpoint(jobID)
/project/internal/agentrun/run.go-326-				contentOpen = false
/project/internal/agentrun/run.go-327-			}
/project/internal/agentrun/run.go-328-		},
/project/internal/agentrun/run.go-329-		OnTool: func(name, arguments, result string, toolErr bool) {
/project/internal/agentrun/run.go-330-			r.hub.Publish(jobID, livelog.Event{
--
/project/internal/agentrun/run.go-340-				r.logger.Warn("failed to marshal tool log entry", "job", jobID, "error", err)
/project/internal/agentrun/run.go-341-			} else {
/project/internal/agentrun/run.go:342:				logAppend("tool", string(line))
/project/internal/agentrun/run.go-343-			}
/project/internal/agentrun/run.go-344-
/project/internal/agentrun/run.go-345-			r.hub.Checkpoint(jobID)
/project/internal/agentrun/run.go-346-		},
/project/internal/agentrun/run.go-347-	}
/project/internal/agentrun/run.go-348-}

{"content": "package llm\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"net/http\"\n)\n\n// The client classifies its failures into a small set of typed errors\n// so callers can decide what is worth retrying (see IsTransient):\n//\n//   - StatusError: the endpoint answered with a non-200 status.\n//   - StreamError: the response body broke or ended before the\n//     stream's [DONE] marker, i.e. the connection dropped mid-turn.\n//   - DecodeError: the endpoint sent a data line that is not valid\n//     JSON, i.e. a protocol violation rather than a transient fault.\n//\n// Unrecognized errors (transport failures such as connection refused\n// or reset, DNS errors, timeouts) are treated as transient by default:\n// when in doubt, the endpoint is assumed flaky and the caller's\n// bounded retry budget decides.\n\n// StatusError is returned when the endpoint answers with a non-200\n// status.\ntype StatusError struct {\n\tStatusCode int\n\tBody       string\n}\n\nfunc (e *StatusError) Error() string {\n\treturn fmt.Sprintf(\"llm endpoint returned status %d: %s\", e.StatusCode, e.Body)\n}\n\n// StreamError is returned when the stream breaks or ends before its\n// [DONE] marker. Err is the underlying read error if the body broke\n// with one; a nil Err means the body ended cleanly without [DONE].\ntype StreamError struct {\n\tErr error\n}\n\nfunc (e *StreamError) Error() string {\n\tif e.Err != nil {\n\t\treturn fmt.Sprintf(\"llm stream interrupted: %v\", e.Err)\n\t}\n\treturn \"llm stream ended before [DONE]\"\n}\n\nfunc (e *StreamError) Unwrap() error { return e.Err }\n\n// DecodeError is returned when a data line is not valid JSON.\ntype DecodeError struct {\n\tErr   error\n\tChunk string\n}\n\nfunc (e *DecodeError) Error() string {\n\treturn fmt.Sprintf(\"decode completion chunk: %v: %s\", e.Err, e.Chunk)\n}\n\nfunc (e *DecodeError) Unwrap() error { return e.Err }\n\n// IsTransient reports whether a failed LLM round trip is worth\n// retrying. Transport failures, 5xx/429/408 responses, and mid-stream\n// interruptions are transient: the endpoint may be down or overloaded,\n// and the same request may succeed later. Client errors (other 4xx)\n// and malformed responses are not: retrying the same request cannot\n// fix them. Context cancellation is never transient — the caller gave\n// up.\nfunc IsTransient(err error) bool {\n\tif err == nil {\n\t\treturn false\n\t}\n\n\tif errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {\n\t\treturn false\n\t}\n\n\tvar se *StatusError\n\tif errors.As(err, &se) {\n\t\treturn se.StatusCode == http.StatusRequestTimeout ||\n\t\t\tse.StatusCode == http.StatusTooManyRequests ||\n\t\t\tse.StatusCode >= 500\n\t}\n\n\tvar de *DecodeError\n\tif errors.As(err, &de) {\n\t\treturn false\n\t}\n\n\treturn true\n}\n", "path": "internal/llm/errors.go"}

OK

{"content": "package llm\n\nimport (\n\t\"bufio\"\n\t\"bytes\"\n\t\"encoding/json\"\n\t\"io\"\n\t\"net/http\"\n)\n\n// maxStatusBody caps how much of a non-200 response body is kept for\n// the error message.\nconst maxStatusBody = 1024\n\ntype Streamer struct {\n\tcompletion ChatCompletion\n\tresp       *http.Response\n\tscanner    *bufio.Scanner\n\teof        bool\n}\n\nfunc NewStreamer(resp *http.Response) (*Streamer, error) {\n\tif resp.StatusCode != http.StatusOK {\n\t\tbody, _ := io.ReadAll(io.LimitReader(resp.Body, maxStatusBody))\n\t\tresp.Body.Close()\n\t\treturn nil, &StatusError{StatusCode: resp.StatusCode, Body: string(body)}\n\t}\n\n\treturn &Streamer{\n\t\tresp:    resp,\n\t\tscanner: bufio.NewScanner(resp.Body),\n\t}, nil\n}\n\n// Get returns the accumulated completion after merging in the next SSE\n// chunk. Callers should keep calling Get until it returns io.EOF.\nfunc (s *Streamer) Get() (*ChatCompletion, error) {\n\tif s.eof {\n\t\treturn nil, io.EOF\n\t}\n\n\tprefix := []byte(\"data: \")\n\n\tvar buf []byte\n\tvar found bool\n\n\tfor s.scanner.Scan() {\n\t\tline := bytes.TrimSpace(s.scanner.Bytes())\n\n\t\tif len(line) == 0 {\n\t\t\tcontinue\n\t\t}\n\n\t\tif bytes.HasPrefix(line, prefix) {\n\t\t\tbuf = bytes.TrimPrefix(line, prefix)\n\t\t\tfound = true\n\t\t\tbreak\n\t\t}\n\t}\n\n\tif err := s.scanner.Err(); err != nil {\n\t\treturn nil, &StreamError{Err: err}\n\t}\n\n\tif !found {\n\t\t// The body ended before a data line arrived: the stream was\n\t\t// cut off before [DONE].\n\t\ts.resp.Body.Close()\n\t\ts.eof = true\n\t\treturn nil, &StreamError{}\n\t}\n\n\tif bytes.Equal(buf, []byte(\"[DONE]\")) {\n\t\ts.resp.Body.Close()\n\t\ts.eof = true\n\t\treturn nil, io.EOF\n\t}\n\n\tvar completion ChatCompletion\n\n\t// Unknown fields are tolerated on purpose: servers (e.g. newer\n\t// llama.cpp builds) may add fields we don't know about yet, and\n\t// failing on them would break compatibility.\n\tif err := json.Unmarshal(buf, &completion); err != nil {\n\t\treturn nil, &DecodeError{Err: err, Chunk: string(buf)}\n\t}\n\n\ts.completion.Merge(&completion)\n\n\treturn &s.completion, nil\n}\n", "path": "internal/llm/streamer.go"}

OK

{"content": "package agentrun\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"io\"\n\t\"math/rand\"\n\t\"time\"\n\n\t\"github.com/abrander/zoo/internal/llm\"\n\t\"github.com/abrander/zoo/internal/tools\"\n)\n\n// Hooks lets a caller observe a runLoop invocation live, as the model\n// streams and tool calls execute, in addition to the final []llm.Message\n// it returns. Any of these may be nil.\ntype Hooks struct {\n\t// OnReasoningDelta and OnContentDelta fire with just the newly\n\t// streamed text for the current turn, not the accumulated total.\n\tOnReasoningDelta func(delta string)\n\tOnContentDelta   func(delta string)\n\n\t// OnTurnEnd fires once per completed streamer round-trip, after the\n\t// model's message for that turn is fully received and before any of\n\t// its tool calls run.\n\tOnTurnEnd func()\n\n\t// OnRetry fires before each backoff wait, i.e. whenever a turn's\n\t// round trip failed transiently and is about to be retried. attempt\n\t// is the 1-based number of the failed attempt, delay is the wait\n\t// that is about to happen, and err is the failure.\n\tOnRetry func(attempt int, delay time.Duration, err error)\n\n\t// OnTool fires once per tool call, after it has run.\n\tOnTool func(name, arguments, result string, toolErr bool)\n}\n\n// The retry budget for one LLM round trip (request + full stream read),\n// not for the whole run: a run can last hours and each turn is\n// independent, so a failing endpoint should cost at most a few seconds\n// of backoff per turn before the run surfaces the error.\nconst (\n\tllmMaxAttempts = 5\n\tllmBaseDelay   = time.Second\n\tllmMaxDelay    = 15 * time.Second\n)\n\n// llmSleep waits d, returning early with ctx's error if the run is\n// canceled or times out while waiting. Overridden in tests.\nvar llmSleep = func(ctx context.Context, d time.Duration) error {\n\tselect {\n\tcase <-time.After(d):\n\t\treturn nil\n\tcase <-ctx.Done():\n\t\treturn ctx.Err()\n\t}\n}\n\n// runLoop is a headless port of ../a's App.generate(): send messages +\n// tool defs, get a completion, run any tool_calls and append their\n// results, repeat until a plain finish or ctx is done. Transient LLM\n// endpoint failures (connection errors, 5xx/429 responses, mid-stream\n// breaks) are retried per turn with exponential backoff — see\n// requestTurn.\nfunc runLoop(ctx context.Context, client *llm.Client, toolsCtx tools.Context, messages []llm.Message, hooks Hooks) ([]llm.Message, error) {\n\tfor {\n\t\tif err := ctx.Err(); err != nil {\n\t\t\treturn messages, err\n\t\t}\n\n\t\tcompletion, err := requestTurn(ctx, client, messages, hooks)\n\t\tif err != nil {\n\t\t\treturn messages, err\n\t\t}\n\n\t\tchoice := completion.Choices[0]\n\t\tmessages = append(messages, choice.Message)\n\n\t\tif choice.FinishReason != \"tool_calls\" || len(choice.Message.ToolCalls) == 0 {\n\t\t\treturn messages, nil\n\t\t}\n\n\t\tfor _, tc := range choice.Message.ToolCalls {\n\t\t\tif err := ctx.Err(); err != nil {\n\t\t\t\treturn messages, err\n\t\t\t}\n\n\t\t\tresult, err := tools.Call(toolsCtx, tc.FunctionCall)\n\n\t\t\ttoolErr := err != nil\n\t\t\tif toolErr {\n\t\t\t\tresult = fmt.Sprintf(\"ERROR CALLING TOOL: %s\", err.Error())\n\t\t\t}\n\n\t\t\tif hooks.OnTool != nil {\n\t\t\t\thooks.OnTool(tc.FunctionCall.Name, tc.FunctionCall.Arguments, result, toolErr)\n\t\t\t}\n\n\t\t\tmessages = append(messages, llm.Message{\n\t\t\t\tRole:       \"tool\",\n\t\t\t\tContent:    result,\n\t\t\t\tToolCallID: tc.Id,\n\t\t\t\tName:       tc.FunctionCall.Name,\n\t\t\t})\n\t\t}\n\t}\n}\n\n// requestTurn performs one LLM round trip (request + full stream\n// read), retrying transient endpoint failures with exponential\n// backoff and jitter. It returns the completed turn's accumulated\n// completion.\nfunc requestTurn(ctx context.Context, client *llm.Client, messages []llm.Message, hooks Hooks) (*llm.ChatCompletion, error) {\n\tfor attempt := 1; ; attempt++ {\n\t\tcompletion, err := streamTurn(ctx, client, messages, hooks)\n\t\tif err == nil {\n\t\t\treturn completion, nil\n\t\t}\n\n\t\t// A canceled or timed-out run is not a failing endpoint; stop\n\t\t// and report the run's own error.\n\t\tif ctxErr := ctx.Err(); ctxErr != nil {\n\t\t\treturn nil, ctxErr\n\t\t}\n\n\t\t// Permanent failures (client errors, malformed responses) and\n\t\t// exhausted budgets fail immediately.\n\t\tif !llm.IsTransient(err) || attempt == llmMaxAttempts {\n\t\t\tif attempt > 1 {\n\t\t\t\treturn nil, fmt.Errorf(\"llm endpoint failed after %d attempts: %w\", attempt, err)\n\t\t\t}\n\t\t\treturn nil, err\n\t\t}\n\n\t\tdelay := llmBackoff(attempt)\n\n\t\tif hooks.OnRetry != nil {\n\t\t\thooks.OnRetry(attempt, delay, err)\n\t\t}\n\n\t\tif err := llmSleep(ctx, delay); err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n}\n\n// llmBackoff returns the delay before retrying after the given failed\n// attempt (1-based): exponential growth from llmBaseDelay, capped at\n// llmMaxDelay, with equal jitter (half fixed, half random) so\n// concurrent agents don't retry in lockstep.\nfunc llmBackoff(attempt int) time.Duration {\n\td := llmBaseDelay << (attempt - 1)\n\tif d <= 0 || d > llmMaxDelay {\n\t\td = llmMaxDelay\n\t}\n\treturn d/2 + time.Duration(rand.Int63n(int64(d/2)+1))\n}\n\n// streamTurn performs one attempt at an LLM round trip: issue the\n// request and read the stream to completion, firing hooks as content\n// arrives.\nfunc streamTurn(ctx context.Context, client *llm.Client, messages []llm.Message, hooks Hooks) (*llm.ChatCompletion, error) {\n\tstreamer, err := client.StreamChatCompletion(ctx, &llm.ChatCompletionRequest{\n\t\tMessages: messages,\n\t\tStream:   true,\n\t\tTools:    tools.All(),\n\t})\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"chat completion: %w\", err)\n\t}\n\n\tvar completion *llm.ChatCompletion\n\n\tvar prevContent, prevReasoning string\n\n\tfor {\n\t\tc, err := streamer.Get()\n\t\tif err == io.EOF {\n\t\t\tbreak\n\t\t}\n\n\t\tif err != nil {\n\t\t\treturn nil, fmt.Errorf(\"stream completion: %w\", err)\n\t\t}\n\n\t\tcompletion = c\n\n\t\tif len(c.Choices) > 0 {\n\t\t\tmsg := c.Choices[0].Message\n\n\t\t\tif hooks.OnReasoningDelta != nil && len(msg.ReasoningContent) > len(prevReasoning) {\n\t\t\t\thooks.OnReasoningDelta(msg.ReasoningContent[len(prevReasoning):])\n\t\t\t}\n\t\t\tprevReasoning = msg.ReasoningContent\n\n\t\t\tif hooks.OnContentDelta != nil && len(msg.Content) > len(prevContent) {\n\t\t\t\thooks.OnContentDelta(msg.Content[len(prevContent):])\n\t\t\t}\n\t\t\tprevContent = msg.Content\n\t\t}\n\t}\n\n\tif hooks.OnTurnEnd != nil {\n\t\thooks.OnTurnEnd()\n\t}\n\n\tif completion == nil || len(completion.Choices) == 0 {\n\t\treturn nil, fmt.Errorf(\"model returned an empty completion\")\n\t}\n\n\treturn completion, nil\n}\n", "path": "internal/agentrun/loop.go"}

OK

{"find": "\t\tOnTurnEnd: func() {\n\t\t\tif reasoningOpen {\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningEnd})\n\t\t\t\tlogAppend(\"reasoning\", reasoningBuf.String())\n\t\t\t\tr.hub.Checkpoint(jobID)\n\t\t\t\treasoningOpen = false\n\t\t\t}\n\n\t\t\tif contentOpen {\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ContentEnd})\n\t\t\t\tlogAppend(\"content\", contentBuf.String())\n\t\t\t\tr.hub.Checkpoint(jobID)\n\t\t\t\tcontentOpen = false\n\t\t\t}\n\t\t},", "path": "internal/agentrun/run.go", "replace": "\t\tOnTurnEnd: func() {\n\t\t\tif reasoningOpen {\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningEnd})\n\t\t\t\tlogAppend(\"reasoning\", reasoningBuf.String())\n\t\t\t\tr.hub.Checkpoint(jobID)\n\t\t\t\treasoningOpen = false\n\t\t\t}\n\n\t\t\tif contentOpen {\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ContentEnd})\n\t\t\t\tlogAppend(\"content\", contentBuf.String())\n\t\t\t\tr.hub.Checkpoint(jobID)\n\t\t\t\tcontentOpen = false\n\t\t\t}\n\t\t},\n\t\tOnRetry: func(attempt int, delay time.Duration, err error) {\n\t\t\t// Keep a trace of the failure in the job's history, so a\n\t\t\t// run that eventually succeeds (or fails after exhausting\n\t\t\t// the budget) still shows what the endpoint did.\n\t\t\tlogAppend(\"system\", fmt.Sprintf(\"LLM endpoint failure (attempt %d/%d): %s — retrying in %s\",\n\t\t\t\tattempt, llmMaxAttempts, truncateForLog(err.Error(), 200), delay.Round(time.Second)))\n\n\t\t\t// If part of the turn was already streamed, discard it from\n\t\t\t// the live view and the hub's replay buffer: it was never\n\t\t\t// persisted (that happens in OnTurnEnd), and the retried\n\t\t\t// turn regenerates it.\n\t\t\tif reasoningOpen || contentOpen {\n\t\t\t\treasoningOpen, contentOpen = false, false\n\t\t\t\treasoningBuf.Reset()\n\t\t\t\tcontentBuf.Reset()\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.TurnReset})\n\t\t\t\tr.hub.Checkpoint(jobID)\n\t\t\t}\n\t\t},"}

1 occurrences replaced

{"find": "\t\t\tr.hub.Checkpoint(jobID)\n\t\t},\n\t}\n}", "path": "internal/agentrun/run.go", "replace": "\t\t\tr.hub.Checkpoint(jobID)\n\t\t},\n\t}\n}\n\n// truncateForLog caps a log line at n runes, appending an ellipsis when\n// it is cut, so a verbose error cannot balloon a job log row.\nfunc truncateForLog(s string, n int) string {\n\tr := []rune(s)\n\tif len(r) <= n {\n\t\treturn s\n\t}\n\treturn string(r[:n]) + \"…\"\n}"}

1 occurrences replaced

{"end_line": 385, "path": "internal/agentrun/run.go", "start_line": 281}

{"path":"internal/agentrun/run.go","content":"// streamHooks builds the Hooks a single Run passes to runLoop: every\n// delta is published live to the hub for connected dashboard viewers,\n// and once a reasoning/content block or tool call is complete, it's\n// persisted to the store as one row and the hub's replay buffer for\n// jobID is checkpointed — so a viewer connecting from this point on\n// sees it via the persisted history instead of a live replay, and is\n// never shown it twice.\nfunc (r *Runner) streamHooks(jobID string, logAppend func(stream, line string)) Hooks {\n\tvar reasoningBuf, contentBuf strings.Builder\n\n\treasoningOpen, contentOpen := false, false\n\n\treturn Hooks{\n\t\tOnReasoningDelta: func(delta string) {\n\t\t\tif !reasoningOpen {\n\t\t\t\treasoningOpen = true\n\t\t\t\treasoningBuf.Reset()\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningStart})\n\t\t\t}\n\n\t\t\treasoningBuf.WriteString(delta)\n\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningDelta, Text: delta})\n\t\t},\n\t\tOnContentDelta: func(delta string) {\n\t\t\tif !contentOpen {\n\t\t\t\tcontentOpen = true\n\t\t\t\tcontentBuf.Reset()\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ContentStart})\n\t\t\t}\n\n\t\t\tcontentBuf.WriteString(delta)\n\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ContentDelta, Text: delta})\n\t\t},\n\t\tOnTurnEnd: func() {\n\t\t\tif reasoningOpen {\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningEnd})\n\t\t\t\tlogAppend(\"reasoning\", reasoningBuf.String())\n\t\t\t\tr.hub.Checkpoint(jobID)\n\t\t\t\treasoningOpen = false\n\t\t\t}\n\n\t\t\tif contentOpen {\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ContentEnd})\n\t\t\t\tlogAppend(\"content\", contentBuf.String())\n\t\t\t\tr.hub.Checkpoint(jobID)\n\t\t\t\tcontentOpen = false\n\t\t\t}\n\t\t},\n\t\tOnRetry: func(attempt int, delay time.Duration, err error) {\n\t\t\t// Keep a trace of the failure in the job's history, so a\n\t\t\t// run that eventually succeeds (or fails after exhausting\n\t\t\t// the budget) still shows what the endpoint did.\n\t\t\tlogAppend(\"system\", fmt.Sprintf(\"LLM endpoint failure (attempt %d/%d): %s — retrying in %s\",\n\t\t\t\tattempt, llmMaxAttempts, truncateForLog(err.Error(), 200), delay.Round(time.Second)))\n\n\t\t\t// If part of the turn was already streamed, discard it from\n\t\t\t// the live view and the hub's replay buffer: it was never\n\t\t\t// persisted (that happens in OnTurnEnd), and the retried\n\t\t\t// turn regenerates it.\n\t\t\tif reasoningOpen || contentOpen {\n\t\t\t\treasoningOpen, contentOpen = false, false\n\t\t\t\treasoningBuf.Reset()\n\t\t\t\tcontentBuf.Reset()\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.TurnReset})\n\t\t\t\tr.hub.Checkpoint(jobID)\n\t\t\t}\n\t\t},\n\t\tOnTool: func(name, arguments, result string, toolErr bool) {\n\t\t\tr.hub.Publish(jobID, livelog.Event{\n\t\t\t\tType:      livelog.Tool,\n\t\t\t\tName:      name,\n\t\t\t\tArguments: arguments,\n\t\t\t\tResult:    result,\n\t\t\t\tError:     toolErr,\n\t\t\t})\n\n\t\t\tline, err := json.Marshal(store.ToolLogEntry{Name: name, Arguments: arguments, Result: result, Error: toolErr})\n\t\t\tif err != nil {\n\t\t\t\tr.logger.Warn(\"failed to marshal tool log entry\", \"job\", jobID, \"error\", err)\n\t\t\t} else {\n\t\t\t\tlogAppend(\"tool\", string(line))\n\t\t\t}\n\n\t\t\tr.hub.Checkpoint(jobID)\n\t\t},\n\t}\n}\n\n// truncateForLog caps a log line at n runes, appending an ellipsis when\n// it is cut, so a verbose error cannot balloon a job log row.\nfunc truncateForLog(s string, n int) string {\n\tr := []rune(s)\n\tif len(r) \u003c= n {\n\t\treturn s\n\t}\n\treturn string(r[:n]) + \"…\"\n}\n\nfunc seedMessage(ev forgejo.Event, branch, defaultBranch, instructions string, comments []forgejo.IssueComment, review *forgejo.ReviewDetail) string {\n\traw, _ := json.MarshalIndent(json.RawMessage(ev.Raw), \"\", \"  \")\n\n\tvar instructionsSection string\n\tif instructions != \"\" {\n\t\tinstructionsSection = fmt.Sprintf(\"Instructions for this event, from zoo.hcl:\\n%s\\n\\n\", instructions)\n\t}","start_line":281,"end_line":385,"total_lines":466,"truncated":true}

{"find": "          case \"tool\":\n            newToolBlock(ev);\n            break;\n          case \"status\":", "path": "internal/web/templates.go", "replace": "          case \"tool\":\n            newToolBlock(ev);\n            break;\n          case \"turn_reset\":\n            // The turn's stream broke and is being retried; drop the\n            // partial block so the retried turn starts clean.\n            if (reasoningBody) { reasoningBody.parentElement.remove(); reasoningBody = null; }\n            if (contentBody) { contentBody.parentElement.remove(); contentBody = null; }\n            break;\n          case \"status\":"}

1 occurrences replaced

{"end_line": 22, "path": "internal/livelog/hub.go", "start_line": 11}

{"path":"internal/livelog/hub.go","content":"\nconst (\n\tReasoningStart Type = \"reasoning_start\"\n\tReasoningDelta Type = \"reasoning_delta\"\n\tReasoningEnd   Type = \"reasoning_end\"\n\tContentStart   Type = \"content_start\"\n\tContentDelta   Type = \"content_delta\"\n\tContentEnd     Type = \"content_end\"\n\tTool           Type = \"tool\"\n\tStatus         Type = \"status\"\n)\n","start_line":11,"end_line":22,"total_lines":164,"truncated":true}

{"find": "\tTool           Type = \"tool\"\n\tStatus         Type = \"status\"\n)", "path": "internal/livelog/hub.go", "replace": "\tTool           Type = \"tool\"\n\tStatus         Type = \"status\"\n\n\t// TurnReset tells live viewers that a turn's stream broke and is\n\t// being retried: any partial reasoning/content block on screen\n\t// belongs to the failed attempt and should be dropped.\n\tTurnReset Type = \"turn_reset\"\n)"}

1 occurrences replaced

{"command": "cd /project && go build ./... && go vet ./..."}

go: downloading github.com/docker/docker v28.5.2+incompatible
go: downloading github.com/hashicorp/hcl/v2 v2.24.0
go: downloading codeberg.org/mvdkleijn/forgejo-sdk/forgejo/v2 v2.2.0
go: downloading github.com/google/uuid v1.6.0
go: downloading modernc.org/sqlite v1.56.0
go: downloading github.com/docker/go-connections v0.8.1
go: downloading github.com/docker/go-units v0.5.0
go: downloading github.com/moby/docker-image-spec v1.3.1
go: downloading github.com/opencontainers/image-spec v1.1.1
go: downloading github.com/containerd/errdefs v1.0.0
go: downloading github.com/containerd/errdefs/pkg v0.3.0
go: downloading github.com/distribution/reference v0.6.0
go: downloading github.com/opencontainers/go-digest v1.0.0
go: downloading github.com/pkg/errors v0.9.1
go: downloading go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0
go: downloading go.opentelemetry.io/otel/trace v1.45.0
go: downloading go.opentelemetry.io/otel v1.45.0
go: downloading github.com/42wim/httpsig v1.2.3
go: downloading github.com/go-fed/httpsig v1.1.0
go: downloading github.com/hashicorp/go-version v1.7.0
go: downloading golang.org/x/crypto v0.39.0
go: downloading github.com/felixge/httpsnoop v1.1.0
go: downloading go.opentelemetry.io/otel/metric v1.45.0
go: downloading github.com/agext/levenshtein v1.2.1
go: downloading github.com/apparentlymart/go-textseg/v15 v15.0.0
go: downloading github.com/mitchellh/go-wordwrap v1.0.1
go: downloading github.com/zclconf/go-cty v1.16.3
go: downloading github.com/go-logr/logr v1.4.4
go: downloading github.com/google/go-cmp v0.7.0
go: downloading golang.org/x/sys v0.47.0
go: downloading github.com/go-logr/stdr v1.2.2
go: downloading go.opentelemetry.io/auto/sdk v1.2.1
go: downloading github.com/cespare/xxhash/v2 v2.3.0
go: downloading golang.org/x/text v0.40.0
go: downloading modernc.org/libc v1.74.4
go: downloading github.com/dustin/go-humanize v1.0.1
go: downloading modernc.org/mathutil v1.7.1
go: downloading modernc.org/memory v1.11.0
go: downloading github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec