Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

build(model-hub): cut model-hub-engine-v8.0.23-2 with an HTTP/2 health check on the Codex uTLS connection (#2488)

Call Whitebabe8f25d6a3
diff --git a/patches/model-hub-cpa-v8.0.23/README.md b/patches/model-hub-cpa-v8.0.23/README.md
index 5b9db60a2..d330628ef 100644
--- a/patches/model-hub-cpa-v8.0.23/README.md
+++ b/patches/model-hub-cpa-v8.0.23/README.md
@@ -1,7 +1,7 @@
# Avibe-owned CPA v8.0.23 compatibility patches
This directory records the source patches carried by Avibe's
-`model-hub-engine-v8.0.23-1` build. Each patch applies independently to the
+`model-hub-engine-v8.0.23-2` build. Each patch applies independently to the
pinned source; the build applies them in the order the manifest's
`build.patches` records.
@@ -30,6 +30,13 @@ The patch is limited to the helper used by both OpenAI Chat execution paths
byte-identical between v8.0.20 and v8.0.23 and differs from v7.3.16 only in
its module import path, outside the patched hunk.
+The patch also updates the three `useMaxCompletionTokens=false` cases of
+upstream's `TestNormalizeOpenAIMaxTokens`, which asserted the stock rewrite,
+to assert this contract: the payload, including a `null` limit, is returned
+unchanged. With all patches applied,
+`go test ./internal/runtime/executor/helps/` passes. The test change does not
+alter the engine binary.
+
## `oauth-callback-forwarder-loopback.patch`
Avibe starts every redirect-based subscription login (Claude, Codex,
@@ -80,6 +87,42 @@ probe answers, then narrowed to the entitled set. With both patches applied,
Drop the patch once router-for-me/CLIProxyAPI#6531 is fixed upstream.
+## `codex-utls-h2-ping-health-check.patch`
+
+Codex subscription requests to `https://chatgpt.com` go through a dedicated
+Chrome uTLS connection per request. When ALPN selects HTTP/2, stock CPA wraps
+that connection in a zero-value `http2.Transport{}`: no PING health check, no
+client timeout, nothing that bounds the body read. A path that stops
+delivering packets without a FIN or RST reaching the engine, which a NAT or a
+TCP-terminating proxy can leave behind and TCP keepalive cannot see past,
+therefore blocks the stream until the caller gives up. Avibe's turns then
+waited out their 600-second bound with no byte and no error. The same code is
+in v7.3.16, so this is not a v8 regression.
+
+The patch sets `ReadIdleTimeout` 30 s and `PingTimeout` 15 s on that
+connection's `http2.Transport` only. After 30 s without a frame the transport
+sends one PING and closes the connection when no ACK arrives within 15 s, so
+the stream fails with an in-stream `request_timeout` error at about 45 s.
+Model Hub's recovery then retries on a new connection. A live upstream that
+is silent, for example during a long reasoning phase, acknowledges the PING
+and is not cut; an active stream sends no PING. The shared transports, the
+proxy transports, the HTTP/1.1 Claude round tripper and the WebSocket path
+are untouched. The patch adds `utls_client_health_test.go`: a dead path fails
+the stream, and a silent healthy stream survives ten idle periods.
+
+Measured on the shipped v8.0.23 engine on the uTLS HTTP/2 path through a
+black-holing CONNECT proxy: stock sent no byte and no error for 9 min 38 s,
+until it was killed; patched sent `event: error` (`request_timeout`) at
+45.0 s. A live stream silent for 120 s completed on both.
+
+Upstream: router-for-me/CLIProxyAPI#6535. Upstream made the health check an
+opt-in setting, `streaming.http2-health-check-seconds`
+(`requests.streaming.http2-health-check-seconds` in the v8 layout), which
+defaults to 0, off. This patch stays unconditional. Once a tagged CPA release
+that Avibe adopts contains that setting, drop this patch and render
+`http2-health-check-seconds: 30` in `vibe/model_hub_runtime/config.py`
+alongside the other fixed keys, in the layout that config uses.
+
## Rebuild
The repository-owned release path checks out `source_sha`, applies the
diff --git a/patches/model-hub-cpa-v8.0.23/codex-utls-h2-ping-health-check.patch b/patches/model-hub-cpa-v8.0.23/codex-utls-h2-ping-health-check.patch
new file mode 100644
index 000000000..6dcb0aa44
--- /dev/null
+++ b/patches/model-hub-cpa-v8.0.23/codex-utls-h2-ping-health-check.patch
@@ -0,0 +1,236 @@
+diff --git a/internal/runtime/executor/helps/utls_client.go b/internal/runtime/executor/helps/utls_client.go
+index f832748b..0344b41a 100644
+--- a/internal/runtime/executor/helps/utls_client.go
++++ b/internal/runtime/executor/helps/utls_client.go
+@@ -29,6 +29,17 @@ type utlsRoundTripper struct {
+ dialer proxy.Dialer
+ }
+
++// utlsHTTP2ReadIdleTimeout and utlsHTTP2PingTimeout turn on the HTTP/2 health check for the dedicated
++// uTLS connection: after ReadIdleTimeout without a frame the transport sends a PING, and closes the
++// connection if no PING ACK arrives within PingTimeout. Without it, a stream whose path stopped
++// delivering packets without a FIN or RST - which a NAT or a TCP-terminating proxy can leave behind,
++// and which TCP keepalive cannot see past - blocks its body read until the caller gives up. A silent
++// but live upstream acknowledges the PING, so long reasoning pauses are not cut.
++var (
++ utlsHTTP2ReadIdleTimeout = 30 * time.Second
++ utlsHTTP2PingTimeout = 15 * time.Second
++)
++
+ type closeConnectionBody struct {
+ io.ReadCloser
+ closeConnection func() error
+@@ -123,7 +134,8 @@ func roundTripUtlsConnection(req *http.Request, tlsConn *tls.UConn) (*http.Respo
+ var err error
+ switch protocol := tlsConn.ConnectionState().NegotiatedProtocol; protocol {
+ case "h2":
+- h2Conn, errClientConn := (&http2.Transport{}).NewClientConn(tlsConn)
++ h2Transport := &http2.Transport{ReadIdleTimeout: utlsHTTP2ReadIdleTimeout, PingTimeout: utlsHTTP2PingTimeout}
++ h2Conn, errClientConn := h2Transport.NewClientConn(tlsConn)
+ if errClientConn != nil {
+ err = fmt.Errorf("utls: initialize HTTP/2 connection: %w", errClientConn)
+ break
+diff --git a/internal/runtime/executor/helps/utls_client_health_test.go b/internal/runtime/executor/helps/utls_client_health_test.go
+new file mode 100644
+index 00000000..2368c5d5
+--- /dev/null
++++ b/internal/runtime/executor/helps/utls_client_health_test.go
+@@ -0,0 +1,198 @@
++package helps
++
++import (
++ "bufio"
++ stdtls "crypto/tls"
++ "crypto/x509"
++ "errors"
++ "net"
++ "net/http"
++ "net/http/httptest"
++ "net/url"
++ "strings"
++ "sync"
++ "testing"
++ "time"
++
++ tls "github.com/refraction-networking/utls"
++)
++
++// deadPathConn models a connection whose far side stopped answering without a FIN or RST, as a NAT or
++// a TCP-terminating proxy can leave it: after stall, writes are accepted and dropped and reads block
++// until the connection is closed locally.
++type deadPathConn struct {
++ net.Conn
++ mu sync.Mutex
++ stalled bool
++ closed chan struct{}
++ once sync.Once
++}
++
++func newDeadPathConn(conn net.Conn) *deadPathConn {
++ return &deadPathConn{Conn: conn, closed: make(chan struct{})}
++}
++
++func (c *deadPathConn) stall() {
++ c.mu.Lock()
++ c.stalled = true
++ c.mu.Unlock()
++}
++
++func (c *deadPathConn) isStalled() bool {
++ c.mu.Lock()
++ defer c.mu.Unlock()
++ return c.stalled
++}
++
++func (c *deadPathConn) Read(p []byte) (int, error) {
++ if c.isStalled() {
++ <-c.closed
++ return 0, net.ErrClosed
++ }
++ return c.Conn.Read(p)
++}
++
++func (c *deadPathConn) Write(p []byte) (int, error) {
++ if c.isStalled() {
++ return len(p), nil
++ }
++ return c.Conn.Write(p)
++}
++
++func (c *deadPathConn) Close() error {
++ c.once.Do(func() { close(c.closed) })
++ return c.Conn.Close()
++}
++
++// newALPNTestConnectionThrough is newALPNTestConnection with the client's TCP connection wrapped
++// before the TLS handshake, so a test can model the network path under the TLS session.
++func newALPNTestConnectionThrough(t *testing.T, protocol string, handler http.Handler, wrap func(net.Conn) net.Conn) (*tls.UConn, string) {
++ t.Helper()
++ server := httptest.NewUnstartedServer(handler)
++ server.EnableHTTP2 = protocol == "h2"
++ server.TLS = &stdtls.Config{NextProtos: []string{protocol}}
++ server.StartTLS()
++ t.Cleanup(server.Close)
++ rootCAs := x509.NewCertPool()
++ rootCAs.AddCert(server.Certificate())
++ serverURL, errParse := url.Parse(server.URL)
++ if errParse != nil {
++ t.Fatal(errParse)
++ }
++ conn, errDial := (&net.Dialer{}).DialContext(t.Context(), "tcp", serverURL.Host)
++ if errDial != nil {
++ t.Fatal(errDial)
++ }
++ tlsConn := tls.UClient(wrap(conn), &tls.Config{ServerName: serverURL.Hostname(), RootCAs: rootCAs}, tls.HelloChrome_Auto)
++ t.Cleanup(func() { _ = tlsConn.Close() })
++ if errHandshake := tlsConn.HandshakeContext(t.Context()); errHandshake != nil {
++ t.Fatal(errHandshake)
++ }
++ if got := tlsConn.ConnectionState().NegotiatedProtocol; got != protocol {
++ t.Fatalf("negotiated protocol = %q, want %q", got, protocol)
++ }
++ return tlsConn, server.URL
++}
++
++// shortenUtlsHTTP2HealthCheck makes the health check ping after 100ms without a frame. The PING timeout
++// stays generous, so a slow ACK on a loaded machine cannot fail a healthy connection.
++func shortenUtlsHTTP2HealthCheck(t *testing.T) {
++ t.Helper()
++ readIdle, ping := utlsHTTP2ReadIdleTimeout, utlsHTTP2PingTimeout
++ utlsHTTP2ReadIdleTimeout, utlsHTTP2PingTimeout = 100*time.Millisecond, time.Second
++ t.Cleanup(func() { utlsHTTP2ReadIdleTimeout, utlsHTTP2PingTimeout = readIdle, ping })
++}
++
++// sseUntilReleased writes one event, then holds the stream open and silent until release closes,
++// and then writes a second event.
++func sseUntilReleased(t *testing.T, release <-chan struct{}) http.Handler {
++ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
++ w.Header().Set("Content-Type", "text/event-stream")
++ if _, errWrite := w.Write([]byte("data: {\"type\":\"response.created\"}\n\n")); errWrite != nil {
++ t.Errorf("write first event: %v", errWrite)
++ return
++ }
++ w.(http.Flusher).Flush()
++ select {
++ case <-release:
++ case <-r.Context().Done():
++ return
++ }
++ if _, errWrite := w.Write([]byte("data: {\"type\":\"response.completed\"}\n\n")); errWrite == nil {
++ w.(http.Flusher).Flush()
++ }
++ })
++}
++
++func TestUtlsHTTP2StreamFailsWhenThePathGoesDead(t *testing.T) {
++ shortenUtlsHTTP2HealthCheck(t)
++ release := make(chan struct{})
++ t.Cleanup(func() { close(release) })
++ var path *deadPathConn
++ tlsConn, serverURL := newALPNTestConnectionThrough(t, "h2", sseUntilReleased(t, release), func(conn net.Conn) net.Conn {
++ path = newDeadPathConn(conn)
++ return path
++ })
++ req, errRequest := http.NewRequestWithContext(t.Context(), http.MethodPost, serverURL, strings.NewReader("{}"))
++ if errRequest != nil {
++ t.Fatal(errRequest)
++ }
++ resp, errRoundTrip := roundTripUtlsConnection(req, tlsConn)
++ if errRoundTrip != nil {
++ t.Fatal(errRoundTrip)
++ }
++ defer func() { _ = resp.Body.Close() }()
++ reader := bufio.NewReader(resp.Body)
++ if line, errRead := reader.ReadString('\n'); errRead != nil || !strings.Contains(line, "response.created") {
++ t.Fatalf("first line = %q, error = %v", line, errRead)
++ }
++ path.stall()
++ started := time.Now()
++ done := make(chan error, 1)
++ go func() {
++ _, errRead := reader.ReadString('\n')
++ for errRead == nil {
++ _, errRead = reader.ReadString('\n')
++ }
++ done <- errRead
++ }()
++ select {
++ case errRead := <-done:
++ if errRead == nil || errors.Is(errRead, http.ErrBodyReadAfterClose) {
++ t.Fatalf("read error = %v, want a lost-connection error", errRead)
++ }
++ t.Logf("dead path detected after %v: %v", time.Since(started), errRead)
++ case <-time.After(10 * time.Second):
++ t.Fatal("stream read still blocked on a dead path; the HTTP/2 health check did not close the connection")
++ }
++}
++
++func TestUtlsHTTP2HealthCheckKeepsASilentHealthyStream(t *testing.T) {
++ shortenUtlsHTTP2HealthCheck(t)
++ release := make(chan struct{})
++ tlsConn, _, serverURL := newALPNTestConnection(t, "h2", sseUntilReleased(t, release))
++ req, errRequest := http.NewRequestWithContext(t.Context(), http.MethodPost, serverURL, strings.NewReader("{}"))
++ if errRequest != nil {
++ t.Fatal(errRequest)
++ }
++ resp, errRoundTrip := roundTripUtlsConnection(req, tlsConn)
++ if errRoundTrip != nil {
++ t.Fatal(errRoundTrip)
++ }
++ defer func() { _ = resp.Body.Close() }()
++ reader := bufio.NewReader(resp.Body)
++ if line, errRead := reader.ReadString('\n'); errRead != nil || !strings.Contains(line, "response.created") {
++ t.Fatalf("first line = %q, error = %v", line, errRead)
++ }
++ // Ten health-check periods of silence: the server answers each PING, so the stream survives.
++ time.AfterFunc(10*utlsHTTP2ReadIdleTimeout, func() { close(release) })
++ for {
++ line, errRead := reader.ReadString('\n')
++ if errRead != nil {
++ t.Fatalf("silent healthy stream failed: %v", errRead)
++ }
++ if strings.Contains(line, "response.completed") {
++ return
++ }
++ }
++}
diff --git a/patches/model-hub-cpa-v8.0.23/openai-compat-native-token-field.patch b/patches/model-hub-cpa-v8.0.23/openai-compat-native-token-field.patch
index fedf3bd2c..ff0773405 100644
--- a/patches/model-hub-cpa-v8.0.23/openai-compat-native-token-field.patch
+++ b/patches/model-hub-cpa-v8.0.23/openai-compat-native-token-field.patch
@@ -1,9 +1,8 @@
diff --git a/internal/runtime/executor/helps/openai_compat_max_tokens.go b/internal/runtime/executor/helps/openai_compat_max_tokens.go
-index 71915c5b..9819da97 100644
+index 71915c5..9819da9 100644
--- a/internal/runtime/executor/helps/openai_compat_max_tokens.go
+++ b/internal/runtime/executor/helps/openai_compat_max_tokens.go
-@@ -55,6 +55,13 @@ func NormalizeOpenAIMaxTokens(payload []byte, useMaxCompletionTokens bool) []byte
- if !hasMaxTokens && !hasMaxCompletionTokens {
+@@ -55,6 +55,13 @@ func NormalizeOpenAIMaxTokens(payload []byte, useMaxCompletionTokens bool) []byt
return payload
}
@@ -17,4 +16,56 @@ index 71915c5b..9819da97 100644
if useMaxCompletionTokens {
if hasMaxTokens && !hasMaxCompletionTokens {
val := gjson.GetBytes(payload, "max_tokens")
- if val.Raw != "" {
+diff --git a/internal/runtime/executor/helps/openai_compat_max_tokens_test.go b/internal/runtime/executor/helps/openai_compat_max_tokens_test.go
+index f1bd20a..4f06037 100644
+--- a/internal/runtime/executor/helps/openai_compat_max_tokens_test.go
++++ b/internal/runtime/executor/helps/openai_compat_max_tokens_test.go
+@@ -147,27 +147,22 @@ func TestNormalizeOpenAIMaxTokens(t *testing.T) {
+ }
+ })
+
+- t.Run("useMaxCompletionTokens=false converts max_completion_tokens to max_tokens", func(t *testing.T) {
++ // Avibe: false leaves the caller's native field unchanged.
++ t.Run("useMaxCompletionTokens=false keeps native max_completion_tokens", func(t *testing.T) {
+ input := []byte(`{"model":"deepseek","max_completion_tokens":1024,"messages":[]}`)
+ got := NormalizeOpenAIMaxTokens(input, false)
+
+- if v := gjson.GetBytes(got, "max_tokens"); !v.Exists() || v.Int() != 1024 {
+- t.Fatalf("max_tokens = %v, want 1024; out=%s", v, string(got))
+- }
+- if gjson.GetBytes(got, "max_completion_tokens").Exists() {
+- t.Fatalf("max_completion_tokens should be deleted; out=%s", string(got))
++ if string(got) != string(input) {
++ t.Fatalf("payload changed; out=%s", string(got))
+ }
+ })
+
+- t.Run("useMaxCompletionTokens=false preserves existing max_tokens and removes max_completion_tokens", func(t *testing.T) {
++ t.Run("useMaxCompletionTokens=false keeps both native fields", func(t *testing.T) {
+ input := []byte(`{"model":"deepseek","max_tokens":512,"max_completion_tokens":2048}`)
+ got := NormalizeOpenAIMaxTokens(input, false)
+
+- if v := gjson.GetBytes(got, "max_tokens"); !v.Exists() || v.Int() != 512 {
+- t.Fatalf("max_tokens = %v, want 512; out=%s", v, string(got))
+- }
+- if gjson.GetBytes(got, "max_completion_tokens").Exists() {
+- t.Fatalf("max_completion_tokens should be deleted; out=%s", string(got))
++ if string(got) != string(input) {
++ t.Fatalf("payload changed; out=%s", string(got))
+ }
+ })
+
+@@ -199,11 +194,8 @@ func TestNormalizeOpenAIMaxTokens(t *testing.T) {
+ input := []byte(`{"model":"deepseek","max_completion_tokens":null}`)
+ got := NormalizeOpenAIMaxTokens(input, false)
+
+- if v := gjson.GetBytes(got, "max_tokens"); !v.Exists() || v.Type != gjson.Null {
+- t.Fatalf("max_tokens = %v, want null; out=%s", v, string(got))
+- }
+- if gjson.GetBytes(got, "max_completion_tokens").Exists() {
+- t.Fatalf("max_completion_tokens should be deleted; out=%s", string(got))
++ if string(got) != string(input) {
++ t.Fatalf("payload changed; out=%s", string(got))
+ }
+ })
+
diff --git a/tests/test_model_hub_runtime.py b/tests/test_model_hub_runtime.py
index ee4be9c27..1f97863fd 100644
--- a/tests/test_model_hub_runtime.py
+++ b/tests/test_model_hub_runtime.py
@@ -899,39 +899,39 @@ def test_packaged_manifest_matches_frozen_runtime_dependency_values(
"assets": [
{
"platform": "darwin-arm64",
- "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-1/CLIProxyAPI_8.0.23_darwin_aarch64.tar.gz",
- "size_bytes": 40511180,
- "sha256": "bd863d04d950390b745dd4414ea8c8be715cb5c21b492d3c0d71504f64fca978",
+ "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-2/CLIProxyAPI_8.0.23_darwin_aarch64.tar.gz",
+ "size_bytes": 40514706,
+ "sha256": "db6e2e1622a066c1f407dd2c5ce0d2676cdf81b713dbf84f2afd48768015e360",
},
{
"platform": "darwin-x64",
- "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-1/CLIProxyAPI_8.0.23_darwin_amd64.tar.gz",
- "size_bytes": 42973748,
- "sha256": "eda0092a9d1afecf8471fc95e4c077825a3db8059df7caa6a06816a2a8a438eb",
+ "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-2/CLIProxyAPI_8.0.23_darwin_amd64.tar.gz",
+ "size_bytes": 42974424,
+ "sha256": "defbe2074ea70f578db2f0ddaa436327cc2b434730df75e01f5f8dcfecfea6cd",
},
{
"platform": "linux-amd64",
- "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-1/CLIProxyAPI_8.0.23_linux_amd64.tar.gz",
- "size_bytes": 40932246,
- "sha256": "e72351f5280f943233c9ddc8ab9f51556f57e9f95d68bf13a15b141a95e48b65",
+ "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-2/CLIProxyAPI_8.0.23_linux_amd64.tar.gz",
+ "size_bytes": 40932273,
+ "sha256": "254b71f4c72b6b56766fd5625b7d16356cd9cc389f5cd35ef24c0470c937fd8f",
},
{
"platform": "linux-arm64",
- "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-1/CLIProxyAPI_8.0.23_linux_aarch64.tar.gz",
- "size_bytes": 37548183,
- "sha256": "ca06e508c654d6c8cfc5af44341eeac339e0a033d217a480c44043b8e8c81ebc",
+ "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-2/CLIProxyAPI_8.0.23_linux_aarch64.tar.gz",
+ "size_bytes": 37547515,
+ "sha256": "4d89ec9733c3953243fd852d509bb913a782eb2bedf6ba81b0347bb5e998bf39",
},
{
"platform": "windows-amd64",
- "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-1/CLIProxyAPI_8.0.23_windows_amd64.tar.gz",
- "size_bytes": 41444644,
- "sha256": "7d138744b44a7ee103f15d065712f97798db0259cdafce2a93819b4135b69006",
+ "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-2/CLIProxyAPI_8.0.23_windows_amd64.tar.gz",
+ "size_bytes": 41444643,
+ "sha256": "3eab3dbb539d5c88ae78231de92ceff33988ab847c1e67f282599b98022b7d77",
},
{
"platform": "windows-arm64",
- "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-1/CLIProxyAPI_8.0.23_windows_aarch64.tar.gz",
- "size_bytes": 37803078,
- "sha256": "969997f1dbe169c83e227def75ca51e105aafb9f3d30bb3bb615685fc289b525",
+ "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-2/CLIProxyAPI_8.0.23_windows_aarch64.tar.gz",
+ "size_bytes": 37803292,
+ "sha256": "95e31d67a229908d7ce52da2cf1e1b54fa70201a14a040945cee9a021ac2d719",
},
],
}
@@ -1434,45 +1434,45 @@ def test_installing_projection_matches_live_owner_or_resumable_claim(
"darwin-arm64",
False,
"darwin-arm64",
- 40511180,
- "bd863d04d950390b745dd4414ea8c8be715cb5c21b492d3c0d71504f64fca978",
- "f953540b126b220352bb66991e9f8d1c29cf18054f4c75f17e49a7d73fb17e19",
+ 40514706,
+ "db6e2e1622a066c1f407dd2c5ce0d2676cdf81b713dbf84f2afd48768015e360",
+ "6a908bde31115b913b5c71a2f149805f8a976025459950ff6e8f6f0eb05767e4",
"cli-proxy-api",
),
(
"darwin-x64",
False,
"darwin-x64",
- 42973748,
- "eda0092a9d1afecf8471fc95e4c077825a3db8059df7caa6a06816a2a8a438eb",
- "f279440f5689b15f322bb9c4116fcf8434d0b48bfcac2c2f2e089557e6f59f36",
+ 42974424,
+ "defbe2074ea70f578db2f0ddaa436327cc2b434730df75e01f5f8dcfecfea6cd",
+ "569b1bb7e4a6d698dda66337ba4ae47e4b3ec2662466b7cdceb98bebd63a5e3a",
"cli-proxy-api",
),
(
"linux-x64",
False,
"linux-amd64",
- 40932246,
- "e72351f5280f943233c9ddc8ab9f51556f57e9f95d68bf13a15b141a95e48b65",
- "fa7fa7cd0289a4912587764c535adcd06a41fe1fb0dc92193925883bbfe8b3a1",
+ 40932273,
+ "254b71f4c72b6b56766fd5625b7d16356cd9cc389f5cd35ef24c0470c937fd8f",
+ "197eec804e0be5264ad5e75a8c1552e601de456d9296cb1ec2e0ac6f6f16f89b",
"cli-proxy-api",
),
(
"linux-arm64",
False,
"linux-arm64",
- 37548183,
- "ca06e508c654d6c8cfc5af44341eeac339e0a033d217a480c44043b8e8c81ebc",
- "5a514166e95e35b53a846030ab3cb4af5a1c52c06df2c3db8c764adde1bc6178",
+ 37547515,
+ "4d89ec9733c3953243fd852d509bb913a782eb2bedf6ba81b0347bb5e998bf39",
+ "e824efc5b7dface33993fd2d2634e8c3243feafc2f56a6e220fb7aef2f24419f",
"cli-proxy-api",
),
(
"win32-x64",
False,
"windows-amd64",
- 41444644,
- "7d138744b44a7ee103f15d065712f97798db0259cdafce2a93819b4135b69006",
- "c265136d64bc6fdb7a4737e28333ff58ed995407d50b0581857e6693a2952a32",
+ 41444643,
+ "3eab3dbb539d5c88ae78231de92ceff33988ab847c1e67f282599b98022b7d77",
+ "5fc8d17e4a63e996de1de59324dcb016b994442d9efca95ad52f00aa2f32b98f",
"cli-proxy-api.exe",
),
# x64 Python on Windows on Arm still gets the native engine.
@@ -1480,18 +1480,18 @@ def test_installing_projection_matches_live_owner_or_resumable_claim(
"win32-x64",
True,
"windows-arm64",
- 37803078,
- "969997f1dbe169c83e227def75ca51e105aafb9f3d30bb3bb615685fc289b525",
- "0ba1b87a3c562f5121f2902507e6608713237a3daafa229bca5b4829b29c29ec",
+ 37803292,
+ "95e31d67a229908d7ce52da2cf1e1b54fa70201a14a040945cee9a021ac2d719",
+ "6bb5c1dde91a272da2f517f2f987bebfa5e82e9193b0636824d4164631ec10e2",
"cli-proxy-api.exe",
),
(
"win32-arm64",
True,
"windows-arm64",
- 37803078,
- "969997f1dbe169c83e227def75ca51e105aafb9f3d30bb3bb615685fc289b525",
- "0ba1b87a3c562f5121f2902507e6608713237a3daafa229bca5b4829b29c29ec",
+ 37803292,
+ "95e31d67a229908d7ce52da2cf1e1b54fa70201a14a040945cee9a021ac2d719",
+ "6bb5c1dde91a272da2f517f2f987bebfa5e82e9193b0636824d4164631ec10e2",
"cli-proxy-api.exe",
),
],
diff --git a/vibe/model_hub_runtime/cliproxyapi_manifest.json b/vibe/model_hub_runtime/cliproxyapi_manifest.json
index 8163b4171..a8c02e6f4 100644
--- a/vibe/model_hub_runtime/cliproxyapi_manifest.json
+++ b/vibe/model_hub_runtime/cliproxyapi_manifest.json
@@ -6,55 +6,55 @@
"source_url": "https://github.com/router-for-me/CLIProxyAPI/tree/d318bcc3afb9ea8782862f5e8cdb541afdc9dfa5",
"source_sha": "d318bcc3afb9ea8782862f5e8cdb541afdc9dfa5",
"release_tag": "v8.0.23",
- "asset_release_tag": "model-hub-engine-v8.0.23-1",
+ "asset_release_tag": "model-hub-engine-v8.0.23-2",
"license": "MIT",
"assets": [
{
"platform": "darwin-arm64",
- "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-1/CLIProxyAPI_8.0.23_darwin_aarch64.tar.gz",
- "size_bytes": 40511180,
- "sha256": "bd863d04d950390b745dd4414ea8c8be715cb5c21b492d3c0d71504f64fca978",
- "binary_sha256": "f953540b126b220352bb66991e9f8d1c29cf18054f4c75f17e49a7d73fb17e19",
+ "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-2/CLIProxyAPI_8.0.23_darwin_aarch64.tar.gz",
+ "size_bytes": 40514706,
+ "sha256": "db6e2e1622a066c1f407dd2c5ce0d2676cdf81b713dbf84f2afd48768015e360",
+ "binary_sha256": "6a908bde31115b913b5c71a2f149805f8a976025459950ff6e8f6f0eb05767e4",
"bin_path": "cli-proxy-api"
},
{
"platform": "darwin-x64",
- "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-1/CLIProxyAPI_8.0.23_darwin_amd64.tar.gz",
- "size_bytes": 42973748,
- "sha256": "eda0092a9d1afecf8471fc95e4c077825a3db8059df7caa6a06816a2a8a438eb",
- "binary_sha256": "f279440f5689b15f322bb9c4116fcf8434d0b48bfcac2c2f2e089557e6f59f36",
+ "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-2/CLIProxyAPI_8.0.23_darwin_amd64.tar.gz",
+ "size_bytes": 42974424,
+ "sha256": "defbe2074ea70f578db2f0ddaa436327cc2b434730df75e01f5f8dcfecfea6cd",
+ "binary_sha256": "569b1bb7e4a6d698dda66337ba4ae47e4b3ec2662466b7cdceb98bebd63a5e3a",
"bin_path": "cli-proxy-api"
},
{
"platform": "linux-amd64",
- "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-1/CLIProxyAPI_8.0.23_linux_amd64.tar.gz",
- "size_bytes": 40932246,
- "sha256": "e72351f5280f943233c9ddc8ab9f51556f57e9f95d68bf13a15b141a95e48b65",
- "binary_sha256": "fa7fa7cd0289a4912587764c535adcd06a41fe1fb0dc92193925883bbfe8b3a1",
+ "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-2/CLIProxyAPI_8.0.23_linux_amd64.tar.gz",
+ "size_bytes": 40932273,
+ "sha256": "254b71f4c72b6b56766fd5625b7d16356cd9cc389f5cd35ef24c0470c937fd8f",
+ "binary_sha256": "197eec804e0be5264ad5e75a8c1552e601de456d9296cb1ec2e0ac6f6f16f89b",
"bin_path": "cli-proxy-api"
},
{
"platform": "linux-arm64",
- "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-1/CLIProxyAPI_8.0.23_linux_aarch64.tar.gz",
- "size_bytes": 37548183,
- "sha256": "ca06e508c654d6c8cfc5af44341eeac339e0a033d217a480c44043b8e8c81ebc",
- "binary_sha256": "5a514166e95e35b53a846030ab3cb4af5a1c52c06df2c3db8c764adde1bc6178",
+ "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-2/CLIProxyAPI_8.0.23_linux_aarch64.tar.gz",
+ "size_bytes": 37547515,
+ "sha256": "4d89ec9733c3953243fd852d509bb913a782eb2bedf6ba81b0347bb5e998bf39",
+ "binary_sha256": "e824efc5b7dface33993fd2d2634e8c3243feafc2f56a6e220fb7aef2f24419f",
"bin_path": "cli-proxy-api"
},
{
"platform": "windows-amd64",
- "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-1/CLIProxyAPI_8.0.23_windows_amd64.tar.gz",
- "size_bytes": 41444644,
- "sha256": "7d138744b44a7ee103f15d065712f97798db0259cdafce2a93819b4135b69006",
- "binary_sha256": "c265136d64bc6fdb7a4737e28333ff58ed995407d50b0581857e6693a2952a32",
+ "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-2/CLIProxyAPI_8.0.23_windows_amd64.tar.gz",
+ "size_bytes": 41444643,
+ "sha256": "3eab3dbb539d5c88ae78231de92ceff33988ab847c1e67f282599b98022b7d77",
+ "binary_sha256": "5fc8d17e4a63e996de1de59324dcb016b994442d9efca95ad52f00aa2f32b98f",
"bin_path": "cli-proxy-api.exe"
},
{
"platform": "windows-arm64",
- "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-1/CLIProxyAPI_8.0.23_windows_aarch64.tar.gz",
- "size_bytes": 37803078,
- "sha256": "969997f1dbe169c83e227def75ca51e105aafb9f3d30bb3bb615685fc289b525",
- "binary_sha256": "0ba1b87a3c562f5121f2902507e6608713237a3daafa229bca5b4829b29c29ec",
+ "url": "https://github.com/avibe-bot/avibe/releases/download/model-hub-engine-v8.0.23-2/CLIProxyAPI_8.0.23_windows_aarch64.tar.gz",
+ "size_bytes": 37803292,
+ "sha256": "95e31d67a229908d7ce52da2cf1e1b54fa70201a14a040945cee9a021ac2d719",
+ "binary_sha256": "6bb5c1dde91a272da2f517f2f987bebfa5e82e9193b0636824d4164631ec10e2",
"bin_path": "cli-proxy-api.exe"
}
],
@@ -67,7 +67,7 @@
"patches": [
{
"path": "patches/model-hub-cpa-v8.0.23/openai-compat-native-token-field.patch",
- "sha256": "b2b80bb2c10887926c467f3088b2c16c5c048714a4bbb8f3c0b6a237c65c9675"
+ "sha256": "a631a1714f5becd51a88e570799f4f2666ca7be9d5d65e15681b10ef125d4dc3"
},
{
"path": "patches/model-hub-cpa-v8.0.23/oauth-callback-forwarder-loopback.patch",
@@ -76,6 +76,10 @@
{
"path": "patches/model-hub-cpa-v8.0.23/antigravity-static-catalog-until-probe.patch",
"sha256": "d6e0c77a0271f5671ba8090e0f14d91bb293a50cfa4d5127dd15e87bd0619d19"
+ },
+ {
+ "path": "patches/model-hub-cpa-v8.0.23/codex-utls-h2-ping-health-check.patch",
+ "sha256": "eca61db9f3e29dadb714dc8f7a2c22bc0104216459c37356d59d12ca048c6b74"
}
],
"source_date_epoch": 0