Merge upstream v8.0.44 into the fork (HOUSE-79)

AGENTS.md

@@ -52,6 +52,7 @@ go build -o test-output ./cmd/server && rm test-output # Verify compile (REQUIRE
 - As a rule, do not make standalone changes to `internal/translator/`. You may modify it only as part of broader changes elsewhere.
 - If a task requires changing only `internal/translator/`, run `gh repo view --json viewerPermission -q .viewerPermission` to confirm you have `WRITE`, `MAINTAIN`, or `ADMIN`. If you do, you may proceed; otherwise, file a GitHub issue including the goal, rationale, and the intended implementation code, then stop further work.
 - `internal/runtime/executor/` should contain executors and their unit tests only. Place any helper/supporting files under `internal/runtime/executor/helps/`.
+- Payload configuration MUST be the final semantic barrier before sending requests in every executor, including streaming, WebSocket, continuation, retry/fallback, image, and token-count paths where applicable. Complete all built-in payload translation, normalization, injection, and cleanup first, then evaluate and apply user payload rules exactly once to the final business payload. No subsequent logic may overwrite configured values or restore filtered fields. Only necessary transport framing, serialization, signature calculation, and read-only validation may follow without changing business payload semantics. Add regression tests when introducing or changing request-building paths to enforce this ordering.
 - Follow `gofmt`; keep imports goimports-style; wrap errors with context where helpful
 - Do not use `log.Fatal`/`log.Fatalf` (terminates the process); prefer returning errors and logging via logrus
 - Shadowed variables: use method suffix (`errStart := server.Start()`)

MOBILYZE.md

@@ -2,10 +2,13 @@
 
 A fork of [router-for-me/CLIProxyAPI](https://github.com/router-for-me/CLIProxyAPI) that adds the `soonest-reset` credential selector (MASTRA-765). The selector sends each new session to the account whose weekly window resets soonest, among accounts that still have quota.
 
-- Base: upstream tag `v8.0.13` (d7914afd). Our commits sit on top of it on `main`.
-- To move to a new upstream tag: `git fetch upstream --tags`, then rebase our commits onto the tag.
+- Base: upstream tag `v8.0.44` (1f917e77), merged into `main` by merge commit `7f7d7a61`.
+- To move to a new upstream tag: `git fetch upstream --tags`, create a branch from `main`, and
+  merge the tag into it. Keep `.github/workflows/` to our own workflows. Land the branch through
+  a normal pull request, which Mergify merges with a merge commit. Do not rebase: a rebase needs a
+  force-push past the `non_fast_forward` rule on `main`.
 - Never push upstream tags to this repo. Upstream's release and Docker workflows were removed, but a pushed upstream tag still carries them in its own tree.
-- Our releases use tags of the form `v8.0.13-mob.N`.
+- Our releases use tags of the form `v8.0.44-mob.N`.
 - Selector source: zsprackett/CLIProxyAPI commits `faa4ccff`, `01ad0021` and `67f5749d` (MIT), with authorship kept. `4d7b2e84` (model-scoped weekly windows) was left out.
 
 ## Subscription reserves

cmd/fetch_codex_models/main.go

@@ -37,6 +37,8 @@ import (
 	coreauth "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/auth"
 	"github.com/router-for-me/CLIProxyAPI/v8/sdk/proxyutil"
 	log "github.com/sirupsen/logrus"
+	"github.com/tidwall/gjson"
+	"github.com/tidwall/sjson"
 )
 
 const (
@@ -46,6 +48,8 @@ const (
 	defaultCodexUserAgent    = "codex_cli_rs/0.159.0 (Mac OS 26.3.1; arm64) iTerm.app/3.6.9"
 	defaultCodexOriginator   = "codex_cli_rs"
 	accessTokenRefreshLeeway = 30 * time.Second
+	baselineModelSlug        = "gpt-5.5"
+	baselineModelVisibility  = "list"
 )
 
 func init() {
@@ -289,13 +293,85 @@ func fetchModels(ctx context.Context, auth *coreauth.Auth, accessToken, clientVe
 		return nil, 0, fmt.Errorf("models request failed with status %d: %s", httpResp.StatusCode, strings.TrimSpace(string(bodyBytes)))
 	}
 
-	count, errCount := countModels(bodyBytes)
-	if errCount != nil {
-		return nil, 0, errCount
+	bodyBytes, count, errEnsure := ensureBaselineModel(bodyBytes)
+	if errEnsure != nil {
+		return nil, 0, errEnsure
 	}
 	return bodyBytes, count, nil
 }
 
+func ensureBaselineModel(raw []byte) ([]byte, int, error) {
+	var payload struct {
+		Models []json.RawMessage `json:"models"`
+	}
+	if errUnmarshal := json.Unmarshal(raw, &payload); errUnmarshal != nil {
+		return nil, 0, fmt.Errorf("failed to parse response JSON: %w", errUnmarshal)
+	}
+	// Keep this check intentionally loose: fetch_codex_models dumps the upstream
+	// Codex API payload. Strict CPA catalog validation belongs in
+	// cmd/validate_codex_models and registry.ValidateCodexClientModelsJSON.
+	if payload.Models == nil {
+		return nil, 0, fmt.Errorf("response JSON does not contain models array")
+	}
+	if len(payload.Models) == 0 {
+		return raw, 0, nil
+	}
+
+	foundBaseline := false
+	for i, modelRaw := range payload.Models {
+		slugResult := gjson.GetBytes(modelRaw, "slug")
+		if slugResult.Type != gjson.String || strings.TrimSpace(slugResult.Str) != baselineModelSlug {
+			continue
+		}
+		foundBaseline = true
+		visResult := gjson.GetBytes(modelRaw, "visibility")
+		if visResult.Type != gjson.String || visResult.Str != baselineModelVisibility {
+			updated, errSet := sjson.SetBytes(raw, fmt.Sprintf("models.%d.visibility", i), baselineModelVisibility)
+			if errSet != nil {
+				return nil, 0, fmt.Errorf("failed to update %s visibility: %w", baselineModelSlug, errSet)
+			}
+			raw = updated
+		}
+	}
+
+	count := len(payload.Models)
+	if !foundBaseline {
+		cloned := append([]byte(nil), payload.Models[0]...)
+		var errSet error
+		cloned, errSet = sjson.SetBytes(cloned, "slug", baselineModelSlug)
+		if errSet != nil {
+			return nil, 0, fmt.Errorf("failed to set %s slug on cloned model: %w", baselineModelSlug, errSet)
+		}
+		visResult := gjson.GetBytes(cloned, "visibility")
+		if visResult.Type != gjson.String || visResult.Str != baselineModelVisibility {
+			cloned, errSet = sjson.SetBytes(cloned, "visibility", baselineModelVisibility)
+			if errSet != nil {
+				return nil, 0, fmt.Errorf("failed to set %s visibility on cloned model: %w", baselineModelSlug, errSet)
+			}
+		}
+		for _, reset := range []struct {
+			path  string
+			value any
+		}{
+			{path: "tool_mode", value: "direct"},
+			{path: "use_responses_lite", value: false},
+			{path: "supports_reasoning_effort_updates", value: false},
+		} {
+			cloned, errSet = sjson.SetBytes(cloned, reset.path, reset.value)
+			if errSet != nil {
+				return nil, 0, fmt.Errorf("failed to set %s %s on cloned model: %w", baselineModelSlug, reset.path, errSet)
+			}
+		}
+		raw, errSet = sjson.SetRawBytes(raw, "models.-1", cloned)
+		if errSet != nil {
+			return nil, 0, fmt.Errorf("failed to append %s model: %w", baselineModelSlug, errSet)
+		}
+		count++
+	}
+
+	return raw, count, nil
+}
+
 func codexModelsURL(clientVersion string) (string, error) {
 	u, err := url.Parse(codexModelsBaseURL + codexModelsPath)
 	if err != nil {

cmd/fetch_codex_models/main_test.go

@@ -1,6 +1,10 @@
 package main
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/tidwall/gjson"
+)
 
 func TestCodexModelsURL(t *testing.T) {
 	got, err := codexModelsURL(" 0.144.1 ")
@@ -46,3 +50,96 @@ func TestCountModels(t *testing.T) {
 		t.Fatal("countModels(missing models) error = nil, want error")
 	}
 }
+
+func TestEnsureBaselineModel(t *testing.T) {
+	t.Run("clones first model as gpt-5.5 when missing", func(t *testing.T) {
+		raw := []byte(`{"models":[{"slug":"gpt-6.1-sol","display_name":"GPT-6.1-Sol","visibility":"list","tool_mode":"code_mode_only","use_responses_lite":true,"supports_reasoning_effort_updates":true},{"slug":"gpt-5.6-sol","visibility":"list"}]}`)
+		out, count, errEnsure := ensureBaselineModel(raw)
+		if errEnsure != nil {
+			t.Fatalf("ensureBaselineModel: %v", errEnsure)
+		}
+		if count != 3 {
+			t.Fatalf("count = %d, want 3", count)
+		}
+		if got := gjson.GetBytes(out, "models.0.slug").String(); got != "gpt-6.1-sol" {
+			t.Fatalf("models[0].slug = %q, want gpt-6.1-sol", got)
+		}
+		if got := gjson.GetBytes(out, "models.0.tool_mode").String(); got != "code_mode_only" {
+			t.Fatalf("models[0].tool_mode = %q, want code_mode_only", got)
+		}
+		if got := gjson.GetBytes(out, "models.2.slug").String(); got != "gpt-5.5" {
+			t.Fatalf("models[2].slug = %q, want gpt-5.5", got)
+		}
+		if got := gjson.GetBytes(out, "models.2.display_name").String(); got != "GPT-6.1-Sol" {
+			t.Fatalf("models[2].display_name = %q, want GPT-6.1-Sol", got)
+		}
+		if got := gjson.GetBytes(out, "models.2.visibility").String(); got != "list" {
+			t.Fatalf("models[2].visibility = %q, want list", got)
+		}
+		if got := gjson.GetBytes(out, "models.2.tool_mode"); got.Type != gjson.String || got.Str != "direct" {
+			t.Fatalf("models[2].tool_mode = %v (%s), want string \"direct\"", got.Value(), got.Type)
+		}
+		if got := gjson.GetBytes(out, "models.2.use_responses_lite"); got.Type != gjson.False {
+			t.Fatalf("models[2].use_responses_lite = %v (%s), want false", got.Value(), got.Type)
+		}
+		if got := gjson.GetBytes(out, "models.2.supports_reasoning_effort_updates"); got.Type != gjson.False {
+			t.Fatalf("models[2].supports_reasoning_effort_updates = %v (%s), want false", got.Value(), got.Type)
+		}
+	})
+
+	t.Run("clones first model and forces visibility to list when first model is hidden", func(t *testing.T) {
+		raw := []byte(`{"models":[{"slug":"gpt-reserve","visibility":"hide"}]}`)
+		out, count, errEnsure := ensureBaselineModel(raw)
+		if errEnsure != nil {
+			t.Fatalf("ensureBaselineModel: %v", errEnsure)
+		}
+		if count != 2 {
+			t.Fatalf("count = %d, want 2", count)
+		}
+		if got := gjson.GetBytes(out, "models.0.visibility").String(); got != "hide" {
+			t.Fatalf("models[0].visibility = %q, want hide", got)
+		}
+		if got := gjson.GetBytes(out, "models.1.slug").String(); got != "gpt-5.5" {
+			t.Fatalf("models[1].slug = %q, want gpt-5.5", got)
+		}
+		if got := gjson.GetBytes(out, "models.1.visibility").String(); got != "list" {
+			t.Fatalf("models[1].visibility = %q, want list", got)
+		}
+	})
+
+	t.Run("forces existing gpt-5.5 visibility to list when hidden", func(t *testing.T) {
+		raw := []byte(`{"models":[{"slug":"gpt-6.1-sol","visibility":"list"},{"slug":"gpt-5.5","visibility":"hide"}]}`)
+		out, count, errEnsure := ensureBaselineModel(raw)
+		if errEnsure != nil {
+			t.Fatalf("ensureBaselineModel: %v", errEnsure)
+		}
+		if count != 2 {
+			t.Fatalf("count = %d, want 2", count)
+		}
+		if got := gjson.GetBytes(out, "models.1.slug").String(); got != "gpt-5.5" {
+			t.Fatalf("models[1].slug = %q, want gpt-5.5", got)
+		}
+		if got := gjson.GetBytes(out, "models.1.visibility").String(); got != "list" {
+			t.Fatalf("models[1].visibility = %q, want list", got)
+		}
+	})
+
+	t.Run("forces existing gpt-5.5 visibility to exact list when padded or non-string", func(t *testing.T) {
+		for _, raw := range [][]byte{
+			[]byte(`{"models":[{"slug":"gpt-5.5","visibility":" list "}]}`),
+			[]byte(`{"models":[{"slug":"gpt-5.5","visibility":false}]}`),
+		} {
+			out, count, errEnsure := ensureBaselineModel(raw)
+			if errEnsure != nil {
+				t.Fatalf("ensureBaselineModel(%s): %v", raw, errEnsure)
+			}
+			if count != 1 {
+				t.Fatalf("count = %d, want 1", count)
+			}
+			vis := gjson.GetBytes(out, "models.0.visibility")
+			if vis.Type != gjson.String || vis.Str != "list" {
+				t.Fatalf("models[0].visibility = %v (%s), want string \"list\"", vis.Value(), vis.Type)
+			}
+		}
+	})
+}

cmd/fetch_devin_models/main.go

@@ -429,6 +429,15 @@ var devinCompoundSuffixes = []struct {
 	{suffix: "-thinking", effort: ""},
 	{suffix: "-max-1m", effort: "max", readd: "-1m"},
 	{suffix: "-none-1m", effort: "none", readd: "-1m"},
+	// Lightning tier keeps the effort before the -lightning suffix upstream
+	// (e.g. swe-2-high-lightning), so it aggregates as <base>-lightning.
+	{suffix: "-minimal-lightning", effort: "minimal", readd: "-lightning"},
+	{suffix: "-low-lightning", effort: "low", readd: "-lightning"},
+	{suffix: "-medium-lightning", effort: "medium", readd: "-lightning"},
+	{suffix: "-high-lightning", effort: "high", readd: "-lightning"},
+	{suffix: "-xhigh-lightning", effort: "xhigh", readd: "-lightning"},
+	{suffix: "-max-lightning", effort: "max", readd: "-lightning"},
+	{suffix: "-none-lightning", effort: "none", readd: "-lightning"},
 }
 
 var devinSimpleEffortSuffixes = []struct {
@@ -571,12 +580,19 @@ func aggregateModels(raw []rawDevinModel) []devinModelJSON {
 			}
 		}
 
+		// Lightning display names strip both the effort word and "Lightning";
+		// re-append it so swe-2-lightning shows as "SWE-2 Lightning".
+		displayName := entry.displayName
+		if strings.HasSuffix(id, "-lightning") && !strings.HasSuffix(strings.ToLower(displayName), "lightning") {
+			displayName = strings.TrimSpace(displayName + " Lightning")
+		}
+
 		res = append(res, devinModelJSON{
 			ID:                        entry.baseID,
 			Object:                    "model",
 			Type:                      "devin",
 			OwnedBy:                   vendorName(entry.vendorID, entry.baseID),
-			DisplayName:               entry.displayName,
+			DisplayName:               displayName,
 			ContextLength:             entry.contextLength,
 			MaxCompletionTokens:       64000,
 			SupportedInputModalities:  modalities,
@@ -595,7 +611,7 @@ var devinDisplayNameSuffixes = []string{
 	" Low Thinking", " Medium Thinking", " High Thinking", " XHigh Thinking",
 	" Max Thinking", " No Thinking",
 	" Low", " Medium", " High", " XHigh", " Max", " None", " Minimal",
-	" Thinking", " Fast",
+	" Thinking", " Fast", " Lightning",
 }
 
 func cleanDisplayName(label string) string {

cmd/fetch_devin_models/main_test.go

@@ -24,6 +24,9 @@ func TestSplitDevinUID(t *testing.T) {
 		{"swe-1-6-slow", "swe-1-6-slow", ""},
 		{"swe-1-6-fast", "swe-1-6", ""},
 		{"swe-2", "swe-2", ""},
+		{"swe-2-medium-lightning", "swe-2-lightning", "medium"},
+		{"swe-2-high-lightning", "swe-2-lightning", "high"},
+		{"swe-2-max-lightning", "swe-2-lightning", "max"},
 	}
 
 	for _, tt := range tests {