open-source/cursor-byok
1
0
Fork 0
mirror of https://wget.la/https://github.com/leookun/cursor-byok synced 2026-08-18 03:57:06 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: UI

Browse Source
This commit is contained in:
leookun
2026-08-07 01:50:20 +08:00
parent 5bd39ed317
commit 225de8bb85
39 changed files with 1734 additions and 1604 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/backend/agent/model/openai.go
+1 -1
View File
@@ -839,7 +839,7 @@ func (adapter *OpenAIAdapter) streamChatCompletions(ctx context.Context, req Str
}
}
if choice.FinishReason != nil {
if choice.FinishReason != nil && strings.TrimSpace(*choice.FinishReason) != "" {
if err := flushTaggedContentTail(); err != nil {
return fail(err)
}
internal/backend/agent/model/openai_stream_test.go
+95
View File
@@ -0,0 +1,95 @@
package modeladapter
import (
"context"
"fmt"
"net/http"
"net/http/httptest"
"testing"
)
func TestOpenAIChatCompletionsIgnoresBlankFinishReason(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
writer.Header().Set("Content-Type", "text/event-stream")
chunks := []string{
`{"model":"deepseek-v4-flash","choices":[{"delta":{"reasoning_content":"first"},"finish_reason":""}]}`,
`{"model":"deepseek-v4-flash","choices":[{"delta":{"reasoning_content":" second"},"finish_reason":""}]}`,
`{"model":"deepseek-v4-flash","choices":[{"delta":{"tool_calls":[{"index":0,"id":"call_1","type":"function","function":{"name":"Ls","arguments":""}}]},"finish_reason":""}]}`,
`{"model":"deepseek-v4-flash","choices":[{"delta":{"tool_calls":[{"index":0,"id":"","type":"function","function":{"name":"","arguments":"{\"path\":"}}]},"finish_reason":""}]}`,
`{"model":"deepseek-v4-flash","choices":[{"delta":{"tool_calls":[{"index":0,"id":"","type":"function","function":{"name":"","arguments":"\"/tmp\"}"}}]},"finish_reason":"tool_calls"}]}`,
`{"model":"deepseek-v4-flash","choices":[],"usage":{"prompt_tokens":12,"completion_tokens":7}}`,
}
for _, chunk := range chunks {
_, _ = fmt.Fprintf(writer, "data: %s\n\n", chunk)
}
_, _ = fmt.Fprint(writer, "data: [DONE]\n\n")
}))
defer server.Close()
adapter := &OpenAIAdapter{client: server.Client()}
events := make([]ModelEvent, 0, 8)
err := adapter.Stream(context.Background(), StreamRequest{
RequestID: "request-1",
RunID: "run-1",
ModelCallID: "model-call-1",
BaseURL: server.URL,
APIKey: "test-key",
ProviderModelID: "deepseek-v4-flash",
OpenAIEndpoint: "/v1/chat/completions",
Messages: []Message{{Role: "user", Content: "list files"}},
MaxTokens: 128,
RequestKnobs: map[string]any{},
}, func(event ModelEvent) error {
events = append(events, event)
return nil
})
if err != nil {
t.Fatalf("stream failed: %v", err)
}
assertOpenAIEventKindCount(t, events, ModelEventKindThinkingDelta, 2)
assertOpenAIEventKindCount(t, events, ModelEventKindThinkingCompleted, 1)
assertOpenAIEventKindCount(t, events, ModelEventKindToolLikeCompleted, 1)
assertOpenAIEventKindCount(t, events, ModelEventKindTurnFinished, 1)
toolEvent := firstOpenAIEventForTest(events, ModelEventKindToolLikeCompleted)
if toolEvent == nil || toolEvent.ToolInvocation == nil {
t.Fatalf("completed tool invocation missing: %#v", toolEvent)
}
if toolEvent.ToolInvocation.ToolName != "Ls" {
t.Fatalf("tool name = %q, want Ls", toolEvent.ToolInvocation.ToolName)
}
if got := string(toolEvent.ToolInvocation.ArgsJSON); got != `{"path":"/tmp"}` {
t.Fatalf("tool args = %q, want %q", got, `{"path":"/tmp"}`)
}
finished := firstOpenAIEventForTest(events, ModelEventKindTurnFinished)
if finished == nil || finished.FinishReason != "tool_calls" {
t.Fatalf("finish reason = %q, want tool_calls", finished.FinishReason)
}
if finished.InputTokens != 12 || finished.OutputTokens != 7 {
t.Fatalf("usage = input:%d output:%d, want input:12 output:7", finished.InputTokens, finished.OutputTokens)
}
}
func assertOpenAIEventKindCount(t *testing.T, events []ModelEvent, kind ModelEventKind, want int) {
t.Helper()
got := 0
for _, event := range events {
if event.Kind == kind {
got++
}
}
if got != want {
t.Fatalf("event kind %s count = %d, want %d; events=%#v", kind, got, want, events)
}
}
func firstOpenAIEventForTest(events []ModelEvent, kind ModelEventKind) *ModelEvent {
for index := range events {
if events[index].Kind == kind {
return &events[index]
}
}
return nil
}
internal/backend/forwarder/service.go
+7
View File
@@ -1736,6 +1736,13 @@ func (service *Service) handleToolInvocation(stream *ActiveStream, invocation ru
stream.ToolInvocationCount++
stream.UpdatedAt = time.Now().UTC()
stream.mu.Unlock()
if !isKnownToolName(trimmedToolName) {
displayToolName := trimmedToolName
if displayToolName == "" {
displayToolName = "<empty>"
}
return service.completePreDispatchToolError(stream, invocation, nil, false, false, fmt.Errorf("Model hallucination: attempted to invoke a nonexistent tool: %s", displayToolName))
}
if !isToolAllowedInMode(mode, subagentTypeName, trimmedToolName) {
return service.completePreDispatchToolError(stream, invocation, nil, false, false, fmt.Errorf("tool invocation is not enabled in mode %s: %s", mode.String(), invocation.ToolName))
}
internal/backend/forwarder/tool_catalog.go
+19
View File
@@ -181,6 +181,25 @@ func supportedToolNamesForMode(mode agentv1.AgentMode) map[string]struct{} {
}
}
func isKnownToolName(toolName string) bool {
trimmedToolName := strings.TrimSpace(toolName)
if trimmedToolName == "" {
return false
}
for _, supported := range []map[string]struct{}{
agentModeToolNames,
askModeToolNames,
planModeToolNames,
debugModeToolNames,
multitaskModeToolNames,
} {
if _, ok := supported[trimmedToolName]; ok {
return true
}
}
return false
}
func isToolAllowedInMode(mode agentv1.AgentMode, subagentTypeName string, toolName string) bool {
trimmedToolName := strings.TrimSpace(toolName)
if trimmedToolName == "" {
internal/backend/server/config/legacy_runtime.go
+1
View File
@@ -16,6 +16,7 @@ func (store *Store) LegacyRuntimeSnapshot(ctx context.Context) (legacyruntime.Ru
for _, item := range cfg.ModelAdapters {
adapters = append(adapters, legacyruntime.ModelAdapterConfig{
ID: item.ID,
Sort: item.Sort,
DisplayName: item.DisplayName,
Type: item.Type,
BaseURL: item.BaseURL,
internal/backend/server/config/manager.go
+1
View File
@@ -147,6 +147,7 @@ func (manager *Manager) LegacyRuntimeSnapshot(_ context.Context) (legacyruntime.
for _, item := range cfg.ModelAdapters {
adapters = append(adapters, legacyruntime.ModelAdapterConfig{
ID: item.ID,
Sort: item.Sort,
DisplayName: item.DisplayName,
Type: item.Type,
BaseURL: item.BaseURL,
internal/backend/server/config/types.go
+24
View File
@@ -5,6 +5,7 @@ import (
"errors"
"fmt"
"net"
"sort"
"strconv"
"strings"
@@ -21,6 +22,7 @@ const (
type ModelAdapterConfig struct {
ID string `json:"id,omitempty" yaml:"-"`
Sort int `json:"sort" yaml:"sort"`
DisplayName string `json:"displayName" yaml:"displayName"`
Type string `json:"type" yaml:"type"`
BaseURL string `json:"baseURL" yaml:"baseURL"`
@@ -104,6 +106,7 @@ func NormalizeModelAdapterConfigs(input []ModelAdapterConfig) ([]ModelAdapterCon
}
nextType := normalizeModelAdapterType(item.Type)
next := ModelAdapterConfig{
Sort: item.Sort,
DisplayName: strings.TrimSpace(item.DisplayName),
Type: nextType,
BaseURL: baseURL,
@@ -164,9 +167,30 @@ func NormalizeModelAdapterConfigs(input []ModelAdapterConfig) ([]ModelAdapterCon
seenChannelIDs[next.ID] = struct{}{}
normalized = append(normalized, next)
}
normalizeModelAdapterSorts(normalized)
return normalized, nil
}
func normalizeModelAdapterSorts(adapters []ModelAdapterConfig) {
sort.SliceStable(adapters, func(leftIndex, rightIndex int) bool {
left := adapters[leftIndex].Sort
right := adapters[rightIndex].Sort
switch {
case left <= 0 && right <= 0:
return false
case left <= 0:
return false
case right <= 0:
return true
default:
return left < right
}
})
for index := range adapters {
adapters[index].Sort = index + 1
}
}
func validateJSONMap(value string, fieldName string) error {
text := strings.TrimSpace(value)
if text == "" {
internal/backend/server/config/types_test.go
+60
View File
@@ -0,0 +1,60 @@
package config
import "testing"
func testModelAdapter(displayName string, sortValue int) ModelAdapterConfig {
return ModelAdapterConfig{
Sort: sortValue,
DisplayName: displayName,
Type: "openai",
BaseURL: "https://api.example.com/v1",
APIKey: "test-key",
TooltipData: displayName,
ModelID: displayName,
ReasoningEffort: "medium",
OpenAIEndpoint: "/v1/responses",
}
}
func TestNormalizeModelAdapterConfigsPreservesLegacyArrayOrder(t *testing.T) {
adapters, err := NormalizeModelAdapterConfigs([]ModelAdapterConfig{
testModelAdapter("first", 0),
testModelAdapter("second", 0),
testModelAdapter("third", 0),
})
if err != nil {
t.Fatalf("NormalizeModelAdapterConfigs returned error: %v", err)
}
for index, expectedName := range []string{"first", "second", "third"} {
if adapters[index].DisplayName != expectedName {
t.Fatalf("adapter %d = %q, want %q", index, adapters[index].DisplayName, expectedName)
}
if adapters[index].Sort != index+1 {
t.Fatalf("adapter %d sort = %d, want %d", index, adapters[index].Sort, index+1)
}
}
}
func TestNormalizeModelAdapterConfigsUsesStableExplicitSort(t *testing.T) {
adapters, err := NormalizeModelAdapterConfigs([]ModelAdapterConfig{
testModelAdapter("legacy", 0),
testModelAdapter("third", 30),
testModelAdapter("first", 10),
testModelAdapter("second-a", 20),
testModelAdapter("second-b", 20),
})
if err != nil {
t.Fatalf("NormalizeModelAdapterConfigs returned error: %v", err)
}
expectedNames := []string{"first", "second-a", "second-b", "third", "legacy"}
for index, expectedName := range expectedNames {
if adapters[index].DisplayName != expectedName {
t.Fatalf("adapter %d = %q, want %q", index, adapters[index].DisplayName, expectedName)
}
if adapters[index].Sort != index+1 {
t.Fatalf("adapter %d sort = %d, want %d", index, adapters[index].Sort, index+1)
}
}
}