Repository navigation
Releases
freepro v0.1.21
freepro v0.1.21
Codex CLI and Codex Desktop support (Quick adds)
A second entry now lives in the Quick adds tab: Codex CLI & Codex Desktop.
Codex only speaks OpenAI's Responses wire (wire_api = "responses" is the sole
value codex-rs accepts for a custom provider), and freepro only spoke Chat
Completions. freepro now serves POST /v1/responses and bridges both directions
itself, so any model you expose works in Codex:
- Request translation —
instructionsand theinputitem array become chat
messages;function_callitems collapse into the assistant turn their
function_call_outputreplies belong to;namespacetool groups are flattened;
customtools are mapped to single-argument functions and restored on the way
back ascustom_tool_callitems; hosted tools (web_search,file_search, …)
are dropped, since no chat upstream can execute them. - Reply translation — a full Responses document for non-streaming calls, and a
live Responses event stream otherwise. Tool calls are emitted through
response.output_item.done, which is the only channel codex-rs actually reads
them from, and every stream ends withresponse.completed— without it Codex
reports "stream closed before response.completed". - Nothing else changes — the bridge runs on the ordinary completion pipeline,
so key rotation, the public proxy pool, retries, failover and metrics all apply
to Codex traffic exactly as they do to any other client.
The quick-add writes $CODEX_HOME/config.toml (or ~/.codex/config.toml) with a
[model_providers.freepro] table plus the root model_provider, model and
model_catalog_json keys, and publishes your enabled models as a Codex catalog so
they appear in its model picker instead of falling back to unknown-model metadata.
Existing providers, MCP servers, projects and desktop settings are left untouched,
the previous config is kept as config.toml.freepro.bak, and applying it twice is
a no-op.
Verified end to end against the real codex-cli 0.153.2 binary: codex exec
accepts the written config under --strict-config, resolves the model through the
freepro provider, streams the answer, and completes a full exec_command tool
round trip.
Memory: the 3 GB was thread stacks
Long runs left freepro holding ~3 GB. Measured directly against a live process:
202 committed regions of exactly 16 MB. That is Zig's Windows default thread stack
size, and std.Io.Threaded adds a pool thread under load and never retires it —
so a burst of concurrent clients permanently cost 16 MB per thread.
- Every thread freepro creates now gets a 2 MB stack: idle commit drops from
132 MB to 20 MB, and a 100-client burst plateaus at ~285 MB instead of
growing with the number of threads ever spawned. - The per-request SSE usage scanner could grow its line buffer to the 16 MB body
cap and then retain that capacity, re-expanding repeatedly within one request.
It now stops at 64 KB (a usage event is a few hundred bytes) and releases the
buffer when a line exceeds that. - Buffered upstream completions are capped at 8 MB instead of 16 MB; the inbound
request cap is unchanged at 16 MB so large agent contexts still work. - The free-proxy candidate reservoir is capped at 20 000 entries instead of 80 000.
Fixes
zig build test: 428/428 passing.
freepro v0.1.20
65 proxy sources, a much faster checker, and a 100-agent live pass
More proxies than ever. The pool now pulls from 65 verified live proxy-list sources (up from 27) — the big GitHub aggregators, per-country slices, high-volume scrapers, and frequently-refreshed APIs — feeding an 80,000-candidate reservoir. Every source is fetched concurrently with its own deadline, so one slow or dead list never blocks the rest.
A faster, always-on checker. Validation now runs with 64 parallel workers and a tight 2.5-second origin-probe deadline (a proxy that works for the provider answers fast; a slow one is dropped quickly). Combined with the origin-aware validation from v0.1.15, the pool continuously re-checks and keeps a full set of proxies that the provider actually accepts. The JSON metadata parser now reads latency from more sources (including the geonode API), so validation starts on the likeliest-good proxies.
Proven at scale. A live benchmark of 100 concurrent agents against OpenCode Zen returned 100/100 HTTP 200 with real completions in ~39s, and the pool was still serving (and learning proven egresses) afterward. A longer sustained run confirms it keeps working past a minute.
Validation
398 unit tests plus the transport, burst, sustained-load, single-instance and dashboard verifiers pass, and the opt-in live benchmark (verify_live_load.py) reports 100/100 successes at 100-agent concurrency.
Downloads
Windows: download and run the standalone .exe. Linux and macOS: download the matching architecture, make it executable with chmod +x, then launch it. The app opens its GUI in your browser. SHA-256 checksums are included.
freepro v0.1.19
v0.1.19 corrects two health-accounting bugs and makes stalled requests traceable.
- Discard background probe results superseded by a newer lease, request outcome, cooldown, or replacement of the same endpoint. A delayed probe can no longer overwrite newer health evidence.
- Track consecutive neutral-check failures separately from the transport score, and reset that streak on successful neutral checks or successful request transport. The retirement message now reflects actual consecutive failed checks.
- Add process-local request IDs and attempt numbers to correlate retries with final client responses, plus phase durations for header waits and transport failures.
- Log malformed inbound HTTP separately, with its read/parser error and confirmation that no upstream request was sent.
- Document the review of the six referenced proxy projects in docs/transport-reliability.md.
Local verification: 398 unit tests and the transport fault suite passed, including stale-result, replacement, failure-streak, and log-correlation regressions. Cross-platform CI checks GUI builds, persistence, proxy faults, concurrent bursts, sustained-load recovery, and single-instance behavior.
This release does not establish a new live Muse Spark latency result, measure public-proxy lifetimes, or demonstrate 100 coding agents running 24/7. It does not expand source lists, change concurrency, or shorten the existing request budget. Provider limits and upstream availability still apply.
Downloads include the standalone Windows executable, Linux x64/ARM64, macOS Intel/Apple Silicon, and SHA256SUMS. Configuration and usage remain in the existing per-user data directory.
freepro v0.1.18
The background proxy checker could wait indefinitely when its direct health-check endpoint accepted a connection but stopped responding. v0.1.18 gives that request a four-second deadline so validation can continue.
Neutral probes now require the endpoint's expected empty HTTP 204. HTML responses, redirects, and inconsistent body framing are rejected instead of treating any 2xx headers as a healthy route. Checker outages continue to avoid penalizing existing routes.
Validation covers a silent local endpoint, valid 204, HTML 200, redirects, invalid content length, and chunked 204, plus the existing transport fault suite. CI runs the GUI builds, unit tests, persistence, concurrent bursts, sustained-load recovery, and single-instance checks on Windows, Linux, and macOS.
This is a transport-check correctness release. It does not add proxy lists, increase per-route concurrency, remove provider rate limits, or claim new Muse Spark latency results. Background checks and sequential reuse already exist; successful probes cannot guarantee future model completions.
Download the standalone Windows executable or the Linux/macOS executable matching your CPU. SHA256SUMS contains the release checksums. Configuration and usage remain in the existing per-user data directory. The app checks for updates at startup.
freepro v0.1.17
100-agent public-proxy routing
A live short-prompt Muse Spark 1.3 contributor-free test submitted 100 requests concurrently and received 100 HTTP 200 responses with nonempty completions. With a 120-second request budget, the batch finished in 60.83 seconds (median 28.59 seconds, p95 57.28 seconds).
Changes
- Prefer routes that completed real model requests. Limit trials of unknown routes and scale those trials with queue pressure, up to eight at once.
- Keep other eligible routes available after IP-based throttles. Count distinct throttled routes correctly; preserve Retry-After and prevent late successes from clearing newer cooldowns.
- Remove synchronous neutral probes after 429/403 responses, eliminating extra network work outside the retry budget.
- Validate anonymous catalogs with a complete JSON response rather than synthetic model traffic or error responses. Own validator configuration safely across provider edits.
- Expose previously successful route capacity separately from transport-validated route counts.
- Use a 120-second request timeout for new configurations and include an opt-in live concurrency benchmark. Existing installations keep their saved setting; set both server and client timeouts to at least 120 seconds for this workload.
Validation
Unit tests, compatibility and persistence checks, catalog rejection and transport fault tests, and 1,536 successful requests with 100 concurrent simulated clients using two reusable routes. Live results describe the tested public pool, not a guaranteed service level: IP quota and public-proxy availability change. A separate 30-second-budget live run completed 60/100 requests, so short client timeouts can still interrupt a large burst.
Downloads
Windows: download and run the standalone .exe. Linux/macOS: download the matching architecture, make it executable with chmod +x, and launch it. Configuration and token history remain in your user-data directory. SHA256SUMS is included.
freepro v0.1.16
No more mass proxy eviction when the checker blips
What you saw: 8 working proxies all "failed the neutral probe" within 6 seconds, then nothing for ~3 minutes. That was a bug, not 8 proxies dying at once: the pool dropped a route on a single neutral-probe failure, and when the validation target (or your network) briefly became unreachable, every idle route failed its one probe and got evicted in a cascade — leaving the pool empty, and it couldn't refill while the target was still down.
The fixes:
- Soft strikes. A route is now dropped only after 4 consecutive neutral-probe failures, not one. A single blip (or a flaky free proxy) no longer evicts it.
- Checker-health gating. Before a validation pass can drop anything, freepro checks that the neutral target is reachable directly (no proxy). If it isn't — the network or checker is down — probe failures are not counted against proxies and nothing is evicted; the existing pool keeps serving and validation simply retries next cycle.
- Recovery unchanged: a success still clears a route's strikes, so a proxy that had a rough patch is kept and re-promoted rather than lost.
Combined with v0.1.15's origin-aware validation, this means: only proxies the provider actually accepts enter the pool, they're only removed when they genuinely fail repeatedly while the checker is healthy, and a checker/network blip can no longer wipe the pool.
Validation
368 unit tests plus the transport, burst, sustained-load, single-instance and dashboard verifiers pass.
Downloads
Windows: download and run the standalone .exe. Linux and macOS: download the matching architecture, make it executable with chmod +x, then launch it. The app opens its GUI in your browser. SHA-256 checksums are included.
freepro v0.1.15
Origin-aware proxy validation: only proxies the provider accepts get used
The real problem, finally fixed. The pool validated proxies against a neutral site (Google's 204 endpoint) — so a proxy that could "reach the internet" passed even if the model provider had rate-limited its IP. Every request through such a proxy then failed with 429. You were right: there was no proper checker for the actual provider.
The fix: when a provider uses public-proxy routing, the pool now validates each candidate against that provider's real chat endpoint with a real model id it serves. A proxy the origin answers 429/403 to (a burned datacenter egress IP) is rejected at validation time and never enters the pool. Only proxies the provider actually accepts are pooled and handed to requests. Idle routes are re-checked the same way, so a proxy the origin starts rate-limiting is dropped.
Verified live against OpenCode Zen: with origin-aware validation the pool admitted only the proxies Zen does not rate-limit, and a real request through the pool returned HTTP 200 with a real completion — instead of cycling through burned IPs and 429ing.
Validation
368 unit tests plus the transport, burst, sustained-load, single-instance and dashboard verifiers pass.
Downloads
Windows: download and run the standalone .exe. Linux and macOS: download the matching architecture, make it executable with chmod +x, then launch it. The app opens its GUI in your browser. SHA-256 checksums are included.
freepro v0.1.14
Proxy pool now avoids egress IPs the origin has rate-limited
What we proved: the proxies are being used — requests through freepro's pool reach the origin from the proxy's egress IP, and some proxies genuinely return HTTP 200 for OpenCode Zen free models. The problem was selection: OpenCode Zen rate-limits by egress IP, and the pool contained many proxies whose egress IPs were already burned (datacenter IPs that return 429). The pool kept cycling through burned IPs while the few working ones sat unused — which is exactly why it looked like "proxies aren't used at all."
The fix (v0.1.14): when a proxied request gets a 429/403 from the origin, the pool now cools every proxy on that same egress IP for 60 seconds — not just the single host:port — so the picker immediately moves to egress IPs the origin accepts. When a request succeeds (2xx) through an IP, all proxies behind it are unblocked and marked preferred, so the working IPs get reused. The pool now learns which egress IPs work for that provider, the same way your VPN does manually.
Verified with live data: through the pool, proxies on clean IPs returned 200 for mimo-v2.5-free while burned datacenter IPs returned 429 — the fix makes the pool prefer the former.
Validation
368 unit tests plus the transport, burst, sustained-load, single-instance and dashboard verifiers pass.
Downloads
Windows: download and run the standalone .exe. Linux and macOS: download the matching architecture, make it executable with chmod +x, then launch it. The app opens its GUI in your browser. SHA-256 checksums are included.
freepro v0.1.13
Proxy-pool robustness: no more worker hostage-taking, working routes stay warm
A deep review of the proxy code turned up two issues that could stall traffic under load or age out good proxies:
1. Requests no longer hold a worker hostage waiting for a proxy (the "pipe" fix).
When the proxy pool was empty/stale, a request could wait up to 30 seconds for a route while occupying one of the 128 worker threads. Under a burst, enough such requests would occupy every worker and the accept loop would backpressure — stalling all traffic, including non-proxy requests and the dashboard. A single proxy-wait is now capped at 3 seconds (attempts still retry within the overall request deadline), so an empty pool can never tie up the whole server.
2. A real success keeps a proxy in rotation.
A successful request through a proxy now refreshes its validation freshness (same as a clean neutral probe). Previously a working proxy could be aged out and re-probed even though real traffic through it was succeeding, and a proxy that silently degraded stayed pickable until a real request failed. Now the pool keeps reliably-working proxies warm and reuses them.
Also from the review: the 429 circuit-breaker deadlock from v0.1.12 is confirmed fixed, per-attempt retries correctly avoid already-tried proxies, and the request deadline is shared (not per-attempt), so nothing can stack timeouts.
Validation
365 unit tests plus the transport, burst, sustained-load, single-instance and dashboard verifiers pass.
Downloads
Windows: download and run the standalone .exe. Linux and macOS: download the matching architecture, make it executable with chmod +x, then launch it. The app opens its GUI in your browser. SHA-256 checksums are included.
freepro v0.1.12
Fixes the proxy pool deadlocking on a provider that keeps rate-limiting
What you saw: after a few minutes under a 429 flood, every request was rejected in 2–80ms with "origin still rate-limiting" and it never recovered — even after the origin's rate-limit should have passed.
Root cause: a self-inflicted deadlock in the circuit breaker. When a provider kept returning 429, each 429 cooled the route — and that cooling was also extending the provider's breaker open-window by 8s on every single 429. Since 429s kept arriving faster than the window expired, the breaker was perpetually re-armed and never closed. Once it was open, every request was skipped instantly (OriginThrottled), so nothing ever got through to succeed and clear it → permanent 429 wall.
The fix: cooling a route no longer extends the breaker. The breaker opens for its fixed short window, then closes and lets a request through. If the origin still 429s, it re-trips (correct — the origin really is throttling); if the origin has recovered, the first attempt succeeds and clears the breaker, and traffic flows again.
Added a regression test asserting that repeated route-cooling never keeps the provider breaker open.
Validation
362 unit tests plus the transport, burst, sustained-load, single-instance and dashboard verifiers pass.
Downloads
Windows: download and run the standalone .exe. Linux and macOS: download the matching architecture, make it executable with chmod +x, then launch it. The app opens its GUI in your browser. SHA-256 checksums are included.