feat: add Cursor IDE provider with cursor-agent integration#451
feat: add Cursor IDE provider with cursor-agent integration#451pnewell wants to merge 1 commit intorouter-for-me:mainfrom
Conversation
Adds Cursor as a new AI provider using cursor-agent as a subprocess executor. Includes OAuth auth flow, OpenAI↔Cursor NDJSON translation, streaming/non-streaming completions, thinking support (reasoning_effort), tool call parsing, and dynamic model discovery with 14 fallback models. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Summary of ChangesHello, I'm Gemini Code Assist1! I'm currently reviewing this pull request and will post my feedback shortly. In the meantime, here's a summary to help you and other reviewers quickly get up to speed! This pull request significantly expands the platform's AI provider capabilities by integrating Cursor IDE. It establishes a robust framework for authenticating with Cursor, translating requests and responses to ensure compatibility with existing OpenAI-based workflows, and managing Cursor's unique features like thinking support and tool execution. This integration allows users to seamlessly leverage Cursor's advanced AI models and agentic capabilities within the system. Highlights
🧠 New Feature in Public Preview: You can now enable Memory to help Gemini Code Assist learn from your team's feedback. This makes future code reviews more consistent and personalized to your project's style. Click here to enable Memory in your admin console. Using Gemini Code AssistThe full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips. Invoking Gemini You can request assistance from Gemini at any point by creating a comment using either
Customization To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a Limitations & Feedback Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for GitHub and other Google products, sign up here. Footnotes
|
![gemini-code-assist[bot]](https://avatars.githubusercontent.com/in/956858?s=60&v=4){kind=small}
There was a problem hiding this comment.
Code Review
This pull request adds comprehensive support for Cursor IDE as a new AI provider. The integration is well-implemented, leveraging cursor-agent for authentication and chat completions. The changes include a new OAuth flow, translation layers for OpenAI compatibility, and dynamic model discovery. My review focuses on a critical bug in the authentication flow, some dead code that can be removed, and a redundant implementation in the translation layer. Overall, this is a great addition, and with a few fixes, it will be ready to merge.
| // Read stdout in background to extract login URL | ||
| stdoutCh := make(chan string, 1) | ||
| go func() { | ||
| buf := make([]byte, 8192) | ||
| var output strings.Builder | ||
| for { | ||
| n, readErr := stdout.Read(buf) | ||
| if n > 0 { | ||
| output.Write(buf[:n]) | ||
| } | ||
| if readErr != nil { | ||
| break | ||
| } | ||
| } | ||
| stdoutCh <- output.String() | ||
| }() | ||
|
|
||
| // Read stderr in background | ||
| go func() { | ||
| buf := make([]byte, 4096) | ||
| for { | ||
| _, readErr := stderr.Read(buf) | ||
| if readErr != nil { | ||
| break | ||
| } | ||
| } | ||
| }() | ||
|
|
||
| // Try to extract URL with polling | ||
| var loginURL string | ||
| extractStart := time.Now() | ||
| for loginURL == "" && time.Since(extractStart) < urlExtractTimeout { | ||
| select { | ||
| case rawOutput := <-stdoutCh: | ||
| loginURL = extractLoginURL(rawOutput) | ||
| if loginURL == "" { | ||
| // Put it back for later | ||
| go func() { stdoutCh <- rawOutput }() | ||
| } | ||
| case <-time.After(100 * time.Millisecond): | ||
| // Keep waiting | ||
| case <-ctx.Done(): | ||
| _ = cmd.Process.Kill() | ||
| return nil, ctx.Err() | ||
| } | ||
| } |
There was a problem hiding this comment.
The current implementation for reading stdout from the cursor-agent process and extracting the login URL has a critical bug that will lead to a deadlock. The goroutine on lines 72-85 reads from the stdout pipe in a loop until it encounters an error (like io.EOF), which typically happens only when the process exits. However, the cursor-agent login process prints the URL and then waits for the user to authenticate in the browser before exiting. This creates a deadlock: the Go code waits for the process to exit to get the URL, and the process waits for the user to use the URL to exit.
The URL extraction loop on lines 98-115 is also problematic, as it uses go func() { stdoutCh <- rawOutput }() to put data back onto the channel, which is an inefficient busy-wait pattern.
I suggest refactoring this section to process the stdout stream as it arrives and extract the URL without waiting for the process to terminate.
// Read stdout in background to extract the login URL.
urlCh := make(chan string, 1)
go func() {
defer close(urlCh)
buf := make([]byte, 4096)
var output strings.Builder
for {
n, err := stdout.Read(buf)
if n > 0 {
output.Write(buf[:n])
if url := extractLoginURL(output.String()); url != "" {
urlCh <- url
// Once the URL is found, drain the rest of stdout to prevent the process from blocking.
_, _ = io.Copy(io.Discard, stdout)
return
}
}
if err != nil {
return // Exit goroutine on read error or EOF.
}
}
}()
// Read and discard stderr in the background to prevent the process from blocking.
go func() {
_, _ = io.Copy(io.Discard, stderr)
}()
// Wait for the login URL with a timeout.
var loginURL string
select {
case url, ok := <-urlCh:
if ok {
loginURL = url
}
case <-time.After(urlExtractTimeout):
log.Warn("cursor: timed out waiting for login URL from cursor-agent")
case <-ctx.Done():
_ = cmd.Process.Kill()
return nil, ctx.Err()
}| // Package cursor provides HTML templates for Cursor OAuth status pages. | ||
| package cursor | ||
|
|
||
| // SuccessHTML is displayed after successful Cursor authentication. | ||
| const SuccessHTML = `<!DOCTYPE html> | ||
| <html> | ||
| <head><title>Cursor Auth</title></head> | ||
| <body style="font-family: sans-serif; text-align: center; padding: 50px;"> | ||
| <h1>Cursor Authentication Successful</h1> | ||
| <p>You can close this window and return to the terminal.</p> | ||
| </body> | ||
| </html>` | ||
|
|
||
| // FailureHTML is displayed when Cursor authentication fails. | ||
| const FailureHTML = `<!DOCTYPE html> | ||
| <html> | ||
| <head><title>Cursor Auth</title></head> | ||
| <body style="font-family: sans-serif; text-align: center; padding: 50px;"> | ||
| <h1>Cursor Authentication Failed</h1> | ||
| <p>%s</p> | ||
| <p>Please try again.</p> | ||
| </body> | ||
| </html>` |
There was a problem hiding this comment.
This file defines HTML templates for a web-based OAuth flow. However, the Cursor authentication implemented in this pull request uses the command-line cursor-agent and does not involve a web callback to this application. As such, these templates appear to be unused. This file can likely be removed to avoid dead code in the repository.
| func (s *CursorTokenStorage) SaveTokenToFile(authFilePath string) error { | ||
| if s == nil { | ||
| return fmt.Errorf("cursor token storage is nil") | ||
| } | ||
| if err := os.MkdirAll(filepath.Dir(authFilePath), 0700); err != nil { | ||
| return fmt.Errorf("cursor: create directory: %w", err) | ||
| } | ||
| data, err := json.MarshalIndent(s, "", " ") | ||
| if err != nil { | ||
| return fmt.Errorf("cursor: marshal token: %w", err) | ||
| } | ||
| return os.WriteFile(authFilePath, data, 0600) | ||
| } |
There was a problem hiding this comment.
The SaveTokenToFile method on CursorTokenStorage appears to be unused. The application's generic token store (sdk/auth/token_store.go) saves authentication records by marshaling the coreauth.Auth struct, which includes the Storage field (CursorTokenStorage in this case). It does not call this specific SaveTokenToFile method. This method can be removed to eliminate dead code.
| // estimateCursorUsage provides rough token count estimates from character counts. | ||
| // Uses a ~4 chars per token heuristic since cursor-agent doesn't report token counts. | ||
| func estimateCursorUsage(inputChars, outputChars int) usage.Detail { | ||
| inputTokens := int64(inputChars / 4) | ||
| outputTokens := int64(outputChars / 4) | ||
| return usage.Detail{ | ||
| InputTokens: inputTokens, | ||
| OutputTokens: outputTokens, | ||
| TotalTokens: inputTokens + outputTokens, | ||
| } | ||
| } |
There was a problem hiding this comment.
The usage estimation of 4 characters per token is a reasonable heuristic. However, to improve accuracy, you could consider using a proper tokenizer library like tiktoken for a more precise estimation, especially since many of the models available through Cursor are from OpenAI. This would provide more accurate usage tracking.
| // Package openai provides response translation from Cursor NDJSON to OpenAI SSE format. | ||
| package openai | ||
|
|
||
| import ( | ||
| "context" | ||
| "encoding/json" | ||
| "time" | ||
|
|
||
| "github.com/google/uuid" | ||
| cursorcommon "github.com/router-for-me/CLIProxyAPI/v6/internal/translator/cursor/common" | ||
| "github.com/tidwall/gjson" | ||
| ) | ||
|
|
||
| // CursorStreamState tracks the state of streaming response conversion. | ||
| type CursorStreamState struct { | ||
| ChunkIndex int | ||
| ToolCallIndex int | ||
| HasSentFirstChunk bool | ||
| Model string | ||
| ResponseID string | ||
| Created int64 | ||
| } | ||
|
|
||
| // NewCursorStreamState creates a new stream state for tracking. | ||
| func NewCursorStreamState(model string) *CursorStreamState { | ||
| return &CursorStreamState{ | ||
| Model: model, | ||
| ResponseID: "chatcmpl-" + uuid.New().String()[:24], | ||
| Created: time.Now().Unix(), | ||
| } | ||
| } | ||
|
|
||
| // ConvertCursorStreamToOpenAI converts a Cursor NDJSON line to OpenAI SSE format chunks. | ||
| func ConvertCursorStreamToOpenAI(_ context.Context, model string, _, _, rawJSON []byte, param *any) []string { | ||
| if len(rawJSON) == 0 { | ||
| return nil | ||
| } | ||
|
|
||
| // Initialize state on first call | ||
| if *param == nil { | ||
| *param = NewCursorStreamState(model) | ||
| } | ||
| state := (*param).(*CursorStreamState) | ||
|
|
||
| line := rawJSON | ||
| eventType := gjson.GetBytes(line, "type").String() | ||
|
|
||
| var results []string | ||
|
|
||
| switch eventType { | ||
| case "assistant": | ||
| contentArr := gjson.GetBytes(line, "message.content") | ||
| if !contentArr.IsArray() { | ||
| return nil | ||
| } | ||
| for _, item := range contentArr.Array() { | ||
| itemType := item.Get("type").String() | ||
| switch itemType { | ||
| case "text": | ||
| text := item.Get("text").String() | ||
| if text == "" { | ||
| continue | ||
| } | ||
| chunk := buildTextDelta(state, text) | ||
| results = append(results, chunk) | ||
| case "thinking": | ||
| thinkText := item.Get("thinking").String() | ||
| if thinkText == "" { | ||
| continue | ||
| } | ||
| chunk := buildReasoningDelta(state, thinkText) | ||
| results = append(results, chunk) | ||
| } | ||
| } | ||
|
|
||
| case "thinking": | ||
| subtype := gjson.GetBytes(line, "subtype").String() | ||
| if subtype == "delta" { | ||
| text := gjson.GetBytes(line, "text").String() | ||
| if text != "" { | ||
| chunk := buildReasoningDelta(state, text) | ||
| results = append(results, chunk) | ||
| } | ||
| } | ||
| // "completed" subtype: no-op | ||
|
|
||
| case "tool_call": | ||
| toolCallObj := gjson.GetBytes(line, "tool_call") | ||
| if !toolCallObj.IsObject() { | ||
| return nil | ||
| } | ||
|
|
||
| callID := gjson.GetBytes(line, "call_id").String() | ||
| if callID == "" { | ||
| callID = "call_" + uuid.New().String()[:8] | ||
| } | ||
|
|
||
| toolCallObj.ForEach(func(key, value gjson.Result) bool { | ||
| rawName := key.String() | ||
| toolName := cursorcommon.ResolveToolName(rawName) | ||
|
|
||
| // Extract arguments | ||
| var argsJSON string | ||
| args := value.Get("args") | ||
| if args.Exists() && args.IsObject() { | ||
| argsJSON = args.Raw | ||
| } else if value.IsObject() { | ||
| argsJSON = value.Raw | ||
| } | ||
|
|
||
| // Emit tool call start | ||
| startChunk := buildToolCallStart(state, callID, toolName) | ||
| results = append(results, startChunk) | ||
|
|
||
| // Emit tool call arguments | ||
| if argsJSON != "" { | ||
| argsChunk := buildToolCallArgsDelta(state, argsJSON) | ||
| results = append(results, argsChunk) | ||
| } | ||
|
|
||
| state.ToolCallIndex++ | ||
| return false // only process first key | ||
| }) | ||
|
|
||
| case "result": | ||
| finishReason := "stop" | ||
| chunk := buildFinish(state, finishReason) | ||
| results = append(results, chunk) | ||
|
|
||
| // system, user events: skip | ||
| } | ||
|
|
||
| return results | ||
| } | ||
|
|
||
| // ConvertCursorNonStreamToOpenAI converts accumulated Cursor responses to a non-streaming OpenAI response. | ||
| func ConvertCursorNonStreamToOpenAI(_ context.Context, model string, _, _, rawJSON []byte, _ *any) string { | ||
| // For non-streaming, rawJSON is the full accumulated response | ||
| // Build a standard chat.completion response | ||
| content := string(rawJSON) | ||
|
|
||
| response := map[string]interface{}{ | ||
| "id": "chatcmpl-" + uuid.New().String()[:24], | ||
| "object": "chat.completion", | ||
| "created": time.Now().Unix(), | ||
| "model": model, | ||
| "choices": []map[string]interface{}{ | ||
| { | ||
| "index": 0, | ||
| "message": map[string]interface{}{ | ||
| "role": "assistant", | ||
| "content": content, | ||
| }, | ||
| "finish_reason": "stop", | ||
| }, | ||
| }, | ||
| "usage": map[string]interface{}{ | ||
| "prompt_tokens": 0, | ||
| "completion_tokens": 0, | ||
| "total_tokens": 0, | ||
| }, | ||
| } | ||
|
|
||
| result, _ := json.Marshal(response) | ||
| return string(result) | ||
| } | ||
|
|
||
| // --- SSE chunk builders --- | ||
|
|
||
| func buildTextDelta(state *CursorStreamState, text string) string { | ||
| delta := map[string]interface{}{"content": text} | ||
| if !state.HasSentFirstChunk { | ||
| delta["role"] = "assistant" | ||
| state.HasSentFirstChunk = true | ||
| } | ||
| chunk := buildBaseChunk(state, delta, nil) | ||
| result, _ := json.Marshal(chunk) | ||
| state.ChunkIndex++ | ||
| return string(result) | ||
| } | ||
|
|
||
| func buildReasoningDelta(state *CursorStreamState, text string) string { | ||
| delta := map[string]interface{}{"reasoning_content": text} | ||
| if !state.HasSentFirstChunk { | ||
| delta["role"] = "assistant" | ||
| state.HasSentFirstChunk = true | ||
| } | ||
| chunk := buildBaseChunk(state, delta, nil) | ||
| result, _ := json.Marshal(chunk) | ||
| state.ChunkIndex++ | ||
| return string(result) | ||
| } | ||
|
|
||
| func buildToolCallStart(state *CursorStreamState, callID, name string) string { | ||
| tc := map[string]interface{}{ | ||
| "index": state.ToolCallIndex, | ||
| "id": callID, | ||
| "type": "function", | ||
| "function": map[string]interface{}{ | ||
| "name": name, | ||
| "arguments": "", | ||
| }, | ||
| } | ||
| delta := map[string]interface{}{ | ||
| "tool_calls": []map[string]interface{}{tc}, | ||
| } | ||
| if !state.HasSentFirstChunk { | ||
| delta["role"] = "assistant" | ||
| state.HasSentFirstChunk = true | ||
| } | ||
| chunk := buildBaseChunk(state, delta, nil) | ||
| result, _ := json.Marshal(chunk) | ||
| state.ChunkIndex++ | ||
| return string(result) | ||
| } | ||
|
|
||
| func buildToolCallArgsDelta(state *CursorStreamState, args string) string { | ||
| tc := map[string]interface{}{ | ||
| "index": state.ToolCallIndex, | ||
| "function": map[string]interface{}{ | ||
| "arguments": args, | ||
| }, | ||
| } | ||
| delta := map[string]interface{}{ | ||
| "tool_calls": []map[string]interface{}{tc}, | ||
| } | ||
| chunk := buildBaseChunk(state, delta, nil) | ||
| result, _ := json.Marshal(chunk) | ||
| state.ChunkIndex++ | ||
| return string(result) | ||
| } | ||
|
|
||
| func buildFinish(state *CursorStreamState, finishReason string) string { | ||
| chunk := buildBaseChunk(state, map[string]interface{}{}, &finishReason) | ||
| result, _ := json.Marshal(chunk) | ||
| state.ChunkIndex++ | ||
| return string(result) | ||
| } | ||
|
|
||
| func buildBaseChunk(state *CursorStreamState, delta map[string]interface{}, finishReason *string) map[string]interface{} { | ||
| choice := map[string]interface{}{ | ||
| "index": 0, | ||
| "delta": delta, | ||
| } | ||
| if finishReason != nil { | ||
| choice["finish_reason"] = *finishReason | ||
| } else { | ||
| choice["finish_reason"] = nil | ||
| } | ||
| return map[string]interface{}{ | ||
| "id": state.ResponseID, | ||
| "object": "chat.completion.chunk", | ||
| "created": state.Created, | ||
| "model": state.Model, | ||
| "choices": []map[string]interface{}{choice}, | ||
| } | ||
| } |
There was a problem hiding this comment.
The response translation functions in this file (ConvertCursorStreamToOpenAI and ConvertCursorNonStreamToOpenAI) appear to be redundant. The CursorExecutor in internal/runtime/executor/cursor_executor.go is already responsible for parsing the NDJSON output from cursor-agent and constructing an OpenAI-compatible response directly, for both streaming and non-streaming cases.
Since the executor handles the response translation, these functions are likely unused in the current execution flow. It would be good to verify if they are called from somewhere I might have missed; otherwise, they could be removed to avoid confusion and dead code.
1 participant
Adds comprehensive support for Cursor IDE as a new AI provider via cursor-agent subprocess execution. Includes an OAuth authentication flow using
cursor-agent login, bidirectional translation between OpenAI Chat Completions and Cursor's NDJSON streaming format, and streaming/non-streaming response handling. Thinking support is implemented viareasoning_effort(low/medium/high), and tool call parsing maps Cursor's verbose tool names back to canonical names for OpenAI compatibility. Dynamic model discovery is implemented with a fallback to 14 hardcoded models covering Claude, GPT, Gemini, Grok, and Kimi variants.🤖 Generated with Claude Code