fix(tools): propagate agent context so Ctrl-C/timeout interrupts tools

Only delegate_tasks honored the loop's SetContext, so a turn timeout or
Ctrl-C could not interrupt the other long-running tools — their HTTP
requests and subprocesses ran to completion regardless, and the loop's
drain blocked on them.

Add a small race-safe ctxTool embeddable (SetContext + toolCtx) and wire it
through the tools that do unbounded network or subprocess work:
- http_batch, browser, web_search → http.NewRequestWithContext
- vision (ffprobe/ffmpeg/llama-mtmd-cli), transcribe (ffmpeg/whisper) →
  exec.CommandContext
- shell now uses the shared embed too (replacing its bare ctx field).

The mutex in ctxTool matters: when the LLM emits two calls to the same tool
in one turn, the loop sets the context on the shared instance from parallel
goroutines — an unsynchronised field would race.

Tests: ctxTool default/set/concurrent behavior, and http_batch returning a
cancellation error when its context is already cancelled.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: jkyberneees

cmd/odek/browser_tool.go

@@ -55,6 +55,7 @@ type browserState struct {
 // ── Browser Tool ──────────────────────────────────────────────────────
 
 type browserTool struct {
+	ctxTool
 	state           *browserState
 	client          *http.Client
 	dangerousConfig danger.DangerousConfig
@@ -196,7 +197,7 @@ func (t *browserTool) doNavigate(rawURL string) (string, error) {
 		return jsonError(fmt.Sprintf("invalid URL %q: must start with http:// or https://", rawURL))
 	}
 
-	req, err := http.NewRequest("GET", rawURL, nil)
+	req, err := http.NewRequestWithContext(t.toolCtx(), "GET", rawURL, nil)
 	if err != nil {
 		return jsonError(fmt.Sprintf("cannot create request: %v", err))
 	}

cmd/odek/perf_tools.go

@@ -412,6 +412,7 @@ func (t *parallelShellTool) runOne(cmd parallelShellCmd) parallelShellEntry {
 const maxHTTPBatchURLs = 10
 
 type httpBatchTool struct {
+	ctxTool
 	dangerousConfig danger.DangerousConfig
 	client          *http.Client
 }
@@ -556,7 +557,7 @@ func (t *httpBatchTool) fetchOne(r httpBatchReq) httpBatchEntry {
 	}
 
 	entry := httpBatchEntry{URL: r.URL}
-	httpReq, err := http.NewRequest(method, r.URL, nil)
+	httpReq, err := http.NewRequestWithContext(t.toolCtx(), method, r.URL, nil)
 	if err != nil {
 		entry.Error = err.Error()
 		return entry

cmd/odek/shell.go

@@ -72,19 +72,14 @@ type shellTool struct {
 	// Overridden in tests to mock user input. Only used when approver is nil.
 	ttyPath string
 
-	// ctx, when set via SetContext, ties command execution to the agent's
-	// lifetime: cancelling it (Ctrl-C, turn timeout) kills the running command.
-	ctx context.Context
+	// ctxTool provides SetContext/toolCtx so cancelling the agent context
+	// (Ctrl-C, turn timeout) kills the running command.
+	ctxTool
 
 	// timeout bounds a single command. Zero falls back to defaultShellTimeout.
 	timeout time.Duration
 }
 
-// SetContext lets the agent loop propagate its context so a running command is
-// killed when the turn is cancelled. Implements the loop's optional
-// context-aware tool interface.
-func (t *shellTool) SetContext(ctx context.Context) { t.ctx = ctx }
-
 func (t *shellTool) Name() string { return "shell" }
 
 func (t *shellTool) Description() string {
@@ -138,10 +133,7 @@ func (t *shellTool) Call(args string) (string, error) {
 	// Bound execution: cancel with the agent context (Ctrl-C / turn timeout)
 	// and a generous backstop timeout so a stuck command can never wedge the
 	// agent forever.
-	base := t.ctx
-	if base == nil {
-		base = context.Background()
-	}
+	base := t.toolCtx()
 	timeout := t.timeout
 	if timeout <= 0 {
 		timeout = defaultShellTimeout

cmd/odek/toolctx.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"context"
+	"sync"
+)
+
+// ctxTool is embedded by tools that support agent-context cancellation. The
+// agent loop calls SetContext on any tool implementing it (see internal/loop)
+// right before invoking the tool, so cancelling the agent context — Ctrl-C, a
+// turn timeout — interrupts the tool's in-flight network request or subprocess
+// instead of letting it run to completion (or hang) unsupervised.
+//
+// The mutex matters: when the LLM emits two calls to the SAME tool in one
+// turn, the loop runs them in parallel goroutines and calls SetContext on the
+// shared instance from each. Without synchronisation that is a data race on the
+// context field even though the value is identical for the turn.
+type ctxTool struct {
+	mu  sync.Mutex
+	ctx context.Context
+}
+
+// SetContext records the agent context for the next Call. Safe for concurrent
+// use by parallel invocations of the same tool instance.
+func (c *ctxTool) SetContext(ctx context.Context) {
+	c.mu.Lock()
+	c.ctx = ctx
+	c.mu.Unlock()
+}
+
+// toolCtx returns the recorded agent context, or context.Background() if none
+// was set (e.g. tools invoked directly in tests or outside the agent loop).
+func (c *ctxTool) toolCtx() context.Context {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if c.ctx == nil {
+		return context.Background()
+	}
+	return c.ctx
+}

cmd/odek/toolctx_test.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"context"
+	"strings"
+	"sync"
+	"testing"
+)
+
+func TestCtxTool_DefaultsToBackground(t *testing.T) {
+	var c ctxTool
+	if c.toolCtx() != context.Background() {
+		t.Error("unset ctxTool should return context.Background()")
+	}
+}
+
+func TestCtxTool_SetAndGet(t *testing.T) {
+	var c ctxTool
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	c.SetContext(ctx)
+	if c.toolCtx() != ctx {
+		t.Error("toolCtx should return the context set via SetContext")
+	}
+}
+
+// TestCtxTool_ConcurrentSetContext mirrors the loop calling SetContext on a
+// shared tool instance from parallel goroutines — it must be race-free.
+func TestCtxTool_ConcurrentSetContext(t *testing.T) {
+	var c ctxTool
+	ctx := context.Background()
+	var wg sync.WaitGroup
+	for i := 0; i < 100; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			c.SetContext(ctx)
+			_ = c.toolCtx()
+		}()
+	}
+	wg.Wait()
+}
+
+// TestHTTPBatch_ContextCancelled verifies the propagated context aborts the
+// fetch: a cancelled context yields an error entry instead of a real request.
+func TestHTTPBatch_ContextCancelled(t *testing.T) {
+	tool := newHTTPBatchTool(allowAllDanger())
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel() // already cancelled
+	tool.SetContext(ctx)
+
+	result := callJSON(t, tool, `{"requests":[{"url":"http://example.com/"}]}`)
+	var r struct {
+		Results []struct {
+			Error string `json:"error"`
+		} `json:"results"`
+	}
+	mustUnmarshal(t, result, &r)
+	if len(r.Results) != 1 {
+		t.Fatalf("Results = %d, want 1", len(r.Results))
+	}
+	if r.Results[0].Error == "" {
+		t.Fatal("expected an error from the cancelled context")
+	}
+	if !strings.Contains(r.Results[0].Error, "context canceled") {
+		t.Errorf("error should reflect cancellation, got: %s", r.Results[0].Error)
+	}
+}

cmd/odek/transcribe_tool.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"os"
@@ -20,7 +21,7 @@ import (
 // Returns the path to the WAV file (may be the same as input if already WAV/MP3/FLAC
 // or if ffmpeg is unavailable/fails — in which case whisper will produce its own error).
 // The caller must remove the returned path if it differs from the input path.
-func convertToWAV(srcPath string) string {
+func convertToWAV(ctx context.Context, srcPath string) string {
 	ext := strings.ToLower(filepath.Ext(srcPath))
 	// whisper.cpp supports WAV, MP3, FLAC natively via dr_wav/dr_mp3/dr_flac.
 	switch ext {
@@ -35,7 +36,7 @@ func convertToWAV(srcPath string) string {
 
 	// Convert to WAV using ffmpeg — best-effort, fall through on failure.
 	dstPath := srcPath + ".wav"
-	cmd := exec.Command("ffmpeg", "-y", "-i", srcPath, "-acodec", "pcm_s16le", "-ar", "16000", "-ac", "1", dstPath)
+	cmd := exec.CommandContext(ctx, "ffmpeg", "-y", "-i", srcPath, "-acodec", "pcm_s16le", "-ar", "16000", "-ac", "1", dstPath)
 	if err := cmd.Run(); err != nil {
 		// If ffmpeg fails (corrupt file, unsupported codec, etc.),
 		// just pass the original path — whisper will produce its own error.
@@ -138,6 +139,7 @@ Set "model" in transcription config to change which model is expected.`,
 // ═════════════════════════════════════════════════════════════════════════
 
 type transcribeTool struct {
+	ctxTool
 	dangerousConfig  danger.DangerousConfig
 	transcriptionCfg config.TranscriptionConfig
 }
@@ -224,7 +226,7 @@ func (t *transcribeTool) Call(argsJSON string) (result string, err error) {
 	f.Close()
 
 	// Convert to WAV if needed (whisper.cpp doesn't support OGG Opus natively).
-	wavPath := convertToWAV(args.Path)
+	wavPath := convertToWAV(t.toolCtx(), args.Path)
 	cleanup := func() {
 		if wavPath != args.Path {
 			os.Remove(wavPath)
@@ -263,7 +265,7 @@ func (t *transcribeTool) Call(argsJSON string) (result string, err error) {
 		args2 = append(args2, "--language", lang)
 	}
 
-	cmd := exec.Command(binary, args2...)
+	cmd := exec.CommandContext(t.toolCtx(), binary, args2...)
 	output, err := cmd.Output()
 	if err != nil {
 		if exitErr, ok := err.(*exec.ExitError); ok {

cmd/odek/vision_tool.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"os"
@@ -89,7 +90,7 @@ Or set models_dir in the vision config.`, mp, dir, dir)
 // extractVideoFrames samples n evenly-spaced frames from videoPath into a
 // temporary directory. Returns paths to the JPEG frame files; caller must
 // remove the directory (filepath.Dir of the first path).
-func extractVideoFrames(videoPath string, n int) ([]string, error) {
+func extractVideoFrames(ctx context.Context, videoPath string, n int) ([]string, error) {
 	if _, err := exec.LookPath("ffmpeg"); err != nil {
 		return nil, fmt.Errorf("ffmpeg not found — required for video frame extraction")
 	}
@@ -98,7 +99,7 @@ func extractVideoFrames(videoPath string, n int) ([]string, error) {
 	}
 
 	// Get duration with ffprobe
-	out, err := exec.Command("ffprobe",
+	out, err := exec.CommandContext(ctx, "ffprobe",
 		"-v", "error",
 		"-show_entries", "format=duration",
 		"-of", "csv=p=0",
@@ -124,7 +125,7 @@ func extractVideoFrames(videoPath string, n int) ([]string, error) {
 	for i := 1; i <= n; i++ {
 		ts := interval * float64(i)
 		out := filepath.Join(tmpDir, fmt.Sprintf("frame_%02d.jpg", i))
-		cmd := exec.Command("ffmpeg",
+		cmd := exec.CommandContext(ctx, "ffmpeg",
 			"-ss", fmt.Sprintf("%.3f", ts),
 			"-i", videoPath,
 			"-frames:v", "1",
@@ -146,7 +147,7 @@ func extractVideoFrames(videoPath string, n int) ([]string, error) {
 
 // runLlamaMtmd calls llama-mtmd-cli in single-turn mode with one or more images
 // and returns the trimmed stdout response.
-func runLlamaMtmd(binary, modelPath, mmprojPath, prompt string, imagePaths []string) (string, error) {
+func runLlamaMtmd(ctx context.Context, binary, modelPath, mmprojPath, prompt string, imagePaths []string) (string, error) {
 	args := []string{
 		"-m", modelPath,
 		"--mmproj", mmprojPath,
@@ -162,7 +163,7 @@ func runLlamaMtmd(binary, modelPath, mmprojPath, prompt string, imagePaths []str
 		args = append(args, "--image", img)
 	}
 
-	cmd := exec.Command(binary, args...)
+	cmd := exec.CommandContext(ctx, binary, args...)
 	output, err := cmd.Output()
 	if err != nil {
 		if exitErr, ok := err.(*exec.ExitError); ok {
@@ -179,6 +180,7 @@ func runLlamaMtmd(binary, modelPath, mmprojPath, prompt string, imagePaths []str
 // ═════════════════════════════════════════════════════════════════════════
 
 type visionTool struct {
+	ctxTool
 	dangerousConfig danger.DangerousConfig
 	visionCfg       config.VisionConfig
 }
@@ -277,7 +279,7 @@ func (t *visionTool) Call(argsJSON string) (result string, err error) {
 }
 
 func (t *visionTool) analyzeImage(binary, modelPath, mmprojPath, imgPath, prompt, source string) (string, error) {
-	desc, err := runLlamaMtmd(binary, modelPath, mmprojPath, prompt, []string{imgPath})
+	desc, err := runLlamaMtmd(t.toolCtx(), binary, modelPath, mmprojPath, prompt, []string{imgPath})
 	if err != nil {
 		return jsonResult(visionResult{Error: err.Error()})
 	}
@@ -294,7 +296,7 @@ func (t *visionTool) analyzeVideo(binary, modelPath, mmprojPath, videoPath, prom
 		n = 8
 	}
 
-	frames, err := extractVideoFrames(videoPath, n)
+	frames, err := extractVideoFrames(t.toolCtx(), videoPath, n)
 	if err != nil {
 		return jsonResult(visionResult{Error: err.Error()})
 	}
@@ -304,7 +306,7 @@ func (t *visionTool) analyzeVideo(binary, modelPath, mmprojPath, videoPath, prom
 		"These are %d frames sampled evenly from a video. %s",
 		len(frames), prompt,
 	)
-	desc, err := runLlamaMtmd(binary, modelPath, mmprojPath, videoPrompt, frames)
+	desc, err := runLlamaMtmd(t.toolCtx(), binary, modelPath, mmprojPath, videoPrompt, frames)
 	if err != nil {
 		return jsonResult(visionResult{Error: err.Error()})
 	}

cmd/odek/web_search_tool.go

@@ -34,6 +34,7 @@ var (
 // ═════════════════════════════════════════════════════════════════════════
 
 type webSearchTool struct {
+	ctxTool
 	dangerousConfig danger.DangerousConfig
 	cfg             config.WebSearchConfig
 	client          *http.Client
@@ -235,7 +236,7 @@ func (t *webSearchTool) query(query, category string) (*searxngResponse, error)
 	}
 	endpoint.RawQuery = q.Encode()
 
-	req, err := http.NewRequest(http.MethodGet, endpoint.String(), nil)
+	req, err := http.NewRequestWithContext(t.toolCtx(), http.MethodGet, endpoint.String(), nil)
 	if err != nil {
 		return nil, fmt.Errorf("build request: %v", err)
 	}