Job 921e917e-04b8-468b-aecc-79c4e260ab87

{"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 -10 && git status"}

f58963a Merge pull request 'Jobs page: follow the live log tail, with a jump-to-bottom button' (#58) from issue-57-greg into main
0b5138d Merge pull request 'tools: drop the PTY from docker exec, keep stdout/stderr separate' (#54) from issue-52-greg into main
c91b25a More correct tool schema.
f4da8cd Jobs page: follow the live log tail, with a jump-to-bottom button
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
4ff7ec5 tools: drop the PTY from docker exec, keep stdout/stderr separate
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":100,"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","start_line":1,"end_line":100,"total_lines":118,"truncated":true}

{"end_line":100,"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":118,"path":"internal/agentrun/loop.go","start_line":100}

{"path":"internal/agentrun/loop.go","content":"\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":100,"end_line":118,"total_lines":118,"truncated":false}

{"end_line":100,"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":100,"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 {","start_line":1,"end_line":100,"total_lines":246,"truncated":true}

{"end_line":100,"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","start_line":1,"end_line":100,"total_lines":437,"truncated":true}

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

{"path":"internal/agentrun/run.go","content":"\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":100,"end_line":250,"total_lines":437,"truncated":true}

{"end_line":246,"path":"internal/config/config.go","start_line":100}

{"path":"internal/config/config.go","content":"func (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 {\n\t\t\treturn AgentConfig{\n\t\t\t\tName:  a.Name,\n\t\t\t\tLLM:   a.LLM,\n\t\t\t\tToken: a.Token,\n\t\t\t}, true\n\t\t}\n\t}\n\n\treturn AgentConfig{}, false\n}\n\n// LLMByName returns the llm config with the given name, if declared.\nfunc (c *Config) LLMByName(name string) (LLM, bool) {\n\tfor _, l := range c.LLMs {\n\t\tif l.Name == name {\n\t\t\treturn l, true\n\t\t}\n\t}\n\n\treturn LLM{}, false\n}\n\n// EventAgent returns the statically configured agent name for the given\n// event kind, if one is declared and set.\nfunc (c *Config) EventAgent(kind string) (string, bool) {\n\tfor _, e := range c.Events {\n\t\tif e.Kind == kind {\n\t\t\treturn e.Agent, e.Agent != \"\"\n\t\t}\n\t}\n\n\treturn \"\", false\n}\n\n// EventInstructions returns the configured freeform instructions for the\n// given event kind, e.g. \"Please review this pull request and respond\n// appropriately.\" Returns \"\" if the event isn't declared or has none.\nfunc (c *Config) EventInstructions(kind string) string {\n\tfor _, e := range c.Events {\n\t\tif e.Kind == kind {\n\t\t\treturn e.Instructions\n\t\t}\n\t}\n\n\treturn \"\"\n}","start_line":100,"end_line":246,"total_lines":246,"truncated":false}

{"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":100,"path":"zoo.hcl.example","start_line":1}

{"path":"zoo.hcl.example","content":"# zoo.hcl - Configuration for the zoo daemon.\n#\n# Copy this file to zoo.hcl (gitignored) and fill in real values.\n\nllm \"Qwen 3.6\" {\n    openai = \"https://code.stdio.dk\"\n    token  = \"TOKEN\"\n    model  = \"Qwen3.6\"\n}\n\nllm \"Qwen 3.8\" {\n    openai = \"https://code.stdio.dk\"\n    token  = \"TOKEN\"\n    model  = \"Qwen3.8\"\n}\n\nforgejo {\n    url            = \"https://code.stdio.dk\"\n    token          = \"ZOO_SERVICE_TOKEN\"\n    # Shared secret configured on the Forgejo webhook. Required to accept\n    # webhook deliveries; polling works without it.\n    webhook_secret = \"EXAMPLE_WEBHOOK_SECRET\"\n\n    # Which repositories to watch. Events from every other repository\n    # are ignored. Each entry is an \"owner/repo\" pair with glob\n    # wildcards:\n    #\n    #   repos = [\"acme/*\"]          # everything in the acme org\n    #   repos = [\"acme/widgets\"]    # just that one repository\n    #   repos = [\"acme/web*\"]       # repos in acme whose name starts with \"web\"\n    #   repos = [\"acme\", \"bob\"]     # bare names mean \"everything in that org\"\n    #   repos = [\"*\"]               # everything on the instance\n    #\n    # Owner names match case-insensitively (like Forgejo usernames);\n    # repository names match case-sensitively. Leave the list out (or\n    # empty) to watch everything the token can see.\n    # repos = [\"abrander/*\", \"acme/widgets\"]\n}\n\nenvironment {\n    docker_image   = \"golang:latest\"\n    max_live_agents = 5\n}\n\nagent \"anna\" {\n    llm   = \"Qwen 3.6\"\n    token = \"ANNA_FORGEJO_TOKEN\"\n}\n\nagent \"greg\" {\n    llm   = \"Qwen 3.8\"\n    token = \"GREG_FORGEJO_TOKEN\"\n}\n\n# \"leon\" doubles as the expected Forgejo assignee username for\n# issue:assigned events - see the event block below.\nagent \"leon\" {\n    llm   = \"Qwen 3.8\"\n    token = \"LEON_FORGEJO_TOKEN\"\n}\n\nagent \"mika\" {\n    llm   = \"Qwen 3.6\"\n    token = \"MIKA_FORGEJO_TOKEN\"\n}\n\nevent \"issue:new\" {\n    agent = \"leon\"\n}\n\nevent \"issue:assigned\" {\n    // No `agent` here: the agent whose name matches the Forgejo\n    // assignee's username is triggered.\n    instructions = \"Please handle this issue.\"\n}\n\nevent \"issue:comment\" {\n    agent        = \"leon\"\n    instructions = \"Please review what this comment says and respond appropriately.\"\n}\n\nevent \"pr:new\" {\n    agent        = \"greg\"\n    instructions = \"Please review this pull request and respond appropriately.\"\n}\n\n# A review was submitted on a pull request (approved, changes requested,\n# or comment). The agent that opened the PR is triggered to handle it,\n# like issue:assigned: its working tree is checked out on the PR's head\n# branch, so changes it pushes update the PR directly. It should address\n# the feedback and reply to the review with a summary of what it\n# addressed. (Forgejo has no API to mark review comments resolved, so\n# that stays with the reviewer.)\nevent \"pr:review\" {\n    // No `agent` here: the agent whose name matches the pull request\n    // author's username is triggered.\n    instructions = \"A review was submitted on this pull request. Address the feedback, push your changes to the PR branch, and reply to the review with a summary of what you addressed.\"\n}","start_line":1,"end_line":98,"total_lines":98,"truncated":false}

{"end_line":120,"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\"` // always \"object\"\n\tProperties map[string]Property `json:\"properties\"`\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{","start_line":1,"end_line":120,"total_lines":276,"truncated":true}

{"end_line":120,"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","start_line":1,"end_line":120,"total_lines":164,"truncated":true}

{"query":"livelog.Status|Status:"}

/project/internal/web/web.go:343:			if ev.Type == livelog.Status {
/project/internal/livelog/hub.go:145:	h.Publish(jobID, Event{Type: Status, Status: "done"})
/project/internal/llm/streamer.go:23:		return nil, fmt.Errorf("status: %d: %s", resp.StatusCode, body)

{"end_line":276,"path":"internal/llm/types.go","start_line":120}

{"path":"internal/llm/types.go","content":"\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\t// Servers validate parameters against the JSON Schema\n\t\t\t// metaschema, which rejects a missing or empty type,\n\t\t\t// and an object schema without properties.\n\t\t\tParameters: Parameters{\n\t\t\t\tType:       \"object\",\n\t\t\t\tProperties: map[string]Property{},\n\t\t\t},\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}\n\n\tif _, 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 != \"\" {\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":120,"end_line":276,"total_lines":276,"truncated":false}

{"end_line":380,"path":"internal/web/web.go","start_line":300}

{"path":"internal/web/web.go","content":"\tw.Header().Set(\"Content-Type\", \"text/event-stream\")\n\tw.Header().Set(\"Cache-Control\", \"no-cache\")\n\tw.Header().Set(\"Connection\", \"keep-alive\")\n\tw.WriteHeader(http.StatusOK)\n\n\tbuffered, ch, cancel := s.hub.Subscribe(id)\n\tdefer cancel()\n\n\twrite := func(ev livelog.Event) bool {\n\t\tdata, err := json.Marshal(ev)\n\t\tif err != nil {\n\t\t\treturn true\n\t\t}\n\n\t\tif _, err := fmt.Fprintf(w, \"data: %s\\n\\n\", data); err != nil {\n\t\t\treturn false\n\t\t}\n\n\t\tflusher.Flush()\n\n\t\treturn true\n\t}\n\n\tfor _, ev := range buffered {\n\t\tif !write(ev) {\n\t\t\treturn\n\t\t}\n\t}\n\n\theartbeat := time.NewTicker(15 * time.Second)\n\tdefer heartbeat.Stop()\n\n\tfor {\n\t\tselect {\n\t\tcase ev, ok := \u003c-ch:\n\t\t\tif !ok {\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\tif !write(ev) {\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\tif ev.Type == livelog.Status {\n\t\t\t\treturn\n\t\t\t}\n\n\t\tcase \u003c-heartbeat.C:\n\t\t\tif _, err := fmt.Fprint(w, \": heartbeat\\n\\n\"); err != nil {\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\tflusher.Flush()\n\n\t\tcase \u003c-r.Context().Done():\n\t\t\treturn\n\t\t}\n\t}\n}\n\nfunc (s *Server) render(w http.ResponseWriter, name string, data any) {\n\tw.Header().Set(\"Content-Type\", \"text/html; charset=utf-8\")\n\n\t// Every page here reflects live, fast-changing state (job status, log\n\t// blocks). Without this, browsers are free to serve a stale cached\n\t// copy of the job detail page on a same-URL navigation — including\n\t// the auto location.reload() a job's SSE stream triggers when it\n\t// finishes — which looks exactly like blocks that were visible while\n\t// streaming vanishing once the page reloads.\n\tw.Header().Set(\"Cache-Control\", \"no-store\")\n\n\tif err := s.tmpl.ExecuteTemplate(w, name, data); err != nil {\n\t\thttp.Error(w, err.Error(), http.StatusInternalServerError)\n\t}\n}","start_line":300,"end_line":374,"total_lines":374,"truncated":false}

{"end_line":80,"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) {","start_line":1,"end_line":80,"total_lines":132,"truncated":true}

{"context_after":6,"query":"status"}

/project/cmd/zoo/main.go:91:		w.WriteHeader(http.StatusOK)
/project/cmd/zoo/main.go-92-		w.Write([]byte("ok"))
/project/cmd/zoo/main.go-93-	})
/project/cmd/zoo/main.go-94-
/project/cmd/zoo/main.go-95-	mux.Handle("/", dashboard.Handler())
/project/cmd/zoo/main.go-96-
/project/cmd/zoo/main.go-97-	server := &http.Server{Addr: *listen, Handler: mux}
--
/project/.git/hooks/commit-msg.sample:6:# status after issuing an appropriate message if it wants to stop the
/project/.git/hooks/commit-msg.sample-7-# commit.  The hook is allowed to edit the commit message file.
/project/.git/hooks/commit-msg.sample-8-#
/project/.git/hooks/commit-msg.sample-9-# To enable this hook, rename this file to "commit-msg".
/project/.git/hooks/commit-msg.sample-10-
/project/.git/hooks/commit-msg.sample-11-# Uncomment the below to add a Signed-off-by line to the message.
/project/.git/hooks/commit-msg.sample-12-# Doing this in a hook is a bad idea in general, but the prepare-commit-msg
--
/project/.git/hooks/push-to-checkout.sample:23:# It can exit with a non-zero status to refuse the push (when it does
/project/.git/hooks/push-to-checkout.sample-24-# so, it must not modify the index or the working tree).
/project/.git/hooks/push-to-checkout.sample-25-die () {
/project/.git/hooks/push-to-checkout.sample-26-	echo >&2 "$*"
/project/.git/hooks/push-to-checkout.sample-27-	exit 1
/project/.git/hooks/push-to-checkout.sample-28-}
/project/.git/hooks/push-to-checkout.sample-29-
--
/project/.git/hooks/push-to-checkout.sample:32:# branch is updated to the new commit, and exit with a zero status.
/project/.git/hooks/push-to-checkout.sample-33-#
/project/.git/hooks/push-to-checkout.sample-34-# For example, the hook can simply run git read-tree -u -m HEAD "$1"
/project/.git/hooks/push-to-checkout.sample-35-# in order to emulate git fetch that is run in the reverse direction
/project/.git/hooks/push-to-checkout.sample-36-# with git push, as the two-tree form of git read-tree -u -m is
/project/.git/hooks/push-to-checkout.sample-37-# essentially the same as git switch or git checkout that switches
/project/.git/hooks/push-to-checkout.sample-38-# branches while keeping the local changes in the working tree that do
--
/project/.git/hooks/pre-applypatch.sample:6:# The hook should exit with non-zero status after issuing an
/project/.git/hooks/pre-applypatch.sample-7-# appropriate message if it wants to stop the commit.
/project/.git/hooks/pre-applypatch.sample-8-#
/project/.git/hooks/pre-applypatch.sample-9-# To enable this hook, rename this file to "pre-applypatch".
/project/.git/hooks/pre-applypatch.sample-10-
/project/.git/hooks/pre-applypatch.sample-11-. git-sh-setup
/project/.git/hooks/pre-applypatch.sample-12-precommit="$(git rev-parse --git-path hooks/pre-commit)"
--
/project/.git/hooks/pre-rebase.sample:7:# non-zero status.
/project/.git/hooks/pre-rebase.sample-8-#
/project/.git/hooks/pre-rebase.sample-9-# The hook is called with the following parameters:
/project/.git/hooks/pre-rebase.sample-10-#
/project/.git/hooks/pre-rebase.sample-11-# $1 -- the upstream the series was forked from.
/project/.git/hooks/pre-rebase.sample-12-# $2 -- the branch being rebased (or empty when rebasing the current branch).
/project/.git/hooks/pre-rebase.sample-13-#
--
/project/.git/hooks/pre-commit.sample:5:# exit with non-zero status after issuing an appropriate message if
/project/.git/hooks/pre-commit.sample-6-# it wants to stop the commit.
/project/.git/hooks/pre-commit.sample-7-#
/project/.git/hooks/pre-commit.sample-8-# To enable this hook, rename this file to "pre-commit".
/project/.git/hooks/pre-commit.sample-9-
/project/.git/hooks/pre-commit.sample-10-if git rev-parse --verify HEAD >/dev/null 2>&1
/project/.git/hooks/pre-commit.sample-11-then
--
/project/.git/hooks/pre-merge-commit.sample:5:# exit with non-zero status after issuing an appropriate message to
/project/.git/hooks/pre-merge-commit.sample-6-# stderr if it wants to stop the merge commit.
/project/.git/hooks/pre-merge-commit.sample-7-#
/project/.git/hooks/pre-merge-commit.sample-8-# To enable this hook, rename this file to "pre-merge-commit".
/project/.git/hooks/pre-merge-commit.sample-9-
/project/.git/hooks/pre-merge-commit.sample-10-. git-sh-setup
/project/.git/hooks/pre-merge-commit.sample-11-test -x "$GIT_DIR/hooks/pre-commit" &&
--
/project/.git/hooks/prepare-commit-msg.sample:7:# message file.  If the hook fails with a non-zero status,
/project/.git/hooks/prepare-commit-msg.sample-8-# the commit is aborted.
/project/.git/hooks/prepare-commit-msg.sample-9-#
/project/.git/hooks/prepare-commit-msg.sample-10-# To enable this hook, rename this file to "prepare-commit-msg".
/project/.git/hooks/prepare-commit-msg.sample-11-
/project/.git/hooks/prepare-commit-msg.sample-12-# This hook includes three examples. The first one removes the
/project/.git/hooks/prepare-commit-msg.sample-13-# "# Please enter the commit message..." help message.
--
/project/.git/hooks/prepare-commit-msg.sample:15:# The second includes the output of "git diff --name-status -r"
/project/.git/hooks/prepare-commit-msg.sample:16:# into the message, just before the "git status" output.  It is
/project/.git/hooks/prepare-commit-msg.sample-17-# commented because it doesn't cope with --amend or with squashed
/project/.git/hooks/prepare-commit-msg.sample-18-# commits.
/project/.git/hooks/prepare-commit-msg.sample-19-#
/project/.git/hooks/prepare-commit-msg.sample-20-# The third example adds a Signed-off-by line to the message, that can
/project/.git/hooks/prepare-commit-msg.sample-21-# still be edited.  This is rarely a good idea.
/project/.git/hooks/prepare-commit-msg.sample-22-
--
/project/.git/hooks/prepare-commit-msg.sample:32:#       print "\n" . `git diff --cached --name-status -r`
/project/.git/hooks/prepare-commit-msg.sample-33-# 	 if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;;
/project/.git/hooks/prepare-commit-msg.sample-34-#  *) ;;
/project/.git/hooks/prepare-commit-msg.sample-35-# esac
/project/.git/hooks/prepare-commit-msg.sample-36-
/project/.git/hooks/prepare-commit-msg.sample-37-# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
/project/.git/hooks/prepare-commit-msg.sample-38-# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE"
--
/project/.git/hooks/sendemail-validate.sample:6:# The hook should exit with non-zero status after issuing an appropriate
/project/.git/hooks/sendemail-validate.sample-7-# message if it wants to prevent the email(s) from being sent.
/project/.git/hooks/sendemail-validate.sample-8-#
/project/.git/hooks/sendemail-validate.sample-9-# To enable this hook, rename this file to "sendemail-validate".
/project/.git/hooks/sendemail-validate.sample-10-#
/project/.git/hooks/sendemail-validate.sample-11-# By default, it will only check that the patch(es) can be applied on top of
/project/.git/hooks/sendemail-validate.sample-12-# the default upstream branch without conflicts in a secondary worktree. After
--
/project/.git/hooks/pre-push.sample:4:# push" after it has checked the remote status, but before anything has been
/project/.git/hooks/pre-push.sample:5:# pushed.  If this script exits with a non-zero status nothing will be pushed.
/project/.git/hooks/pre-push.sample-6-#

{"glob":"*.go","query":"livelog\\.Status|Status:"}

/project/internal/web/web.go:343:			if ev.Type == livelog.Status {
/project/internal/livelog/hub.go:145:	h.Publish(jobID, Event{Type: Status, Status: "done"})
/project/internal/llm/streamer.go:23:		return nil, fmt.Errorf("status: %d: %s", resp.StatusCode, body)

{"end_line":80,"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 {","start_line":1,"end_line":80,"total_lines":252,"truncated":true}

{"context_after":10,"context_before":3,"glob":"internal/web/templates.go","query":"status"}

No matches found.

{"end_line":252,"path":"internal/scheduler/scheduler.go","start_line":80}

{"path":"internal/scheduler/scheduler.go","content":"\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 {\n\t\ts.logger.Debug(\"dropping event authored by the agent it would trigger\", \"kind\", ev.Kind, \"agent\", agentName, \"owner\", ev.Owner, \"repo\", ev.Repo, \"index\", ev.Index)\n\t\treturn\n\t}\n\n\tagent, ok := s.cfg.AgentByName(agentName)\n\tif !ok {\n\t\ts.logger.Error(\"resolved agent not declared in config\", \"agent\", agentName)\n\t\treturn\n\t}\n\n\tllm, ok := s.cfg.LLMByName(agent.LLM)\n\tif !ok {\n\t\ts.logger.Error(\"agent references undeclared llm\", \"agent\", agentName, \"llm\", agent.LLM)\n\t\treturn\n\t}\n\n\tjobID := uuid.NewString()\n\n\tif err := s.store.CreateJob(ctx, store.Job{\n\t\tID:         jobID,\n\t\tEventKind:  ev.Kind,\n\t\tAgent:      agentName,\n\t\tOwner:      ev.Owner,\n\t\tRepo:       ev.Repo,\n\t\tIssueIndex: ev.Index,\n\t\tTitle:      ev.Title,\n\t}); err != nil {\n\t\ts.logger.Error(\"failed to record job\", \"job\", jobID, \"error\", err)\n\t\treturn\n\t}\n\n\tselect {\n\tcase s.sem \u003c- struct{}{}:\n\n\tcase \u003c-ctx.Done():\n\t\treturn\n\t}\n\n\ts.wg.Add(1)\n\n\tgo func() {\n\t\tdefer s.wg.Done()\n\t\tdefer func() { \u003c-s.sem }()\n\n\t\ts.run(ctx, jobID, agent, llm, ev)\n\t}()\n}\n\nfunc (s *Scheduler) run(ctx context.Context, jobID string, agent config.AgentConfig, llm config.LLM, ev forgejo.Event) {\n\tlogger := s.logger.With(\"job\", jobID, \"agent\", agent.Name, \"event\", ev.Kind, \"owner\", ev.Owner, \"repo\", ev.Repo, \"index\", ev.Index)\n\n\t// Job status writes use a context detached from ctx, not ctx itself:\n\t// ctx is canceled on daemon shutdown to unwind the in-flight run, and\n\t// an already-canceled ctx would make these UPDATEs fail instantly,\n\t// leaving the job stuck at \"running\" forever even though the process\n\t// has exited.\n\tif err := s.store.MarkJobStarted(context.Background(), jobID); err != nil {\n\t\tlogger.Error(\"failed to mark job started\", \"error\", err)\n\t}\n\n\tlogger.Info(\"agent run starting\")\n\n\terr := s.runner.Run(ctx, jobID, agent, llm, s.cfg.Environment.DockerImage, ev)\n\n\tstatus := store.JobSucceeded\n\terrMsg := \"\"\n\n\tif err != nil {\n\t\terrMsg = err.Error()\n\t\t// The daemon-wide ctx passed in here isn't what times a run out\n\t\t// (agentrun.Runner.Run applies its own per-run deadline\n\t\t// internally); a timed-out run surfaces as a wrapped\n\t\t// context.DeadlineExceeded in the returned error instead.\n\t\tif errors.Is(err, context.DeadlineExceeded) {\n\t\t\tstatus = store.JobTimedOut\n\t\t} else {\n\t\t\tstatus = store.JobFailed\n\t\t}\n\n\t\tlogger.Error(\"agent run failed\", \"status\", status, \"error\", err)\n\t\ts.reportFailure(ev, status, err)\n\t} else {\n\t\tlogger.Info(\"agent run succeeded\")\n\t}\n\n\tif err := s.store.MarkJobFinished(context.Background(), jobID, status, errMsg); err != nil {\n\t\tlogger.Error(\"failed to mark job finished\", \"error\", err)\n\t}\n\n\t// Closing the hub here, only after the terminal status is durably\n\t// written, is what lets a dashboard tab's auto-reload (triggered by\n\t// this Close) see the finished status immediately. Closing it inside\n\t// Runner.Run instead — before this status write — raced a fast\n\t// reload against MarkJobFinished: the reloaded page could still see\n\t// \"running\", open a fresh SSE subscription against a hub entry that\n\t// no longer exists, and be stuck showing a stale status forever.\n\ts.hub.Close(jobID)\n}\n\n// reportFailure implements the locked-in failure policy: comment on the\n// triggering issue/PR with an error summary, and apply FailureLabel.\nfunc (s *Scheduler) reportFailure(ev forgejo.Event, status store.JobStatus, runErr error) {\n\tbody := fmt.Sprintf(\"zoo agent run %s: %s\", status, runErr.Error())\n\n\tif err := s.forgejo.CreateIssueComment(ev.Owner, ev.Repo, ev.Index, body); err != nil {\n\t\ts.logger.Error(\"failed to post failure comment\", \"owner\", ev.Owner, \"repo\", ev.Repo, \"index\", ev.Index, \"error\", err)\n\t}\n\n\tif err := s.forgejo.AddLabel(ev.Owner, ev.Repo, ev.Index, FailureLabel); err != nil {\n\t\ts.logger.Error(\"failed to add failure label\", \"owner\", ev.Owner, \"repo\", ev.Repo, \"index\", ev.Index, \"error\", err)\n\t}\n}\n\n// Shutdown stops accepting new work is the caller's responsibility (stop\n// feeding Run's channel); Shutdown just waits for in-flight runs, up to\n// ctx's deadline.\nfunc (s *Scheduler) Shutdown(ctx context.Context) error {\n\tdone := make(chan struct{})\n\n\tgo func() {\n\t\ts.wg.Wait()\n\t\tclose(done)\n\t}()\n\n\tselect {\n\tcase \u003c-done:\n\t\treturn nil\n\n\tcase \u003c-ctx.Done():\n\t\treturn ctx.Err()\n\t}\n}","start_line":80,"end_line":252,"total_lines":252,"truncated":false}

{"end_line":164,"path":"internal/livelog/hub.go","start_line":120}

{"path":"internal/livelog/hub.go","content":"\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()\n\n\tif !ok {\n\t\treturn\n\t}\n\n\ts.mu.Lock()\n\tdefer s.mu.Unlock()\n\n\tfor ch := range s.subs {\n\t\tclose(ch)\n\t}\n\n\ts.subs = nil\n}","start_line":120,"end_line":164,"total_lines":164,"truncated":false}

{"context_after":15,"glob":"internal/web/templates.go","query":"reasoning_delta"}

No matches found.

{"context_after":30,"glob":"internal/web/templates.go","query":"EventSource"}

No matches found.

{"context_after":40,"glob":"internal/web/templates.go","query":"addEventListener|fetchEventSource|/sse|/events"}

No matches found.

{"glob":"internal/web/*.go","query":"HandleFunc|mux\\.|PathValue|route"}

No matches found.

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

{"path":"internal/web/web.go","content":"// Package web is zoo's minimal server-rendered dashboard: config\n// overview, live queue/history, and a per-job log tail.\npackage web\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"html/template\"\n\t\"net/http\"\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/store\"\n)\n\ntype Server struct {\n\tcfg   *config.Config\n\tstore *store.Store\n\thub   *livelog.Hub\n\tfg    *forgejo.Client\n\ttmpl  *template.Template\n\n\tavatarMu    sync.Mutex\n\tavatarCache map[string]avatarCacheEntry\n}\n\n// avatarCacheTTL bounds how long a resolved avatar URL is trusted before\n// it's re-fetched from Forgejo. Avatars rarely change, but a user can\n// re-upload one (which changes its URL), so the cache expires instead of\n// living for the process lifetime.\nconst avatarCacheTTL = time.Hour\n\ntype avatarCacheEntry struct {\n\turl       string\n\tfetchedAt time.Time\n}\n\nfunc New(cfg *config.Config, st *store.Store, hub *livelog.Hub, fg *forgejo.Client) *Server {\n\treturn \u0026Server{\n\t\tcfg:         cfg,\n\t\tstore:       st,\n\t\thub:         hub,\n\t\tfg:          fg,\n\t\ttmpl:        template.Must(template.New(\"\").Parse(templates)),\n\t\tavatarCache: map[string]avatarCacheEntry{},\n\t}\n}\n\n// Handler returns the dashboard's http.Handler, gated by config.Web's\n// bearer token if one is set.\nfunc (s *Server) Handler() http.Handler {\n\tmux := http.NewServeMux()\n\n\tmux.HandleFunc(\"GET /{$}\", s.handleIndex)\n\tmux.HandleFunc(\"GET /jobs\", s.handleJobs)\n\tmux.HandleFunc(\"GET /jobs/{id}\", s.handleJobDetail)\n\tmux.HandleFunc(\"GET /jobs/{id}/events\", s.handleJobEvents)\n\n\treturn s.authMiddleware(mux)\n}\n\nfunc (s *Server) authMiddleware(next http.Handler) http.Handler {\n\tif s.cfg.Web == nil || s.cfg.Web.Token == \"\" {\n\t\treturn next\n\t}\n\n\ttoken := s.cfg.Web.Token\n\n\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\tauth := r.Header.Get(\"Authorization\")\n\t\tif auth != \"Bearer \"+token {\n\t\t\tw.Header().Set(\"WWW-Authenticate\", `Bearer realm=\"zoo\"`)\n\t\t\thttp.Error(w, \"unauthorized\", http.StatusUnauthorized)\n\n\t\t\treturn\n\t\t}\n\n\t\tnext.ServeHTTP(w, r)\n\t})\n}\n\nfunc (s *Server) handleIndex(w http.ResponseWriter, r *http.Request) {\n\t// Fetch active (pending or running) jobs for the dashboard overview.\n\t// We fetch more than we display so we can filter to just active ones.\n\tallJobs, err := s.store.ListJobs(r.Context(), 200)\n\tif err != nil {\n\t\thttp.Error(w, err.Error(), http.StatusInternalServerError)\n\t\treturn\n\t}\n\n\t// Collect unique agent names from active jobs.\n\tvar agentNames []string\n\tseenAgents := make(map[string]bool)\n\n\tvar activeJobs []activeJobRow\n\tfor _, j := range allJobs {\n\t\tif j.Status != store.JobPending \u0026\u0026 j.Status != store.JobRunning {\n\t\t\tcontinue\n\t\t}\n\t\tif !seenAgents[j.Agent] {\n\t\t\tseenAgents[j.Agent] = true\n\t\t\tagentNames = append(agentNames, j.Agent)\n\t\t}\n\t\tactiveJobs = append(activeJobs, activeJobRow{\n\t\t\tJob:       j,\n\t\t\tAvatarURL: s.avatarFor(j.Agent),\n\t\t})\n\t}\n\n\ttype indexData struct {\n\t\t*config.Config\n\t\tActiveJobs []activeJobRow\n\t}\n\n\ts.render(w, \"index\", indexData{\n\t\tConfig:     s.cfg,","start_line":1,"end_line":120,"total_lines":374,"truncated":true}

{"context_after":40,"glob":"internal/web/templates.go","query":"delta"}

No matches found.

{"context_after":15,"glob":"internal/web/templates.go","query":"events|location\\.reload|setInterval"}

No matches found.

{"command":"cd /project && wc -l internal/web/templates.go && head -50 internal/web/templates.go && grep -n \"script\" internal/web/templates.go | head"}

1073 internal/web/templates.go
package web

const templates = `
{{define "layout_head"}}
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>zoo</title>
<style>
  :root {
    --bg: #0f0f13;
    --bg-surface: #1a1a24;
    --bg-surface-hover: #22222e;
    --bg-code: #12121a;
    --border: #2a2a3a;
    --text: #e4e4e8;
    --text-muted: #8888a0;
    --accent: #7c6aef;
    --accent-glow: rgba(124, 106, 239, 0.15);
    --radius: 12px;
    --radius-sm: 8px;
    --font: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
    --mono: 'JetBrains Mono', 'Fira Code', 'SF Mono', monospace;
  }

  * { margin: 0; padding: 0; box-sizing: border-box; }

  body {
    font-family: var(--font);
    background: var(--bg);
    color: var(--text);
    line-height: 1.6;
    min-height: 100vh;
  }

  /* ── Navigation ─────────────────────────────── */
  nav {
    position: sticky;
    top: 0;
    z-index: 100;
    display: flex;
    align-items: center;
    justify-content: space-between;
    padding: 0 2rem;
    height: 60px;
    background: var(--bg-surface);
    border-bottom: 1px solid var(--border);
    backdrop-filter: blur(12px);
923:  <script>
1067:  </script>

{"end_line":1073,"path":"internal/web/templates.go","start_line":923}

{"path":"internal/web/templates.go","content":"  \u003cscript\u003e\n    (function() {\n      var jobID = {{.Job.ID}};\n      var log = document.getElementById(\"log\");\n      var jumpBtn = document.getElementById(\"log-jump\");\n      var reasoningBody = null;\n      var contentBody = null;\n\n      // The log box (not the window) is what scrolls, so all scroll\n      // math is done against it. While the view is pinned to the\n      // newest output we keep it there as the stream grows; the moment\n      // the user scrolls up to read earlier output we stop, and the\n      // jump button reappears so they can get back to the live tail.\n      var stick = true;\n\n      function atBottom() {\n        return log.scrollHeight - log.scrollTop - log.clientHeight \u003c= 80;\n      }\n\n      function follow() {\n        if (stick) log.scrollTop = log.scrollHeight;\n      }\n\n      log.addEventListener(\"scroll\", function() {\n        stick = atBottom();\n        jumpBtn.hidden = !stick;\n      });\n\n      jumpBtn.addEventListener(\"click\", function() {\n        stick = true;\n        log.scrollTop = log.scrollHeight;\n        jumpBtn.hidden = true;\n      });\n\n      // Opening a live job means spying on its tail: start at the\n      // newest output.\n      follow();\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\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        follow();\n      };\n    })();\n  \u003c/script\u003e\n  {{end}}\n\u003c/div\u003e\n\u003c/body\u003e\n\u003c/html\u003e\n{{end}}\n`","start_line":923,"end_line":1073,"total_lines":1073,"truncated":false}

{"end_line":300,"path":"internal/web/web.go","start_line":120}

{"path":"internal/web/web.go","content":"\t\tConfig:     s.cfg,\n\t\tActiveJobs: activeJobs,\n\t})\n}\n\n// activeJobRow is a store.Job enriched with the agent's avatar URL.\ntype activeJobRow struct {\n\tstore.Job\n\tAvatarURL string\n}\n\n// jobRow is a store.Job plus the agent's Forgejo avatar, resolved for the\n// jobs table so it's immediately clear who is running each job.\ntype jobRow struct {\n\tstore.Job\n\tAvatarURL string\n}\n\nfunc (s *Server) handleJobs(w http.ResponseWriter, r *http.Request) {\n\tjobs, err := s.store.ListJobs(r.Context(), 200)\n\tif err != nil {\n\t\thttp.Error(w, err.Error(), http.StatusInternalServerError)\n\n\t\treturn\n\t}\n\n\trows := make([]jobRow, 0, len(jobs))\n\n\tfor _, j := range jobs {\n\t\trows = append(rows, jobRow{Job: j, AvatarURL: s.avatarFor(j.Agent)})\n\t}\n\n\ts.render(w, \"jobs\", rows)\n}\n\n// avatarFor returns the Forgejo avatar URL of the agent named username,\n// or \"\" if it can't be resolved (no Forgejo client configured, unknown\n// user, API error). The dashboard must never fail to render because of a\n// missing avatar, so every failure mode degrades to no image. Results are\n// cached per username for avatarCacheTTL so a page refresh doesn't turn\n// into one GetUserInfo call per unique agent.\nfunc (s *Server) avatarFor(username string) string {\n\tif s.fg == nil || username == \"\" {\n\t\treturn \"\"\n\t}\n\n\ts.avatarMu.Lock()\n\n\tif e, ok := s.avatarCache[username]; ok \u0026\u0026 time.Since(e.fetchedAt) \u003c avatarCacheTTL {\n\t\ts.avatarMu.Unlock()\n\n\t\treturn e.url\n\t}\n\n\ts.avatarMu.Unlock()\n\n\tprofile, err := s.fg.AgentProfile(username)\n\tif err != nil {\n\t\treturn \"\"\n\t}\n\n\ts.avatarMu.Lock()\n\ts.avatarCache[username] = avatarCacheEntry{url: profile.AvatarURL, fetchedAt: time.Now()}\n\ts.avatarMu.Unlock()\n\n\treturn profile.AvatarURL\n}\n\n// toolBlock is the parsed form of a stream=\"tool\" store.LogLine, for the\n// template to render as a single collapsed detail.\ntype 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\n}\n\nfunc (s *Server) handleJobDetail(w http.ResponseWriter, r *http.Request) {\n\tid := r.PathValue(\"id\")\n\n\tjob, err := s.store.GetJob(r.Context(), id)\n\tif err != nil {\n\t\thttp.Error(w, \"job not found\", http.StatusNotFound)\n\n\t\treturn\n\t}\n\n\tlogs, err := s.store.TailLogs(r.Context(), id, -1)\n\tif err != nil {\n\t\thttp.Error(w, err.Error(), http.StatusInternalServerError)\n\n\t\treturn\n\t}\n\n\ts.render(w, \"job_detail\", struct {\n\t\tJob       store.Job\n\t\tBlocks    []block\n\t\tLive      bool\n\t\tAvatarURL string\n\t}{job, buildBlocks(logs), job.Status == store.JobPending || job.Status == store.JobRunning, s.avatarFor(job.Agent)})\n}\n\n// handleJobEvents streams job jobID's live output as Server-Sent\n// Events. It only ever carries events for the current, not-yet-persisted\n// block (see livelog.Hub.Checkpoint) — everything already written to\n// the store is rendered once, statically, by handleJobDetail. If the\n// job isn't live, the response just ends immediately and the client\n// falls back to the static page.\nfunc (s *Server) handleJobEvents(w http.ResponseWriter, r *http.Request) {\n\tid := r.PathValue(\"id\")\n\n\tjob, err := s.store.GetJob(r.Context(), id)\n\tif err != nil {\n\t\thttp.Error(w, \"job not found\", http.StatusNotFound)\n\n\t\treturn\n\t}\n\n\tif job.Status != store.JobPending \u0026\u0026 job.Status != store.JobRunning {\n\t\treturn\n\t}\n\n\tflusher, ok := w.(http.Flusher)\n\tif !ok {\n\t\thttp.Error(w, \"streaming unsupported\", http.StatusInternalServerError)\n\n\t\treturn\n\t}\n\n\tw.Header().Set(\"Content-Type\", \"text/event-stream\")","start_line":120,"end_line":300,"total_lines":374,"truncated":true}

{"command":"cd /project && cat go.mod && grep -rn \"AppendLog\\|stream\" internal/store/store.go | head -30"}

module github.com/abrander/zoo

go 1.26.4

require (
	codeberg.org/mvdkleijn/forgejo-sdk/forgejo/v2 v2.2.0
	github.com/docker/docker v28.5.2+incompatible
	github.com/google/uuid v1.6.0
	github.com/hashicorp/hcl/v2 v2.24.0
	modernc.org/sqlite v1.56.0
)

require (
	github.com/42wim/httpsig v1.2.3 // indirect
	github.com/Microsoft/go-winio v0.6.2 // indirect
	github.com/agext/levenshtein v1.2.1 // indirect
	github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect
	github.com/cespare/xxhash/v2 v2.3.0 // indirect
	github.com/containerd/errdefs v1.0.0 // indirect
	github.com/containerd/errdefs/pkg v0.3.0 // indirect
	github.com/containerd/log v0.1.0 // indirect
	github.com/davidmz/go-pageant v1.0.2 // indirect
	github.com/distribution/reference v0.6.0 // indirect
	github.com/docker/go-connections v0.8.1 // indirect
	github.com/docker/go-units v0.5.0 // indirect
	github.com/dustin/go-humanize v1.0.1 // indirect
	github.com/felixge/httpsnoop v1.1.0 // indirect
	github.com/go-fed/httpsig v1.1.0 // indirect
	github.com/go-logr/logr v1.4.4 // indirect
	github.com/go-logr/stdr v1.2.2 // indirect
	github.com/google/go-cmp v0.7.0 // indirect
	github.com/hashicorp/go-version v1.7.0 // indirect
	github.com/mattn/go-isatty v0.0.24 // indirect
	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
	github.com/moby/docker-image-spec v1.3.1 // indirect
	github.com/moby/sys/atomicwriter v0.1.0 // indirect
	github.com/moby/term v0.5.2 // indirect
	github.com/morikuni/aec v1.1.0 // indirect
	github.com/ncruces/go-strftime v1.0.0 // indirect
	github.com/opencontainers/go-digest v1.0.0 // indirect
	github.com/opencontainers/image-spec v1.1.1 // indirect
	github.com/pkg/errors v0.9.1 // indirect
	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
	github.com/zclconf/go-cty v1.16.3 // indirect
	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0 // indirect
	go.opentelemetry.io/otel v1.45.0 // indirect
	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.45.0 // indirect
	go.opentelemetry.io/otel/metric v1.45.0 // indirect
	go.opentelemetry.io/otel/trace v1.45.0 // indirect
	golang.org/x/crypto v0.39.0 // indirect
	golang.org/x/mod v0.37.0 // indirect
	golang.org/x/sync v0.22.0 // indirect
	golang.org/x/sys v0.47.0 // indirect
	golang.org/x/text v0.40.0 // indirect
	golang.org/x/time v0.15.0 // indirect
	golang.org/x/tools v0.47.0 // indirect
	gotest.tools/v3 v3.5.2 // indirect
	modernc.org/libc v1.74.4 // indirect
	modernc.org/mathutil v1.7.1 // indirect
	modernc.org/memory v1.11.0 // indirect
)
325:// AppendLog appends one log line for a job, assigning it the next
327:func (s *Store) AppendLog(ctx context.Context, jobID, stream, line string) error {
329:		`INSERT INTO job_logs (job_id, seq, stream, line, ts)
331:		jobID, jobID, stream, line, time.Now().UTC())
342:		`SELECT seq, stream, line, ts FROM job_logs WHERE job_id = ? AND seq > ? ORDER BY seq ASC`,

{"context_after":8,"context_before":2,"glob":"internal/web/templates.go","query":"system"}

No matches found.

{"command":"cd /project && grep -n \"system\\|block-\" internal/web/templates.go | head -40"}

24:    --font: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
459:     children (.block-tool) gives those children an automatic min-height
478:  .block-label {
487:  .block-body {
496:  .block-reasoning,
497:  .block-content {
502:  .block-reasoning {
507:  .block-reasoning .block-body {
512:  .block-content {
517:  .block-system {
524:  .block-tool {
532:  .block-tool summary {
543:  .block-tool summary::-webkit-details-marker { display: none; }
545:  .block-tool summary::before {
554:  .block-tool[open] summary::before { transform: rotate(90deg); }
575:  .block-tool .tool-name {
581:  .block-tool .tool-args-preview {
592:  .block-tool-error { border-left-color: #ef4444; }
593:  .block-tool-error .tool-badge { background: rgba(239, 68, 68, 0.15); color: #ef4444; }
595:  .block-tool .block-body {
600:       .block-body's white-space: pre-wrap — that would render the
606:  .block-tool .tool-section-label {
615:  .block-tool pre {
888:      <div class="block block-reasoning">
889:        <div class="block-label">Thinking</div>
890:        <div class="block-body">{{.Text}}</div>
893:      <div class="block block-content">
894:        <div class="block-body">{{.Text}}</div>
897:      <details class="block block-tool{{if .Tool.Error}} block-tool-error{{end}}">
905:        <div class="block-body">
913:      <div class="block block-system">{{.Text}}</div>
963:        div.className = "block block-" + kind;
966:          l.className = "block-label";
971:        body.className = "block-body";
979:        details.className = "block block-tool" + (ev.error ? " block-tool-error" : "");
1005:        body.className = "block-body";

{"end_line":530,"path":"internal/web/templates.go","start_line":490}

{"path":"internal/web/templates.go","content":"    line-height: 1.6;\n    color: var(--text);\n    white-space: pre-wrap;\n    word-break: break-word;\n  }\n\n  .block-reasoning,\n  .block-content {\n    padding: 0.75rem 1rem;\n    border-radius: var(--radius-sm);\n  }\n\n  .block-reasoning {\n    background: rgba(124, 106, 239, 0.06);\n    border-left: 3px solid var(--accent);\n  }\n\n  .block-reasoning .block-body {\n    color: var(--text-muted);\n    font-style: italic;\n  }\n\n  .block-content {\n    background: var(--bg-surface);\n    border: 1px solid var(--border);\n  }\n\n  .block-system {\n    padding: 0.35rem 0.75rem;\n    color: var(--text-muted);\n    font-family: var(--mono);\n    font-size: 0.8rem;\n  }\n\n  .block-tool {\n    background: rgba(34, 211, 238, 0.06);\n    border: 1px solid var(--border);\n    border-left: 4px solid #22d3ee;\n    border-radius: var(--radius-sm);\n    overflow: hidden;\n  }","start_line":490,"end_line":530,"total_lines":1073,"truncated":true}

{"end_line":922,"path":"internal/web/templates.go","start_line":875}

{"path":"internal/web/templates.go","content":"    {{if .Job.Error}}\n    \u003cdiv class=\"job-meta-item\"\u003e\n      \u003cspan class=\"label\"\u003eError\u003c/span\u003e\n      \u003cspan class=\"value error-text\"\u003e{{.Job.Error}}\u003c/span\u003e\n    \u003c/div\u003e\n    {{end}}\n  \u003c/div\u003e\n\n  \u003ch2\u003eLog\u003c/h2\u003e\n  \u003cdiv class=\"log-wrap\"\u003e\n  \u003cdiv class=\"log-container\" id=\"log\"\u003e\n    {{range .Blocks}}\n      {{if eq .Kind \"reasoning\"}}\n      \u003cdiv class=\"block block-reasoning\"\u003e\n        \u003cdiv class=\"block-label\"\u003eThinking\u003c/div\u003e\n        \u003cdiv class=\"block-body\"\u003e{{.Text}}\u003c/div\u003e\n      \u003c/div\u003e\n      {{else if eq .Kind \"content\"}}\n      \u003cdiv class=\"block block-content\"\u003e\n        \u003cdiv class=\"block-body\"\u003e{{.Text}}\u003c/div\u003e\n      \u003c/div\u003e\n      {{else if eq .Kind \"tool\"}}\n      \u003cdetails class=\"block block-tool{{if .Tool.Error}} block-tool-error{{end}}\"\u003e\n        \u003csummary\u003e\n          \u003cspan class=\"tool-badge\"\u003eTool\u003c/span\u003e\n          \u003cspan class=\"tool-summary-text\"\u003e\n            \u003cspan class=\"tool-name\"\u003e🔧 {{.Tool.Name}}\u003c/span\u003e\n            \u003cspan class=\"tool-args-preview\"\u003e{{.Tool.Arguments}}\u003c/span\u003e\n          \u003c/span\u003e\n        \u003c/summary\u003e\n        \u003cdiv class=\"block-body\"\u003e\n          \u003cdiv class=\"tool-section-label\"\u003eArguments\u003c/div\u003e\n          \u003cpre\u003e{{.Tool.Arguments}}\u003c/pre\u003e\n          \u003cdiv class=\"tool-section-label\"\u003eResult\u003c/div\u003e\n          \u003cpre\u003e{{.Tool.Result}}\u003c/pre\u003e\n        \u003c/div\u003e\n      \u003c/details\u003e\n      {{else}}\n      \u003cdiv class=\"block block-system\"\u003e{{.Text}}\u003c/div\u003e\n      {{end}}\n    {{end}}\n  \u003c/div\u003e\n  {{if .Live}}\n  \u003cbutton type=\"button\" class=\"log-jump\" id=\"log-jump\" hidden\u003e↓ Latest\u003c/button\u003e\n  {{end}}\n  \u003c/div\u003e\n\n  {{if .Live}}","start_line":875,"end_line":922,"total_lines":1073,"truncated":true}

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

{"path":"internal/config/config_test.go","content":"package config\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"testing\"\n)\n\nfunc load(t *testing.T, hcl string) (*Config, error) {\n\tt.Helper()\n\n\tpath := filepath.Join(t.TempDir(), \"zoo.hcl\")\n\tif err := os.WriteFile(path, []byte(hcl), 0o600); err != nil {\n\t\tt.Fatal(err)\n\t}\n\n\treturn Load(path)\n}\n\nconst validConfig = `\nllm \"qwen\" {\n    openai = \"https://example.com\"\n    token  = \"tok\"\n    model  = \"qwen3\"\n}\n\nforgejo {\n    url   = \"https://example.com\"\n    token = \"tok\"\n}\n\nenvironment {\n    docker_image   = \"debian:unstable\"\n    max_live_agents = 2\n}\n\nagent \"leon\" {\n    llm = \"qwen\"\n}\n\nevent \"issue:new\" {\n    agent = \"leon\"\n}\n\nevent \"issue:assigned\" {\n    instructions = \"Please handle this issue.\"\n}\n\nevent \"issue:comment\" {\n    agent = \"leon\"\n    instructions = \"Please review the comment and respond appropriately.\"\n}\n\nevent \"pr:new\" {\n    agent = \"leon\"\n}\n\nevent \"pr:review\" {\n    instructions = \"Address the review feedback and respond.\"\n}\n`\n\nfunc TestLoadValid(t *testing.T) {\n\tcfg, err := load(t, validConfig)\n\tif err != nil {\n\t\tt.Fatalf(\"unexpected error: %v\", err)\n\t}\n\n\tif len(cfg.LLMs) != 1 || cfg.LLMs[0].Name != \"qwen\" {\n\t\tt.Fatalf(\"unexpected llms: %+v\", cfg.LLMs)\n\t}\n\n\tif agent, ok := cfg.EventAgent(EventIssueNew); !ok || agent != \"leon\" {\n\t\tt.Fatalf(\"expected issue:new -\u003e leon, got %q, %v\", agent, ok)\n\t}\n\n\tif _, ok := cfg.EventAgent(EventIssueAssigned); ok {\n\t\tt.Fatalf(\"issue:assigned should have no static agent\")\n\t}\n\n\tif got := cfg.EventInstructions(EventIssueAssigned); got != \"Please handle this issue.\" {\n\t\tt.Fatalf(\"unexpected issue:assigned instructions: %q\", got)\n\t}\n\tif got := cfg.EventInstructions(EventIssueComment); got != \"Please review the comment and respond appropriately.\" {\n\t\tt.Fatalf(\"unexpected issue:comment instructions: %q\", got)\n\t}\n\tif got := cfg.EventInstructions(EventPRNew); got != \"\" {\n\t\tt.Fatalf(\"expected no instructions for pr:new, got %q\", got)\n\t}\n\n\tif _, ok := cfg.EventAgent(EventPRReview); ok {\n\t\tt.Fatalf(\"pr:review should have no static agent\")\n\t}\n\tif got := cfg.EventInstructions(EventPRReview); got != \"Address the review feedback and respond.\" {\n\t\tt.Fatalf(\"unexpected pr:review instructions: %q\", got)\n\t}\n}\n\nfunc TestValidatePRReviewRejectsAgent(t *testing.T) {\n\t_, err := load(t, `\nllm \"qwen\" { openai = \"https://example.com\" token = \"tok\" model = \"qwen3\" }\nforgejo { url = \"https://example.com\" token = \"tok\" }\nenvironment { docker_image = \"debian:unstable\" max_live_agents = 1 }\nagent \"leon\" { llm = \"qwen\" }\nevent \"pr:review\" { agent = \"leon\" }\n`)\n\tif err == nil {\n\t\tt.Fatal(\"expected error: pr:review must not set agent\")\n\t}\n}\n\nfunc TestValidateUndeclaredLLM(t *testing.T) {\n\t_, err := load(t, `\nforgejo { url = \"https://example.com\" token = \"tok\" }\nenvironment { docker_image = \"debian:unstable\" max_live_agents = 1 }\nagent \"leon\" { llm = \"missing\" }\n`)\n\tif err == nil {\n\t\tt.Fatal(\"expected error for undeclared llm reference\")","start_line":1,"end_line":120,"total_lines":241,"truncated":true}

{"command":"cd /tmp/hcltest && cat > main.go <<'EOF'\npackage main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/hashicorp/hcl/v2/hclsimple\"\n)\n\ntype LLM struct {\n\tName    string `hcl:\"name,label\"`\n\tOpenAI  string `hcl:\"openai\"`\n\tRetries *int   `hcl:\"retries,optional\"`\n}\n\ntype Cfg struct {\n\tLLMs []LLM `hcl:\"llm,block\"`\n}\n\nfunc main() {\n\tvar c Cfg\n\terr := hclsimple.Decode(\"zoo.hcl\", []byte(\"llm \\\"a\\\" { openai = \\\"x\\\" }\\nllm \\\"b\\\" { openai = \\\"x\\\" retries = 0 }\\nllm \\\"c\\\" { openai = \\\"x\\\" retries = 3 }\\n\"), nil, &c)\n\tfmt.Printf(\"err: %v\\n\", err)\n\tfor _, l := range c.LLMs {\n\t\tif l.Retries == nil {\n\t\t\tfmt.Printf(\"%s: nil\\n\", l.Name)\n\t\t} else {\n\t\t\tfmt.Printf(\"%s: %d\\n\", l.Name, *l.Retries)\n\t\t}\n\t}\n}\nEOF\ngo run main.go"}

err: zoo.hcl:2,24-31: Invalid single-argument block definition; A single-line block definition must end with a closing brace immediately after its single argument definition.

{"command":"cd /tmp/hcltest && cat > main.go <<'EOF'\npackage main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/hashicorp/hcl/v2/hclsimple\"\n)\n\ntype LLM struct {\n\tName    string `hcl:\"name,label\"`\n\tOpenAI  string `hcl:\"openai\"`\n\tRetries *int   `hcl:\"retries,optional\"`\n}\n\ntype Cfg struct {\n\tLLMs []LLM `hcl:\"llm,block\"`\n}\n\nconst src = `\nllm \"a\" {\n  openai = \"x\"\n}\nllm \"b\" {\n  openai  = \"x\"\n  retries = 0\n}\nllm \"c\" {\n  openai  = \"x\"\n  retries = 3\n}\n`\n\nfunc main() {\n\tvar c Cfg\n\terr := hclsimple.Decode(\"zoo.hcl\", []byte(src), nil, &c)\n\tfmt.Printf(\"err: %v\\n\", err)\n\tfor _, l := range c.LLMs {\n\t\tif l.Retries == nil {\n\t\t\tfmt.Printf(\"%s: nil\\n\", l.Name)\n\t\t} else {\n\t\t\tfmt.Printf(\"%s: %d\\n\", l.Name, *l.Retries)\n\t\t}\n\t}\n}\nEOF\ngo run main.go"}

err: <nil>
a: nil
b: 0
c: 3

{"end_line":60,"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 its stdout and stderr as separate strings. A non-zero\n\t// exit code is an error; the output is still returned so callers\n\t// can surface it.\n\tExec(ctx context.Context, command string) (stdout, stderr string, err 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":45,"total_lines":45,"truncated":false}

{"command":"cd /project && grep -n \"func \" internal/tools/registry.go | head && grep -n \"func Test\" internal/web/web_test.go internal/livelog/hub_test.go internal/agentrun/seed_test.go"}

20:func All() []llm.Tool {
31:// registry is a stateless name->func map shared across concurrent runs;
33:func Register[P any](def llm.Tool, fun toolFunc[P]) {
72:func Call(ctx Context, fcall llm.FunctionCall) (string, error) {
internal/web/web_test.go:39:func TestIndexRenders(t *testing.T) {
internal/web/web_test.go:53:func TestJobsAndDetail(t *testing.T) {
internal/web/web_test.go:112:func TestJobDetailTrimsBlockWhitespace(t *testing.T) {
internal/web/web_test.go:160:func TestJobDetailAutoScroll(t *testing.T) {
internal/web/web_test.go:211:func TestAuthGate(t *testing.T) {
internal/web/web_test.go:239:func TestJobsShowAgentAvatars(t *testing.T) {
internal/livelog/hub_test.go:25:func TestSubscribeReplaysBufferedEvents(t *testing.T) {
internal/livelog/hub_test.go:49:func TestCheckpointClearsBuffer(t *testing.T) {
internal/livelog/hub_test.go:64:func TestCloseTerminatesSubscribers(t *testing.T) {
internal/livelog/hub_test.go:87:func TestSubscribeAfterCloseGetsEmptyBuffer(t *testing.T) {
internal/livelog/hub_test.go:107:func TestCancelUnregistersSubscriber(t *testing.T) {
internal/agentrun/seed_test.go:11:func TestSeedMessageIncludesInstructions(t *testing.T) {
internal/agentrun/seed_test.go:21:func TestSeedMessageOmitsEmptyInstructions(t *testing.T) {
internal/agentrun/seed_test.go:31:func TestSeedMessageIncludesAllComments(t *testing.T) {
internal/agentrun/seed_test.go:59:func TestSeedMessageOmitsEmptyComments(t *testing.T) {
internal/agentrun/seed_test.go:69:func TestSeedMessageIncludesReview(t *testing.T) {
internal/agentrun/seed_test.go:120:func TestSeedMessageOmitsNilReview(t *testing.T) {

{"end_line":100,"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\t// Servers validate the parameters schema against the JSON Schema\n\t// metaschema and reject anything but a proper object schema.\n\tif def.Function.Parameters.Type != \"object\" {\n\t\tpanic(fmt.Sprintf(\"tool %q must have object parameters, got %q\", def.Function.Name, def.Function.Parameters.Type))\n\t}\n\n\tif def.Function.Parameters.Properties == nil {\n\t\tpanic(fmt.Sprintf(\"tool %q must have a non-nil properties map\", def.Function.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)\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":1,"end_line":79,"total_lines":79,"truncated":false}

{"command":"cd /project && grep -rn \"runLoop\\|NewStreamer\\|StreamChatCompletion\\|DefaultClient\" --include=\"*.go\" | grep -v \"_test.go\" ; echo ---; grep -rn \"status:\" --include=\"*_test.go\" . ; echo ---; sed -n '100,160p' internal/web/web_test.go"}

internal/llm/client.go:26:		httpClient: http.DefaultClient,
internal/llm/client.go:30:func (c *Client) StreamChatCompletion(ctx context.Context, req *ChatCompletionRequest) (*Streamer, error) {
internal/llm/client.go:49:	// instead of hanging the goroutine forever — http.DefaultClient has
internal/llm/client.go:64:	return NewStreamer(resp)
internal/llm/streamer.go:19:func NewStreamer(resp *http.Response) (*Streamer, error) {
internal/agentrun/loop.go:12:// Hooks lets a caller observe a runLoop invocation live, as the model
internal/agentrun/loop.go:30:// runLoop is a headless port of ../a's App.generate(): send messages +
internal/agentrun/loop.go:33:func runLoop(ctx context.Context, client *llm.Client, toolsCtx tools.Context, messages []llm.Message, hooks Hooks) ([]llm.Message, error) {
internal/agentrun/loop.go:39:		streamer, err := client.StreamChatCompletion(ctx, &llm.ChatCompletionRequest{
internal/agentrun/run.go:271:	_, err = runLoop(ctx, llmClient, runCtx, messages, hooks)
internal/agentrun/run.go:281:// streamHooks builds the Hooks a single Run passes to runLoop: every
---
---
	rr = httptest.NewRecorder()
	s.Handler().ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/jobs/job-2/events", nil))
	if rr.Code != http.StatusOK || rr.Body.Len() != 0 {
		t.Fatalf("expected empty response for a non-live job, got %d %q", rr.Code, rr.Body.String())
	}
}

// TestJobDetailTrimsBlockWhitespace verifies that reasoning/content
// blocks are rendered without the leading/trailing newlines the model
// routinely emits: the block body uses white-space: pre-wrap, so those
// would show up as visible blank lines inflating the block's height
// (issue #53). Internal newlines must be preserved.
func TestJobDetailTrimsBlockWhitespace(t *testing.T) {
	s, st := testServer(t)
	ctx := context.Background()

	if err := st.CreateJob(ctx, store.Job{ID: "job-1", EventKind: "issue:new", Agent: "leon", Owner: "acme", Repo: "widgets", IssueIndex: 1}); err != nil {
		t.Fatal(err)
	}
	if err := st.MarkJobFinished(ctx, "job-1", store.JobSucceeded, ""); err != nil {
		t.Fatal(err)
	}
	if err := st.AppendLog(ctx, "job-1", "content", "\nNow the remaining tool callers:\n\n\n"); err != nil {
		t.Fatal(err)
	}
	// A block that is nothing but whitespace should not render at all.
	if err := st.AppendLog(ctx, "job-1", "content", "   \n\t  "); err != nil {
		t.Fatal(err)
	}
	if err := st.AppendLog(ctx, "job-1", "reasoning", "  \ninner\nlines\nkept\n  "); err != nil {
		t.Fatal(err)
	}

	r := httptest.NewRecorder()
	s.Handler().ServeHTTP(r, httptest.NewRequest(http.MethodGet, "/jobs/job-1", nil))
	if r.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d: %s", r.Code, r.Body.String())
	}

	body := r.Body.String()
	if !strings.Contains(body, `<div class="block-body">Now the remaining tool callers:</div>`) {
		t.Fatalf("expected trimmed content block, got: %s", body)
	}
	if strings.Contains(body, "<div class=\"block-body\">\n") {
		t.Fatalf("block body still starts with a newline: %s", body)
	}
	if got := strings.Count(body, `class="block block-content"`); got != 1 {
		t.Fatalf("expected exactly one content block (whitespace-only one dropped), got %d: %s", got, body)
	}
	if !strings.Contains(body, "inner\nlines\nkept") {
		t.Fatalf("expected internal newlines to be preserved, got: %s", body)
	}
}

// TestJobDetailAutoScroll verifies the live job detail page ships the
// tail-following controls (issue #57): the log box is wrapped so the
// jump-to-bottom button can float over it, and the streaming script does
// its scroll math against the log container (the actual scrollable
// element) instead of the window. A finished job is static and must not
// carry either the button or the streaming script.
func TestJobDetailAutoScroll(t *testing.T) {

{"content":"package llm\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"math/rand/v2\"\n\t\"net/http\"\n\t\"time\"\n)\n\n// StatusError is a non-2xx response from the LLM endpoint.\ntype StatusError struct {\n\tCode int\n\tBody string\n}\n\nfunc (e *StatusError) Error() string {\n\treturn fmt.Sprintf(\"llm endpoint returned status %d: %s\", e.Code, e.Body)\n}\n\n// ErrEmptyCompletion is returned when the endpoint answered 200 but the\n// stream carried no choices at all. That is a protocol violation, not a\n// transient endpoint failure, so IsRetryable reports false for it:\n// retrying just repeats the same empty answer.\nvar ErrEmptyCompletion = errors.New(\"model returned an empty completion\")\n\n// IsRetryable reports whether err is a transient failure of the LLM\n// endpoint worth retrying with backoff. Retryable: transport errors\n// (connection refused, DNS, TLS, reset, a dropped or undecodable\n// stream) and HTTP 408, 429 and 5xx responses. Not retryable: context\n// cancellation or deadline (the run is being torn down or has timed\n// out; retrying only delays the failure), an empty completion, and\n// other 4xx responses (bad token, bad request, unknown model) —\n// repeating those just repeats the same failure.\nfunc IsRetryable(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\tif errors.Is(err, ErrEmptyCompletion) {\n\t\treturn false\n\t}\n\n\tvar se *StatusError\n\tif errors.As(err, &se) {\n\t\treturn se.Code == http.StatusRequestTimeout ||\n\t\t\tse.Code == http.StatusTooManyRequests ||\n\t\t\tse.Code >= 500\n\t}\n\n\t// Everything else — connection errors, mid-stream resets, undecodable\n\t// chunks — is treated as transient: the endpoint or the connection\n\t// failed in a way a fresh request may well fix.\n\treturn true\n}\n\n// RetryPolicy controls how the agent loop retries a failed turn: how\n// many times, and how long to wait between attempts.\ntype RetryPolicy struct {\n\t// MaxRetries is the number of retries after the initial attempt.\n\t// 0 means a failed turn fails the run immediately.\n\tMaxRetries int\n\t// BaseDelay is the backoff before the first retry; it doubles for\n\t// each subsequent retry, up to MaxDelay.\n\tBaseDelay time.Duration\n\t// MaxDelay caps the backoff.\n\tMaxDelay time.Duration\n}\n\n// DefaultRetryPolicy is used when the llm config block doesn't set\n// retries: up to 5 retries, 1s base backoff, 30s cap. Worst case that\n// is ~31s of waiting before a persistently failing endpoint is given\n// up on — small against a run's 120-minute budget, long enough to ride\n// out a restart or a rate-limit window.\nfunc DefaultRetryPolicy() RetryPolicy {\n\treturn RetryPolicy{\n\t\tMaxRetries: 5,\n\t\tBaseDelay:  time.Second,\n\t\tMaxDelay:   30 * time.Second,\n\t}\n}\n\n// Delay returns the backoff to sleep before the n-th retry (n is\n// 0-based), with full jitter: a uniform random value in\n// [0, min(MaxDelay, BaseDelay·2ⁿ)]. The jitter matters because several\n// agents can run concurrently against the same endpoint; without it,\n// all of their retries would land on the same beat.\nfunc (p RetryPolicy) Delay(n int) time.Duration {\n\tif p.BaseDelay <= 0 || p.MaxDelay <= 0 {\n\t\treturn 0\n\t}\n\n\tcap := p.BaseDelay\n\tfor i := 0; i < n && cap < p.MaxDelay; i++ {\n\t\tcap *= 2\n\t}\n\n\tif cap <= 0 || cap > p.MaxDelay { // the former guards overflow\n\t\tcap = p.MaxDelay\n\t}\n\n\treturn time.Duration(rand.Int64N(int64(cap)))\n}\n","path":"internal/llm/retry.go"}

OK

{"find":"func 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}","path":"internal/llm/streamer.go","replace":"// maxStatusBody bounds how much of a non-2xx response body is kept in\n// the error: enough to diagnose, not enough to paste a full HTML error\n// page into a job log.\nconst maxStatusBody = 1024\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\n\t\tif len(body) > maxStatusBody {\n\t\t\tbody = append(body[:maxStatusBody], []byte(\"… (truncated)\")...)\n\t\t}\n\n\t\treturn nil, &StatusError{Code: resp.StatusCode, Body: string(body)}\n\t}"}

1 occurrences replaced

{"find":"import (\n\t\"bytes\"\n\t\"context\"\n\t\"encoding/json\"\n\t\"net/http\"\n\n\t\"github.com/abrander/zoo/internal/config\"\n)","path":"internal/llm/client.go","replace":"import (\n\t\"bytes\"\n\t\"context\"\n\t\"encoding/json\"\n\t\"net/http\"\n\t\"time\"\n\n\t\"github.com/abrander/zoo/internal/config\"\n)\n\n// responseHeaderTimeout bounds how long a request waits for the\n// endpoint's response headers before failing. A dead or black-holing\n// endpoint must fail the request — so the agent loop can retry it —\n// instead of blocking until the run's own deadline. The timeout covers\n// only the wait for headers, not the stream body: a slow model can\n// legitimately stream a single turn for minutes.\nconst responseHeaderTimeout = 5 * time.Minute"}

1 occurrences replaced

{"find":"// NewClient builds a Client from a configured llm block.\nfunc NewClient(cfg config.LLM) *Client {\n\treturn &Client{\n\t\tendpoint:   cfg.OpenAI,\n\t\ttoken:      cfg.Token,\n\t\tmodel:      cfg.Model,\n\t\thttpClient: http.DefaultClient,\n\t}\n}","path":"internal/llm/client.go","replace":"// NewClient builds a Client from a configured llm block.\nfunc NewClient(cfg config.LLM) *Client {\n\t// A dedicated transport (not http.DefaultClient) so the\n\t// response-header timeout can be set without affecting the rest of\n\t// the process.\n\ttr := http.DefaultTransport.Clone()\n\ttr.ResponseHeaderTimeout = responseHeaderTimeout\n\n\treturn &Client{\n\t\tendpoint:   cfg.OpenAI,\n\t\ttoken:      cfg.Token,\n\t\tmodel:      cfg.Model,\n\t\thttpClient: &http.Client{Transport: tr},\n\t}\n}"}

1 occurrences replaced

{"end_line":85,"path":"internal/llm/client.go","start_line":50}

{"path":"internal/llm/client.go","content":"\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":50,"end_line":80,"total_lines":80,"truncated":false}

{"find":"\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))","path":"internal/llm/client.go","replace":"\t// Bound to ctx so a stalled stream body is unblocked by the run's\n\t// deadline instead of hanging the goroutine forever; the wait for\n\t// response headers is additionally bounded by the transport's\n\t// ResponseHeaderTimeout, so a black-holing endpoint fails fast\n\t// enough for the agent loop to retry it.\n\tr, err := http.NewRequestWithContext(ctx, http.MethodPost, c.endpoint+\"/chat/completions\", bytes.NewBuffer(body))"}

1 occurrences replaced

{"content":"package agentrun\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"io\"\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// OnTurnRetry fires when a failed turn is about to be retried:\n\t// attempt is the retry number about to start (1 = the first\n\t// retry), maxRetries the total number of retries allowed, delay the\n\t// backoff about to be slept, and err the failure that ended the\n\t// previous attempt. The failed attempt's partial stream is\n\t// discarded by this point: any reasoning or content it streamed\n\t// must not be persisted.\n\tOnTurnRetry func(attempt, maxRetries 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// llmClient is the slice of *llm.Client that runLoop drives. An\n// interface rather than the concrete client so tests can script\n// endpoint failures without a real HTTP server.\ntype llmClient interface {\n\tStreamChatCompletion(ctx context.Context, req *llm.ChatCompletionRequest) (*llm.Streamer, error)\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.\n//\n// A turn that fails with a transient endpoint error (connection\n// failure, 408, 429, 5xx, a dropped stream) is retried with\n// exponential backoff and jitter, up to retry.MaxRetries times;\n// non-transient failures and ctx cancellation fail the run immediately.\nfunc runLoop(ctx context.Context, client llmClient, toolsCtx tools.Context, messages []llm.Message, hooks Hooks, retry llm.RetryPolicy) ([]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 := runTurn(ctx, client, messages, hooks, retry)\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// runTurn does one model round-trip — request the completion and\n// consume its stream — retrying it while the LLM endpoint is failing\n// transiently. A failed attempt's partial stream is discarded (via\n// hooks.OnTurnRetry) and the turn restarts from scratch, so a retried\n// turn replays cleanly: no duplicated deltas, no half-written block in\n// the persisted log.\nfunc runTurn(ctx context.Context, client llmClient, messages []llm.Message, hooks Hooks, retry llm.RetryPolicy) (*llm.ChatCompletion, error) {\n\tfor attempt := 0; ; attempt++ {\n\t\tcompletion, err := doTurn(ctx, client, messages, hooks)\n\t\tif err == nil {\n\t\t\tif completion == nil || len(completion.Choices) == 0 {\n\t\t\t\treturn nil, llm.ErrEmptyCompletion\n\t\t\t}\n\t\t\treturn completion, nil\n\t\t}\n\n\t\t// ctx is done, the failure is not transient, or the retry\n\t\t// budget is exhausted: fail the run with the last error.\n\t\tif ctx.Err() != nil || !llm.IsRetryable(err) || attempt >= retry.MaxRetries {\n\t\t\treturn nil, err\n\t\t}\n\n\t\tdelay := retry.Delay(attempt)\n\n\t\tif hooks.OnTurnRetry != nil {\n\t\t\thooks.OnTurnRetry(attempt+1, retry.MaxRetries, delay, err)\n\t\t}\n\n\t\tselect {\n\t\tcase <-ctx.Done():\n\t\t\treturn nil, ctx.Err()\n\t\tcase <-time.After(delay):\n\t\t}\n\t}\n}\n\n// doTurn is a single, un-retried model round-trip.\nfunc doTurn(ctx context.Context, client llmClient, 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\treturn completion, nil\n}\n","path":"internal/agentrun/loop.go"}

OK