Lock OpenCode 2.x to your self-hosted model

Steps#

1. Save the PoC script as opencode-default-model-poc.sh and make it executable. It needs only python3 and the opencode binary. It starts a tiny fake OpenAI-compatible server on 127.0.0.1, then runs opencode run --standalone "say hi" three times in a throwaway HOME: A) the config names the local model, B) the same config without "model", C) B plus "disabled_providers": ["opencode"]. Every non-local request goes to a dead proxy on 127.0.0.1:9, so nothing can reach opencode.ai. The header comment says "twice"; the script runs three cases. That comment is out of date.

   #!/usr/bin/env bash
   # PoC: does OpenCode (V2, @opencode/cli 2.2.x) need an opencode.ai account to use a self-hosted model?
   #
   # Runs `opencode run` twice in a throwaway HOME against a tiny local OpenAI-compatible server
   # (started by this script, 127.0.0.1 only):
   #   A) config names the local model ("model": "local/qwen-local")
   #   B) same config without "model"
   #   C) B plus the fix: "disabled_providers": ["opencode"]
   # All other traffic goes to a dead proxy (127.0.0.1:9), so nothing reaches opencode.ai.
   # Nothing outside the temp dir is touched; your own ~/.config/opencode is not read.
   #
   # Usage: ./opencode-default-model-poc.sh [path-to-opencode]     (default: opencode on PATH)
   set -u
   BIN="${1:-opencode}"
   command -v "$BIN" >/dev/null || { echo "opencode binary not found: $BIN" >&2; exit 2; }
   command -v python3 >/dev/null || { echo "python3 needed for the fake model server" >&2; exit 2; }
   
   T=$(mktemp -d)
   PORT=18765
   cat > "$T/fake.py" <<'EOF_PY'
   import json, sys, time
   from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
   
   class H(BaseHTTPRequestHandler):
       def log_message(self, *a):
           sys.stderr.write("fake-server: " + (a[0] % a[1:]) + "\n")
       def _json(self, obj):
           b = json.dumps(obj).encode()
           self.send_response(200); self.send_header("Content-Type", "application/json")
           self.send_header("Content-Length", str(len(b))); self.end_headers(); self.wfile.write(b)
       def do_GET(self):
           self._json({"object": "list", "data": [{"id": "qwen-local", "object": "model"}]})
       def do_POST(self):
           body = json.loads(self.rfile.read(int(self.headers.get("Content-Length", 0))) or b"{}")
           text = "LOCAL MODEL ANSWERED"
           if not body.get("stream"):
               return self._json({"id": "x", "object": "chat.completion", "created": int(time.time()), "model": "qwen-local",
                                  "choices": [{"index": 0, "message": {"role": "assistant", "content": text}, "finish_reason": "stop"}],
                                  "usage": {"prompt_tokens": 1, "completion_tokens": 3, "total_tokens": 4}})
           self.send_response(200); self.send_header("Content-Type", "text/event-stream"); self.end_headers()
           def ev(d): self.wfile.write(b"data: " + json.dumps(d).encode() + b"\n\n"); self.wfile.flush()
           base = {"id": "x", "object": "chat.completion.chunk", "created": int(time.time()), "model": "qwen-local"}
           ev({**base, "choices": [{"index": 0, "delta": {"role": "assistant", "content": text}, "finish_reason": None}]})
           ev({**base, "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}],
               "usage": {"prompt_tokens": 1, "completion_tokens": 3, "total_tokens": 4}})
           self.wfile.write(b"data: [DONE]\n\n"); self.wfile.flush()
   
   ThreadingHTTPServer(("127.0.0.1", int(sys.argv[1])), H).serve_forever()
   EOF_PY
   python3 "$T/fake.py" "$PORT" 2> "$T/fake.log" &
   FAKE=$!
   trap 'kill $FAKE 2>/dev/null' EXIT
   sleep 1
   
   run_case() {  # $1 label, $2 "with-model" | "no-model" | "fix"
     local h="$T/$1" model_line=""
     mkdir -p "$h/.config/opencode" "$h/proj"
     [ "$2" = with-model ] && model_line=',
     "model": "local/qwen-local"'
     [ "$2" = fix ] && model_line=',
     "disabled_providers": ["opencode"]'
     cat > "$h/.config/opencode/opencode.json" <<EOF_J
   {
     "\$schema": "https://opencode.ai/config.json",
     "provider": {
       "local": {
         "npm": "@ai-sdk/openai-compatible",
         "name": "local",
         "options": { "baseURL": "http://127.0.0.1:$PORT/v1" },
         "models": { "qwen-local": { "name": "qwen-local" } }
       }
     }$model_line
   }
   EOF_J
     echo "=== case $1 ($2)"
     (cd "$h/proj" && env HOME="$h" XDG_CONFIG_HOME="$h/.config" XDG_DATA_HOME="$h/.local/share" \
        XDG_STATE_HOME="$h/.local/state" XDG_CACHE_HOME="$h/.cache" PWD="$h/proj" \
        HTTP_PROXY=http://127.0.0.1:9 HTTPS_PROXY=http://127.0.0.1:9 NO_PROXY=127.0.0.1,localhost \
        OPENCODE_DISABLE_AUTOUPDATE=1 \
        timeout 60 "$BIN" run --standalone "say hi" < /dev/null 2>&1 | sed 's/\x1b\[[0-9;]*m//g' | sort -u | head -n 8)
   }
   
   echo "opencode: $("$BIN" --version 2>&1)"
   run_case A with-model
   run_case B no-model
   run_case C fix
   echo "=== requests the local server got (A and C should have some, B none):"
   grep -c 'POST' "$T/fake.log" || true
   echo "(temp dir: $T)"
   

   chmod +x opencode-default-model-poc.sh
   

2. Run it against your binary: ./opencode-default-model-poc.sh <OPENCODE_BIN> (or with no argument for opencode on PATH). My run on 2.2.5 printed this (the invocation line was not captured):

   opencode: opencode v2.2.5
   === case A (with-model)
   LOCAL MODEL ANSWERED
   === case B (no-model)
   
   > build · flint-40b-free
   Error: Transport: ECONNRESET: The socket connection was closed unexpectedly. For more information, pass `verbose: true` in the second argument to fetch()
   === case C (fix)
   LOCAL MODEL ANSWERED
   === requests the local server got (A and C should have some, B none):
   4
   (temp dir: /tmp/tmp.qySI9NmbUG)
   

   Expected: cases A and C print LOCAL MODEL ANSWERED (the fake server's canned reply); case B prints > build · flint-40b-free and an error; the last count is above zero. The count is one total of POST lines in the fake server's log for the whole run; the script does not split it per case. The server's log held requests from A and C and none from B. Each case's lines pass through sort -u | head -n 8, so they are sorted, not in the order OpenCode printed them; that is why case B starts with an empty line. If your case B also shows flint-40b-free, your binary behaves like 2.2.0 and 2.2.5: with no "model" in the config, it picks OpenCode's hosted free model.

3. Name your local model in <CONFIG>. Add this top-level key, next to "provider":

   "model": "<PROVIDER_ID>/<MODEL_ID>",
   

   In the PoC that is "model": "local/qwen-local" (case A). Expected: the local model answers; in my offline run it also ran a shell tool (echo hello-from-tool) without a key or an account.

4. Disable the hosted provider in <CONFIG>. Add this top-level key:

   "disabled_providers": ["opencode"],
   

   This alone was case C: no "model" key, and the local model answered. On 2.2.5 with the local server up, either step alone was enough; step 4 is the one that removes the hosted models from the choice. Doing both steps leaves both lines set, a combination I have not run (see Scope). For reference, this is the whole config the PoC writes for case C (its heredoc with PORT=18765):

   {
     "$schema": "https://opencode.ai/config.json",
     "provider": {
       "local": {
         "npm": "@ai-sdk/openai-compatible",
         "name": "local",
         "options": { "baseURL": "http://127.0.0.1:18765/v1" },
         "models": { "qwen-local": { "name": "qwen-local" } }
       }
     },
     "disabled_providers": ["opencode"]
   }