vercel-ai-cursor-provider 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,61 @@
+# vercel-ai-cursor-provider
+
+A [Vercel AI SDK](https://sdk.vercel.ai/) custom provider for **Cursor**, leveraging the `cursor-agent` CLI.
+
+## Features
+
+- Use any model supported by your Cursor subscription (Claude 3.5 Sonnet, GPT-4o, etc.)
+- Supports streaming via `streamText`
+- References logic from `opencode-cursor` for robust Prompt building
+
+## Prerequisites
+
+- **Cursor** installed on your machine.
+- `cursor-agent` CLI available in your PATH.
+  - You can usually install it via: `curl -fsS https://cursor.com/install | bash`
+- You must be logged into `cursor-agent`: `cursor-agent login`
+
+## Installation
+
+```bash
+npm install vercel-ai-cursor-provider @ai-sdk/provider ai
+```
+
+## Usage
+
+```typescript
+import { streamText } from 'ai';
+import { createCursor } from 'vercel-ai-cursor-provider';
+
+// Create the provider
+const cursor = createCursor({
+  workspace: process.cwd(), // Optional: project workspace for cursor-agent context
+});
+
+// Use it with Vercel AI SDK
+const { textStream } = await streamText({
+  model: cursor('claude-3.5-sonnet'),
+  prompt: 'Write a TypeScript function to calculate fibonacci numbers.',
+});
+
+for await (const text of textStream) {
+  process.stdout.write(text);
+}
+```
+
+## Configuration
+
+`createCursor` accepts an optional options object:
+
+| Option | Type | Description |
+| --- | --- | --- |
+| `command` | `string` | Path to `cursor-agent` binary. Defaults to `cursor-agent`. |
+| `workspace` | `string` | The directory `cursor-agent` should treat as the project workspace. |
+
+## Credits
+
+Inspired by the [opencode-cursor](https://github.com/Nomadcxx/opencode-cursor) project by Nomadcxx.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { LanguageModelV1, LanguageModelV1StreamPart } from '@ai-sdk/provider';
+export interface CursorOptions {
+    /**
+     * Path to cursor-agent. Defaults to 'cursor-agent' (searched in PATH).
+     */
+    command?: string;
+    /**
+     * Workspace path for cursor-agent.
+     */
+    workspace?: string;
+}
+export declare class CursorLanguageModel implements LanguageModelV1 {
+    readonly modelId: string;
+    private options;
+    readonly specificationVersion = "v1";
+    readonly defaultObjectGenerationMode: undefined;
+    constructor(modelId: string, options?: CursorOptions);
+    get provider(): string;
+    doGenerate(options: any): Promise<any>;
+    doStream(options: any): Promise<{
+        stream: ReadableStream<LanguageModelV1StreamPart>;
+        rawCall: {
+            rawPrompt: string;
+            rawSettings: any;
+        };
+    }>;
+}
+export declare function createCursor(options?: CursorOptions): (modelId: string) => CursorLanguageModel;

package/dist/index.js

@@ -0,0 +1,114 @@
+import { spawn } from 'child_process';
+import { Readable } from 'stream';
+/**
+ * Builds a prompt string compatible with cursor-agent from Vercel AI SDK messages.
+ */
+function buildCursorPrompt(messages, tools) {
+    const lines = [];
+    if (tools && tools.length > 0) {
+        const toolDescs = tools.map((t) => {
+            const fn = t.function || t;
+            return `- ${fn.name}: ${fn.description || ''}\n  Parameters: ${JSON.stringify(fn.parameters || {})}`;
+        }).join('\n');
+        lines.push(`SYSTEM: You have access to the following tools:\n${toolDescs}`);
+    }
+    for (const message of messages) {
+        const role = message.role.toUpperCase();
+        let content = '';
+        if (Array.isArray(message.content)) {
+            content = message.content
+                .filter((c) => c.type === 'text')
+                .map((c) => c.text)
+                .join('\n');
+        }
+        else {
+            content = message.content || '';
+        }
+        if (message.role === 'tool') {
+            lines.push(`TOOL_RESULT (call_id: ${message.toolCallId}): ${content}`);
+        }
+        else if (message.role === 'assistant' && message.toolCalls) {
+            const tcs = message.toolCalls.map((tc) => `tool_call(id: ${tc.toolCallId}, name: ${tc.toolName}, args: ${JSON.stringify(tc.args)})`).join('\n');
+            lines.push(`ASSISTANT: ${content ? content + '\n' : ''}${tcs}`);
+        }
+        else {
+            lines.push(`${role}: ${content}`);
+        }
+    }
+    return lines.join('\n\n');
+}
+export class CursorLanguageModel {
+    modelId;
+    options;
+    specificationVersion = 'v1';
+    defaultObjectGenerationMode = undefined;
+    constructor(modelId, options = {}) {
+        this.modelId = modelId;
+        this.options = options;
+    }
+    get provider() { return 'cursor'; }
+    async doGenerate(options) {
+        throw new Error('doGenerate not implemented, please use streamText');
+    }
+    async doStream(options) {
+        const prompt = buildCursorPrompt(options.prompt, options.tools || []);
+        const cmd = this.options.command || 'cursor-agent';
+        const workspace = this.options.workspace || process.cwd();
+        const args = [
+            '--print',
+            '--output-format', 'stream-json',
+            '--stream-partial-output',
+            '--workspace', workspace,
+            '--model', this.modelId,
+        ];
+        const child = spawn(cmd, args, { stdio: ['pipe', 'pipe', 'pipe'] });
+        child.stdin.write(prompt);
+        child.stdin.end();
+        const stream = new ReadableStream({
+            async start(controller) {
+                const reader = Readable.toWeb(child.stdout);
+                const decoder = new TextDecoder();
+                let buffer = '';
+                try {
+                    for await (const chunk of reader) {
+                        buffer += decoder.decode(chunk, { stream: true });
+                        const lines = buffer.split('\n');
+                        buffer = lines.pop() || '';
+                        for (const line of lines) {
+                            if (!line.trim())
+                                continue;
+                            try {
+                                const event = JSON.parse(line);
+                                if (event.type === 'assistant' || event.type === 'thinking') {
+                                    const text = event.type === 'thinking' ? event.text :
+                                        event.message?.content?.find((c) => c.type === 'text')?.text;
+                                    if (text) {
+                                        controller.enqueue({ type: 'text-delta', textDelta: text });
+                                    }
+                                }
+                            }
+                            catch (e) {
+                                // Ignore parse errors for partial lines
+                            }
+                        }
+                    }
+                }
+                finally {
+                    controller.enqueue({
+                        type: 'finish',
+                        finishReason: 'stop',
+                        usage: { promptTokens: 0, completionTokens: 0 }
+                    });
+                    controller.close();
+                }
+            }
+        });
+        return {
+            stream,
+            rawCall: { rawPrompt: prompt, rawSettings: options },
+        };
+    }
+}
+export function createCursor(options = {}) {
+    return (modelId) => new CursorLanguageModel(modelId, options);
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "vercel-ai-cursor-provider",
+  "version": "0.1.0",
+  "description": "Vercel AI SDK provider for Cursor (using cursor-agent)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "vercel-ai-sdk",
+    "cursor",
+    "cursor-agent",
+    "ai-provider"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@ai-sdk/provider": "^1.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  }
+}