feat: GLM-5.2 and DeepSeek-v4-pro support in Codex Desktop

cmd/agentctl/cmd_set_model.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/agentserver/agentserver-pkg/internal/codex"
+	"github.com/agentserver/agentserver-pkg/internal/paths"
+	"github.com/agentserver/agentserver-pkg/internal/protoconv"
+)
+
+func runSetModel(args []string) {
+	if err := runSetModelWithConfigResolved(args); err != nil {
+		die(err)
+	}
+}
+
+// runSetModelWithConfigResolved resolves the real Codex config path and applies.
+func runSetModelWithConfigResolved(args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("usage: agentctl set-model <name>; known models: %v", protoconv.KnownModels())
+	}
+	if err := validateModelSelection(args[0]); err != nil {
+		return err
+	}
+	p, err := paths.Default()
+	if err != nil {
+		return err
+	}
+	return runSetModelWithConfig(p.CodexConfigFile, args)
+}
+
+// runSetModelWithConfig applies the selection to an explicit config path (testable).
+func runSetModelWithConfig(configPath string, args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("usage: set-model <name>; known models: %v", protoconv.KnownModels())
+	}
+	if err := validateModelSelection(args[0]); err != nil {
+		return err
+	}
+	if err := codex.SetModel(configPath, args[0]); err != nil {
+		return err
+	}
+	fmt.Printf("model set to %s in %s\n", args[0], configPath)
+	return nil
+}
+
+// validateModelSelection rejects models not in the protoconv catalog.
+func validateModelSelection(model string) error {
+	if model == "" {
+		return fmt.Errorf("model name required; known models: %v", protoconv.KnownModels())
+	}
+	if _, ok := protoconv.LookupRoute(model); !ok {
+		return fmt.Errorf("unknown model %q; known models: %v", model, protoconv.KnownModels())
+	}
+	return nil
+}

cmd/agentctl/cmd_set_model_test.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestValidateModelSelection(t *testing.T) {
+	cases := []struct {
+		model string
+		ok    bool
+	}{
+		{"gpt-5.5", true},
+		{"deepseek-v4-pro", true},
+		{"glm-5.2", true},
+		{"bogus-model", false},
+		{"", false},
+	}
+	for _, c := range cases {
+		if err := validateModelSelection(c.model); (err == nil) != c.ok {
+			t.Errorf("validateModelSelection(%q) err=%v, want ok=%v", c.model, err, c.ok)
+		}
+	}
+}
+
+func TestRunSetModelWritesConfig(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "config.toml")
+	if err := runSetModelWithConfig(path, []string{"deepseek-v4-pro"}); err != nil {
+		t.Fatalf("err: %v", err)
+	}
+	b, _ := os.ReadFile(path)
+	if !contains(string(b), `model = "deepseek-v4-pro"`) {
+		t.Errorf("model not written; got:\n%s", b)
+	}
+}
+
+func contains(s, sub string) bool {
+	for i := 0; i+len(sub) <= len(s); i++ {
+		if s[i:i+len(sub)] == sub {
+			return true
+		}
+	}
+	return false
+}

cmd/agentctl/main.go

@@ -23,6 +23,8 @@ func main() {
 		if err := runInstallCodex(os.Args[2:]); err != nil {
 			die(err)
 		}
+	case "set-model":
+		runSetModel(os.Args[2:])
 	case "test-install-vscode":
 		runTestInstallVSCode()
 	case "test-install-codex-desktop":
@@ -54,6 +56,7 @@ USAGE:
   agentctl logs                   print last 200 lines of launcher log
   agentctl install-codex --manifest <path>
                                   download and install Codex runtime from npm mirrors
+  agentctl set-model <name>      set the Codex model (gpt-5.5 / deepseek-v4-pro / glm-5.2)
 
 P13.4 verification subcommands (skip the OAuth steps, exercise everything else):
   agentctl test-install-vscode   download + run the VS Code Microsoft Store bootstrapper

cmd/agentserver/main.go

@@ -13,11 +13,13 @@ import (
 	"strings"
 	"syscall"
 
+	"github.com/agentserver/agentserver-pkg/internal/codex"
 	"github.com/agentserver/agentserver-pkg/internal/headless"
 	"github.com/agentserver/agentserver-pkg/internal/modelaccess"
 	"github.com/agentserver/agentserver-pkg/internal/modelserver"
 	"github.com/agentserver/agentserver-pkg/internal/oauth"
 	"github.com/agentserver/agentserver-pkg/internal/paths"
+	"github.com/agentserver/agentserver-pkg/internal/protoconv"
 	"github.com/agentserver/agentserver-pkg/internal/secrets"
 	"github.com/agentserver/agentserver-pkg/internal/terminalauth"
 	"golang.org/x/term"
@@ -32,6 +34,7 @@ type app struct {
 	switchWorkspace func(context.Context) error
 	serveDriverMCP  func(context.Context) error
 	runDaemon       func(context.Context) error
+	setModel        func(args []string) error
 }
 
 func main() {
@@ -165,6 +168,9 @@ func newApp() app {
 				Logf:            daemonLogf(proxyLogPath),
 			})
 		},
+		setModel: func(args []string) error {
+			return runAgentserverSetModel(args)
+		},
 	}
 }
 
@@ -191,6 +197,12 @@ func (a app) run(ctx context.Context, args []string) error {
 	if cmd == "model-proxy-daemon" {
 		return a.runDaemon(ctx)
 	}
+	if cmd == "set-model" {
+		if a.setModel == nil {
+			return fmt.Errorf("set-model unavailable: paths not initialized")
+		}
+		return a.setModel(args[1:])
+	}
 	switch cmd {
 	case "", "install-driver", "switch-workspace", "serve-driver-mcp":
 	default:
@@ -230,6 +242,25 @@ func promptName(defaultName string) (string, error) {
 	})
 }
 
+func runAgentserverSetModel(args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("usage: agentserver set-model <name>; known models: %v", protoconv.KnownModels())
+	}
+	model := args[0]
+	if _, ok := protoconv.LookupRoute(model); !ok {
+		return fmt.Errorf("unknown model %q; known models: %v", model, protoconv.KnownModels())
+	}
+	p, err := paths.Default()
+	if err != nil {
+		return err
+	}
+	if err := codex.SetModel(p.CodexConfigFile, model); err != nil {
+		return err
+	}
+	fmt.Printf("model set to %s in %s\n", model, p.CodexConfigFile)
+	return nil
+}
+
 func promptNameWithTerminal(r io.Reader, w io.Writer, defaultName string, isTerminal func() bool) (string, error) {
 	if isTerminal == nil || !isTerminal() {
 		return defaultName, nil

cmd/launcher/main.go

@@ -231,6 +231,7 @@ func serveCompletedConsole(ctx context.Context, in completedServeInput) error {
 		Slaves:                   slaveManager,
 		Updates:                  updates,
 		PendingSlaveRestartsPath: in.Paths.PendingSlaveRestartsFile,
+		CodexConfigFile:          in.Paths.CodexConfigFile,
 		ModelserverWebBaseURL:    "https://code.cs.ac.cn",
 		RefreshModelserverToken: func(ctx context.Context) error {
 			_, err := tokenrefresh.RefreshOnce(ctx, tokenrefresh.Options{
@@ -806,8 +807,9 @@ func launchCompletedOpenCodeDesktop(ctx context.Context, s *state.State, p paths
 	if err != nil {
 		return err
 	}
+	// See launchCompletedCodexDesktop for why this is tolerant of failure.
 	if err := codex.UpdateConfig(p.CodexConfigFile, codex.ModelserverProxySettings(modelproxy.DefaultBaseURL, localProxyToken)); err != nil {
-		return err
+		log.Printf("launcher: update codex config (continuing): %v", err)
 	}
 	if p.OpenCodeConfigFile != "" {
 		if err := opencode.UpdateConfig(p.OpenCodeConfigFile, opencode.Settings{
@@ -858,8 +860,15 @@ func launchCompletedCodexDesktop(ctx context.Context, s *state.State, p paths.Pa
 	if err != nil {
 		return err
 	}
+	// UpdateConfig writes config.toml atomically (write tmp, rename). If Codex
+	// Desktop is already running it holds a read handle and Windows rejects
+	// the rename with ERROR_ACCESS_DENIED. That's a benign no-op for "open
+	// frontend" — the running Codex won't reload the file anyway — so log and
+	// continue rather than fail the launch. First-time startup (Codex not
+	// running, file unlocked) still writes normally; codex.SetModel (user
+	// switching models) is invoked when Codex isn't holding the file open.
 	if err := codex.UpdateConfig(p.CodexConfigFile, codex.ModelserverProxySettings(modelproxy.DefaultBaseURL, localProxyToken)); err != nil {
-		return err
+		log.Printf("launcher: update codex config (continuing): %v", err)
 	}
 	_ = env.PersistUserEnv(codex.LocalProxyAPIKeyEnv, localProxyToken)
 	_ = os.Setenv(codex.LocalProxyAPIKeyEnv, localProxyToken)
@@ -1028,8 +1037,13 @@ func execVSCode(codeExe string, p paths.Paths, folder string, sec secrets.Store,
 	if err != nil {
 		return err
 	}
+	// Unlike Codex/OpenCode Desktop, VS Code does NOT hold the codex config
+	// open, so the rename-while-locked race that justifies tolerating
+	// UpdateConfig failures in those paths doesn't apply here. We need a
+	// fresh codex config before VS Code starts (the Codex extension reads it
+	// at session creation), so propagate the error.
 	if err := codex.UpdateConfig(p.CodexConfigFile, codex.ModelserverProxySettings(modelproxy.DefaultBaseURL, localProxyToken)); err != nil {
-		return err
+		return fmt.Errorf("update codex config before launching VS Code: %w", err)
 	}
 	_ = env.PersistUserEnv(codex.LocalProxyAPIKeyEnv, localProxyToken)
 	_ = os.Setenv(codex.LocalProxyAPIKeyEnv, localProxyToken)