Claude Code: OpenCode Go requests lose session affinity through /v1/messages #3945

#!/usr/bin/env python3
"""Minimal Claude-shaped request to an already configured local OpenCodex proxy."""

import argparse
import ipaddress
import json
import sys
import urllib.error
import urllib.parse
import urllib.request
import uuid


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--base-url", required=True, help="Loopback OpenCodex origin, e.g. http://127.0.0.1:10101")
    parser.add_argument("--model", default="opencode-go/glm-5.3-flash")
    parser.add_argument("--conversation", type=uuid.UUID, default=None,
                        help="Reuse a UUID for the same conversation; otherwise generate a new one")
    parser.add_argument("--tool", action="store_true", help="Request a harmless report_ok tool call; never execute it")
    args = parser.parse_args()
    parsed = urllib.parse.urlsplit(args.base_url)
    try:
        loopback = ipaddress.ip_address(parsed.hostname or "").is_loopback
    except ValueError:
        loopback = parsed.hostname == "localhost"
    if parsed.scheme != "http" or not loopback or parsed.username or parsed.password or parsed.query or parsed.fragment:
        parser.error("base URL must be a plain HTTP loopback origin without credentials")
    if parsed.path not in ("", "/"):
        parser.error("base URL must be an origin without a path")
    conversation = args.conversation or uuid.uuid4()
    body = {
        "model": args.model,
        "max_tokens": 64,
        "stream": False,
        "metadata": {"user_id": f"user_mwe_account_mwe_session_{conversation}"},
        "messages": [{"role": "user", "content": "Reply with exactly GO_OK."}],
    }
    if args.tool:
        body["tools"] = [{"name": "report_ok", "description": "Report a successful test",
                          "input_schema": {"type": "object", "properties": {}, "additionalProperties": False}}]
        body["tool_choice"] = {"type": "tool", "name": "report_ok"}
    request = urllib.request.Request(
        args.base_url.rstrip("/") + "/v1/messages",
        data=json.dumps(body).encode(),
        headers={"Content-Type": "application/json", "anthropic-version": "2023-06-01"},
        method="POST",
    )
    # The proxy owns its Go key. This client never loads or sends any credential.
    opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
    try:
        with opener.open(request, timeout=90) as response:
            status, payload = response.status, response.read(1048576)
    except urllib.error.HTTPError as error:
        status, payload = error.code, error.read(1048576)
    except (OSError, urllib.error.URLError):
        print("Connection failed or timed out; confirm the local proxy is running.")
        return 2
    print(f"HTTP {status}")
    if b"missingsessionid" in payload.lower() or b"missing x-opencode-session" in payload.lower():
        print("Error: MissingSessionID / missing x-opencode-session")
        return 1
    try:
        message = json.loads(payload)
    except ValueError:
        print("Response was not message JSON; body omitted.")
        return 1
    content = message.get("content", []) if isinstance(message, dict) else []
    if status == 200 and any(c.get("type") == "text" and c.get("text", "").strip() == "GO_OK" for c in content):
        print("GO_OK")
        return 0
    if status == 200 and args.tool and any(c.get("type") == "tool_use" and c.get("name") == "report_ok" for c in content):
        print("Expected tool call received; no tool executed.")
        return 0
    print("Unexpected response; body omitted to avoid printing upstream diagnostics or credentials.")
    return 1


if __name__ == "__main__":
    sys.exit(main())

#!/usr/bin/env python3
"""Run the Go session reproduction through the existing ocx-claude launcher."""

import json
import shutil
import subprocess
import sys


def main():
    executable = shutil.which("ocx-claude")
    if not executable:
        print("ocx-claude is unavailable; put the configured launcher on PATH.")
        return 2
    command = [
        executable, "--model", "opencode-go/glm-5.3-flash",
        "-p", "Reply with exactly GO_OK.", "--tools", "", "--max-turns", "1",
        "--output-format", "json", "--no-session-persistence",
        "--strict-mcp-config", "--mcp-config", '{"mcpServers":{}}',
    ]
    try:
        completed = subprocess.run(command, capture_output=True, text=True,
                                   timeout=90, check=False)
    except subprocess.TimeoutExpired:
        print("Client timed out after 90 seconds; captured diagnostics omitted.")
        return 2
    except OSError:
        print("Client could not be started; diagnostics omitted.")
        return 2
    print(f"Client exit status: {completed.returncode}")
    diagnostic = (completed.stdout + completed.stderr).lower()
    if "missingsessionid" in diagnostic or "missing x-opencode-session" in diagnostic:
        print("Error: MissingSessionID / missing x-opencode-session")
        return 1
    try:
        result = json.loads(completed.stdout)
    except ValueError:
        result = None
    if (completed.returncode == 0 and isinstance(result, dict)
            and not result.get("is_error") and isinstance(result.get("result"), str)
            and result["result"].strip() == "GO_OK"):
        print("GO_OK")
        return 0
    print("Unexpected client result; captured output omitted to avoid exposing diagnostics or credentials.")
    return 1


if __name__ == "__main__":
    sys.exit(main())