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.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
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.mdindex 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 patchesThis 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 thepinned 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 pathsbyte-identical between v8.0.20 and v8.0.23 and differs from v7.3.16 only inits 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.+## RebuildThe repository-owned release path checks out `source_sha`, applies thediff --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.patchnew file mode 100644index 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.patchindex 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) []bytreturn payload}@@ -17,4 +16,56 @@ index 71915c5b..9819da97 100644if 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.pyindex 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.jsonindex 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