feat: preserve tool calls across protocol bridges and download desktop CLI online

Add portable InputSlots for tool calls/results, Claude request-field extensions, and Responses SSE tool streaming so Codex↔Claude transcoding keeps tool_use semantics. Desktop packaged builds now fetch the core CLI at runtime instead of bundling Go binaries.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: joo

.github/workflows/release-desktop.yml

@@ -68,11 +68,6 @@ jobs:
           RELEASE_VERSION: ${{ github.event.inputs.version }}
         run: node scripts/sync-desktop-version.mjs
 
-      - name: Setup Go
-        uses: actions/setup-go@v5
-        with:
-          go-version-file: core/go.mod
-
       - name: Setup Node
         uses: actions/setup-node@v4
         with:
@@ -128,11 +123,6 @@ jobs:
           RELEASE_VERSION: ${{ github.event.inputs.version }}
         run: node scripts/sync-desktop-version.mjs
 
-      - name: Setup Go
-        uses: actions/setup-go@v5
-        with:
-          go-version-file: core/go.mod
-
       - name: Setup Node
         uses: actions/setup-node@v4
         with:

core/internal/buildinfo/buildinfo.go

@@ -4,7 +4,7 @@ import "strings"
 
 // Set at link time via -ldflags (see .goreleaser.yaml).
 var (
-	Version = "dev0.1.23"
+	Version = "dev0.1.28"
 	Commit  = "none"
 	Date    = "unknown"
 )

core/internal/cliswitch/switch.go

@@ -80,19 +80,8 @@ func VendorCompatibleWithCLI(kind agentkind.Kind, vendor profile.Profile) bool {
 	if providerID == "" {
 		return false
 	}
-	switch kind {
-	case agentkind.ClaudeCode, agentkind.KimiCode:
-		if providerID == provider.ClaudeCodeProviderID {
-			return true
-		}
-	case agentkind.Codex:
-		if providerID == provider.CodexProviderID || providerID == provider.ClaudeCodeProviderID {
-			return true
-		}
-	default:
-		if providerID == provider.ClaudeCodeProviderID || providerID == provider.CodexProviderID {
-			return true
-		}
+	if providerID == provider.ClaudeCodeProviderID || providerID == provider.CodexProviderID {
+		return len(apply.SupportedStyles(kind)) > 0
 	}
 	if providerID == provider.OllamaProviderID || providerID == provider.CustomAPIProviderID {
 		return len(apply.SupportedStyles(kind)) > 0

core/internal/cliswitch/switch_test.go

@@ -34,6 +34,31 @@ func TestCodexCanResolveClaudeSubscriptionSelection(t *testing.T) {
 	}
 }
 
+func TestKimiCanResolveCodexSubscriptionSelection(t *testing.T) {
+	s := &profile.Store{
+		Version: profile.StoreVersion,
+		List: []profile.Profile{{
+			Name:                   provider.CodexVendorName,
+			Kind:                   "subscription",
+			SubscriptionProviderID: provider.CodexProviderID,
+			APIStyle:               apistyle.OpenAIResponses,
+			Models: []profile.Model{{
+				ID:       "gpt-5.4",
+				Model:    "gpt-5.4",
+				APIStyle: apistyle.OpenAIResponses,
+			}},
+		}},
+	}
+
+	selection, err := ResolveSelection(s, agentkind.KimiCode, provider.CodexVendorName, "gpt-5.4")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if selection.ProviderID != provider.CodexProviderID || selection.ModelID != "gpt-5.4" {
+		t.Fatalf("selection = %+v", selection)
+	}
+}
+
 func TestMultiStyleCLIsUsePreferredIngressForCodexSubscription(t *testing.T) {
 	hit := profile.VendorModelHit{
 		Vendor: profile.Profile{

core/internal/protocol/capability.go

@@ -45,7 +45,7 @@ func ValidateRequestExtensionsForEgress(egress apistyle.Style, r Request) error
 		}
 	}
 	for _, ext := range r.Extensions {
-		if ext.Kind == ExtOpenAIResponsesInputString || ext.Kind == ExtOpenAIResponsesRequestField {
+		if ext.Kind == ExtOpenAIResponsesInputString || ext.Kind == ExtOpenAIResponsesRequestField || ext.Kind == ExtAnthropicRequestField {
 			continue
 		}
 		if !extensionSupportedByStyle(style, ext.Kind) {

core/internal/protocol/decode.go

@@ -69,6 +69,7 @@ func DecodeRequestClaude(body []byte) (Request, error) {
 	}
 	msgsAny, _ := raw["messages"].([]any)
 	msgList, sys := PartitionSystemMessages(msgsAny, raw["system"])
+	inputSlots := decodeClaudeInputSlots(msgsAny)
 	tools, _ := mapClaudeTools(raw["tools"])
 	var meta *Metadata
 	if sys != "" {
@@ -87,7 +88,11 @@ func DecodeRequestClaude(body []byte) (Request, error) {
 		}
 	}
 	req := NewRequest(jsonStringField(raw, "model"), msgList, streamDefault(streamPtr), maxTok, tempPtr, meta)
+	req.InputSlots = inputSlots
 	req.Tools = tools
+	if err := appendClaudeRequestFieldExtensions(&req, raw); err != nil {
+		return Request{}, err
+	}
 	return req, nil
 }
 

core/internal/protocol/decode_claude_ext.go

@@ -0,0 +1,220 @@
+package protocol
+
+import (
+	"fmt"
+	"strings"
+)
+
+var claudeKnownRequestKeys = map[string]struct{}{
+	"model":       {},
+	"messages":    {},
+	"stream":      {},
+	"max_tokens":  {},
+	"temperature": {},
+	"system":      {},
+	"tools":       {},
+}
+
+func appendClaudeRequestFieldExtensions(req *Request, raw map[string]any) error {
+	if req == nil || raw == nil {
+		return nil
+	}
+	for key, value := range raw {
+		if !claudeRequestFieldNeedsPreservation(key, value) {
+			continue
+		}
+		ext, err := requestFieldExtensionForKind(ExtAnthropicRequestField, key, value)
+		if err != nil {
+			return fmt.Errorf("preserve request field %q: %w", key, err)
+		}
+		req.Extensions = append(req.Extensions, ext)
+	}
+	return nil
+}
+
+func claudeRequestFieldNeedsPreservation(key string, value any) bool {
+	if _, known := claudeKnownRequestKeys[key]; !known {
+		return true
+	}
+	switch key {
+	case "system":
+		return !isSimpleClaudeSystemWire(value)
+	case "messages":
+		return !isSimpleClaudeMessagesWire(value)
+	case "tools":
+		return !isSimpleClaudeToolsWire(value)
+	default:
+		return false
+	}
+}
+
+func isSimpleClaudeSystemWire(value any) bool {
+	if value == nil {
+		return true
+	}
+	switch v := value.(type) {
+	case string:
+		return true
+	case []any:
+		for _, item := range v {
+			block, ok := item.(map[string]any)
+			if !ok || !isSimpleClaudeTextBlock(block) {
+				return false
+			}
+		}
+		return len(v) > 0
+	default:
+		return false
+	}
+}
+
+func isSimpleClaudeMessagesWire(value any) bool {
+	arr, ok := value.([]any)
+	if !ok {
+		return value == nil
+	}
+	for _, item := range arr {
+		msg, ok := item.(map[string]any)
+		if !ok {
+			return false
+		}
+		role := strings.ToLower(strings.TrimSpace(fmt.Sprint(msg["role"])))
+		if role != string(RoleUser) && role != string(RoleAssistant) {
+			return false
+		}
+		if !isSimpleClaudeMessageContent(msg["content"]) {
+			return false
+		}
+		for field := range msg {
+			if field != "role" && field != "content" {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func isSimpleClaudeMessageContent(content any) bool {
+	if content == nil {
+		return true
+	}
+	switch v := content.(type) {
+	case string:
+		return true
+	case []any:
+		for _, item := range v {
+			block, ok := item.(map[string]any)
+			if !ok || !isSimpleClaudeTextBlock(block) {
+				return false
+			}
+		}
+		return true
+	default:
+		return false
+	}
+}
+
+func isSimpleClaudeTextBlock(block map[string]any) bool {
+	if block == nil {
+		return false
+	}
+	if strings.TrimSpace(fmt.Sprint(block["type"])) != "text" {
+		return false
+	}
+	if _, ok := block["text"]; !ok {
+		return false
+	}
+	for field := range block {
+		if field != "type" && field != "text" {
+			return false
+		}
+	}
+	return true
+}
+
+func isSimpleClaudeToolsWire(value any) bool {
+	arr, ok := value.([]any)
+	if !ok {
+		return value == nil
+	}
+	allowedToolKeys := map[string]struct{}{
+		"name": {}, "description": {}, "input_schema": {}, "parameters": {}, "type": {}, "function": {},
+	}
+	for _, item := range arr {
+		entry, ok := item.(map[string]any)
+		if !ok {
+			return false
+		}
+		if fn, ok := entry["function"].(map[string]any); ok && fn != nil {
+			entry = fn
+		}
+		for field := range entry {
+			if _, ok := allowedToolKeys[field]; !ok {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func decodeClaudeInputSlots(messages []any) []InputSlot {
+	slots := make([]InputSlot, 0)
+	for _, raw := range messages {
+		msg, ok := raw.(map[string]any)
+		if !ok {
+			continue
+		}
+		role := strings.ToLower(strings.TrimSpace(fmt.Sprint(msg["role"])))
+		if role == "" {
+			role = string(RoleUser)
+		}
+		content := msg["content"]
+		blocks, ok := content.([]any)
+		if !ok {
+			text := strings.TrimSpace(TextContent(content))
+			if text != "" {
+				m := Message{Role: Role(role), Content: text}
+				slots = append(slots, InputSlot{Message: &m})
+			}
+			continue
+		}
+		var textParts []string
+		flushText := func() {
+			text := strings.TrimSpace(strings.Join(filterNonEmpty(textParts), "\n"))
+			textParts = nil
+			if text == "" {
+				return
+			}
+			m := Message{Role: Role(role), Content: text}
+			slots = append(slots, InputSlot{Message: &m})
+		}
+		for _, rawBlock := range blocks {
+			block, ok := rawBlock.(map[string]any)
+			if !ok {
+				continue
+			}
+			switch strings.TrimSpace(fmt.Sprint(block["type"])) {
+			case "text":
+				if text := strings.TrimSpace(TextContent(block["text"])); text != "" {
+					textParts = append(textParts, text)
+				}
+			case "tool_use":
+				flushText()
+				if tc := toolCallFromClaudeBlock(block); tc != nil {
+					slots = append(slots, InputSlot{ToolCall: tc})
+				}
+			case "tool_result":
+				flushText()
+				if tr := toolResultFromClaudeBlock(block); tr != nil {
+					slots = append(slots, InputSlot{ToolResult: tr})
+				}
+			default:
+				if text := strings.TrimSpace(TextContent(block)); text != "" {
+					textParts = append(textParts, text)
+				}
+			}
+		}
+		flushText()
+	}
+	return slots
+}

core/internal/protocol/decode_claude_ext_test.go

@@ -0,0 +1,57 @@
+package protocol
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestAppendClaudeRequestFieldExtensionsPreservesComplexWire(t *testing.T) {
+	raw, err := jsonDecodeMap([]byte(`{
+		"model":"claude-opus-4-7",
+		"max_tokens":1024,
+		"stream":true,
+		"thinking":{"type":"enabled","budget_tokens":2048},
+		"system":[{"type":"text","text":"sys","cache_control":{"type":"ephemeral"}}],
+		"messages":[{"role":"user","content":[{"type":"text","text":"hi","cache_control":{"type":"ephemeral"}}]}]
+	}`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	req := Request{Model: "claude-opus-4-7"}
+	if err := appendClaudeRequestFieldExtensions(&req, raw); err != nil {
+		t.Fatal(err)
+	}
+	if len(req.Extensions) < 3 {
+		t.Fatalf("extensions = %#v, want thinking/system/messages preserved", req.Extensions)
+	}
+
+	upstream, err := EncodeRequestClaude(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(upstream)
+	for _, want := range []string{`"thinking"`, `"cache_control"`, `"budget_tokens":2048`} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("encoded upstream missing %s: %s", want, upstream)
+		}
+	}
+}
+
+func TestAppendClaudeRequestFieldExtensionsSkipsSimpleWire(t *testing.T) {
+	raw, err := jsonDecodeMap([]byte(`{
+		"model":"claude-opus-4-7",
+		"max_tokens":1024,
+		"stream":true,
+		"messages":[{"role":"user","content":"hello"}]
+	}`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	req := Request{Model: "claude-opus-4-7", Messages: []Message{{Role: RoleUser, Content: "hello"}}}
+	if err := appendClaudeRequestFieldExtensions(&req, raw); err != nil {
+		t.Fatal(err)
+	}
+	if len(req.Extensions) != 0 {
+		t.Fatalf("extensions = %#v, want none for simple wire", req.Extensions)
+	}
+}