Upload folder using huggingface_hub

tbench/claude-code-setup.sh.j2

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+apt-get update
+apt-get install -y curl
+
+curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.2/install.sh | bash
+
+source "$HOME/.nvm/nvm.sh"
+
+nvm install 22
+npm -v
+
+npm install -g @anthropic-ai/claude-code@{{ version }} 

tbench/local_claude_agent.py

@@ -0,0 +1,80 @@
+"""
+Terminal-Bench agent: Claude Code driven by a local Ollama model.
+
+Terminal-Bench's stock ClaudeCodeAgent forwards only ANTHROPIC_API_KEY and
+ANTHROPIC_MODEL, so it always talks to api.anthropic.com. Ollama >=0.32 serves an
+Anthropic-compatible /v1/messages, so pointing ANTHROPIC_BASE_URL at it is enough
+to run the whole benchmark against local GGUF weights.
+
+Usage:
+    tb run --agent-import-path tbench.local_claude_agent:LocalClaudeCodeAgent \
+           --model ornith15-9b-claude-coder --dataset terminal-bench-core
+
+Containers cannot reach a host-bound 127.0.0.1, so OLLAMA_ANTHROPIC_BASE_URL must
+name an address routable from inside Docker (the bridge gateway, not localhost).
+"""
+
+from __future__ import annotations
+
+import os
+
+from pathlib import Path
+
+from terminal_bench.agents.installed_agents.claude_code import (
+    claude_code_agent as _upstream_mod,
+)
+from terminal_bench.agents.installed_agents.claude_code.claude_code_agent import (
+    ClaudeCodeAgent,
+)
+
+# Terminal-Bench resolves the setup template via inspect.getfile(self.__class__),
+# i.e. next to the *subclass*, not the class that owns the template. Keep a synced
+# copy beside this module so subclassing does not break the install step, and
+# re-sync on every import so a tb upgrade cannot leave us on a stale template.
+_TEMPLATE = "claude-code-setup.sh.j2"
+_upstream = Path(_upstream_mod.__file__).parent / _TEMPLATE
+_local = Path(__file__).parent / _TEMPLATE
+if _upstream.exists() and (
+    not _local.exists() or _local.read_bytes() != _upstream.read_bytes()
+):
+    _local.write_bytes(_upstream.read_bytes())
+
+# Docker bridge gateway. Overridable for host-gateway or a remote Ollama.
+DEFAULT_BASE_URL = "http://172.17.0.1:11435"
+
+
+class LocalClaudeCodeAgent(ClaudeCodeAgent):
+    """Claude Code, but every request goes to a local Ollama model."""
+
+    @staticmethod
+    def name() -> str:
+        return "local-claude-code"
+
+    @property
+    def _env(self) -> dict[str, str]:
+        model = (self._model_name or os.environ.get("ANTHROPIC_MODEL", ""))
+        for prefix in ("anthropic/", "ollama/", "openai/"):
+            model = model.removeprefix(prefix)
+        if not model:
+            raise ValueError("pass --model <ollama model tag>")
+
+        base_url = os.environ.get("OLLAMA_ANTHROPIC_BASE_URL", DEFAULT_BASE_URL)
+        return {
+            "ANTHROPIC_BASE_URL": base_url,
+            # Ollama ignores the value but Claude Code refuses to start without one.
+            "ANTHROPIC_AUTH_TOKEN": os.environ.get("ANTHROPIC_AUTH_TOKEN", "ollama"),
+            "ANTHROPIC_API_KEY": os.environ.get("ANTHROPIC_API_KEY", "ollama"),
+            "ANTHROPIC_MODEL": model,
+            # Claude Code silently routes cheap side-tasks (titles, file triage) to a
+            # small model. Unset, those hit Anthropic-named models Ollama has never
+            # heard of and the run dies mid-task with confusing 404s.
+            "ANTHROPIC_SMALL_FAST_MODEL": model,
+            "ANTHROPIC_DEFAULT_HAIKU_MODEL": model,
+            "ANTHROPIC_DEFAULT_SONNET_MODEL": model,
+            "ANTHROPIC_DEFAULT_OPUS_MODEL": model,
+            "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
+            "DISABLE_TELEMETRY": "1",
+            "DISABLE_ERROR_REPORTING": "1",
+            "FORCE_AUTO_BACKGROUND_TASKS": "1",
+            "ENABLE_BACKGROUND_TASKS": "1",
+        }

tbench/ollama_bridge.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""
+Expose the host's Ollama to Docker containers.
+
+Ollama binds 127.0.0.1:11434, which is unreachable from a container's network
+namespace. Terminal-Bench runs every task in a container, so Claude Code inside
+it cannot see the model without a forwarder.
+
+Binds the Docker bridge address ONLY (default 172.17.0.1), so this does not
+expose Ollama on the LAN, and dies with the process. stdlib only -- no socat.
+
+    python3 tbench/ollama_bridge.py &
+"""
+
+from __future__ import annotations
+
+import argparse
+import socket
+import socketserver
+import threading
+
+
+class Handler(socketserver.BaseRequestHandler):
+    upstream: tuple[str, int] = ("127.0.0.1", 11434)
+
+    def handle(self) -> None:
+        try:
+            up = socket.create_connection(self.upstream, timeout=30)
+        except OSError:
+            return
+        # Long-poll generations can idle for minutes; a read timeout here would
+        # sever a working request mid-stream.
+        up.settimeout(None)
+        self.request.settimeout(None)
+        with up:
+            a = threading.Thread(target=self._pipe, args=(self.request, up), daemon=True)
+            a.start()
+            self._pipe(up, self.request)
+            a.join()
+
+    @staticmethod
+    def _pipe(src: socket.socket, dst: socket.socket) -> None:
+        try:
+            while chunk := src.recv(65536):
+                dst.sendall(chunk)
+        except OSError:
+            pass
+        finally:
+            try:
+                dst.shutdown(socket.SHUT_WR)
+            except OSError:
+                pass
+
+
+class Server(socketserver.ThreadingTCPServer):
+    allow_reuse_address = True
+    daemon_threads = True
+
+
+def main() -> None:
+    p = argparse.ArgumentParser()
+    p.add_argument("--bind", default="172.17.0.1", help="docker bridge address")
+    p.add_argument("--port", type=int, default=11435)
+    p.add_argument("--to-host", default="127.0.0.1")
+    p.add_argument("--to-port", type=int, default=11434)
+    a = p.parse_args()
+
+    Handler.upstream = (a.to_host, a.to_port)
+    with Server((a.bind, a.port), Handler) as s:
+        print(f"bridge {a.bind}:{a.port} -> {a.to_host}:{a.to_port}", flush=True)
+        s.serve_forever()
+
+
+if __name__ == "__main__":
+    main()

tbench/run_bench.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+# Terminal-Bench baselines for local GGUF models driving Claude Code via Ollama.
+#
+# Prereq (needs your approval, run once per boot):
+#   socat TCP-LISTEN:11435,bind=172.17.0.1,fork,reuseaddr TCP:127.0.0.1:11434 &
+# Docker containers cannot reach Ollama's 127.0.0.1 bind; this exposes it on the
+# docker bridge only, not the LAN.
+#
+# Usage: ./tbench/run_bench.sh <ollama-model> [n_tasks] [n_concurrent]
+set -euo pipefail
+
+MODEL="${1:?usage: run_bench.sh <ollama-model> [n_tasks] [n_concurrent]}"
+N_TASKS="${2:-10}"
+N_CONC="${3:-2}"
+# Pin the dataset: "head" resolved to an archive with no tasks/ dir, and an
+# unpinned version is not comparable to the published leaderboard.
+DATASET="${DATASET:-terminal-bench-core==0.1.1}"
+
+REPO="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+TB="${TB_BIN:-$REPO/.tb/bin/tb}"
+BRIDGE="${OLLAMA_ANTHROPIC_BASE_URL:-http://172.17.0.1:11435}"
+
+# Fail loudly here rather than let every task die inside its container with an
+# opaque connection error 20 minutes in.
+if ! curl -s --max-time 5 "${BRIDGE}/api/version" >/dev/null; then
+  echo "ERROR: Ollama not reachable at ${BRIDGE} (needed from inside Docker)." >&2
+  echo "Start the bridge:  socat TCP-LISTEN:11435,bind=172.17.0.1,fork,reuseaddr TCP:127.0.0.1:11434 &" >&2
+  exit 1
+fi
+# Exact tag match. A prefix match would accept gemma4:31b when asked for
+# gemma4:e4b and silently benchmark the wrong model. Capture first: `grep -q`
+# exits early, SIGPIPEs ollama, and pipefail would report a false negative.
+MODELS="$(ollama list | awk 'NR>1 {print $1}')"
+if ! grep -qxF -- "$MODEL" <<<"$MODELS" && ! grep -qxF -- "${MODEL}:latest" <<<"$MODELS"; then
+  echo "ERROR: ollama has no model '${MODEL}'. Available:" >&2
+  echo "$MODELS" | sed 's/^/  /' >&2
+  exit 1
+fi
+
+export OLLAMA_ANTHROPIC_BASE_URL="$BRIDGE"
+export ANTHROPIC_API_KEY=ollama
+export ANTHROPIC_AUTH_TOKEN=ollama
+export PYTHONPATH="$REPO:${PYTHONPATH:-}"
+
+RUN_ID="tb_$(echo "$MODEL" | tr '/:' '__')_${N_TASKS}"
+echo "[tbench] dataset=$DATASET"
+echo "[tbench] model=$MODEL tasks=$N_TASKS concurrent=$N_CONC bridge=$BRIDGE"
+
+"$TB" run \
+  --agent-import-path tbench.local_claude_agent:LocalClaudeCodeAgent \
+  --model "$MODEL" \
+  --dataset "$DATASET" \
+  --n-tasks "$N_TASKS" \
+  --n-concurrent "$N_CONC" \
+  --run-id "$RUN_ID" \
+  --no-livestream