@ai-ide-bridge/cli 1.1.2 → 1.2.0

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> @ai-ide-bridge/cli@1.1.2 build /home/runner/work/llm-bridge/llm-bridge/cli
+> @ai-ide-bridge/cli@1.2.0 build /home/runner/work/llm-bridge/llm-bridge/cli
 > tsc
 

package/dist/core/index.d.ts

@@ -7,3 +7,5 @@ export { PluginRegistry } from './registry.js';
 export { loadConfig, saveConfig, configPath } from './config.js';
 export { createDaemonManager, type DaemonManager } from './daemon.js';
 export { DaemonBridgeSession } from './daemon-session.js';
+export { parseSSE, createTransport, createStream } from './sse/index.js';
+export type { SSEEvent, TransportOptions, Transport, StreamOptions } from './sse/index.js';

package/dist/core/index.js

@@ -7,3 +7,4 @@ export { PluginRegistry } from './registry.js';
 export { loadConfig, saveConfig, configPath } from './config.js';
 export { createDaemonManager } from './daemon.js';
 export { DaemonBridgeSession } from './daemon-session.js';
+export { parseSSE, createTransport, createStream } from './sse/index.js';

package/dist/core/sse/client.d.ts

@@ -0,0 +1,8 @@
+import type { StreamChunk } from '../types.js';
+import { TransportOptions } from './transport.js';
+import { SSEEvent } from './parser.js';
+export interface StreamOptions extends Omit<TransportOptions, 'signal'> {
+    parseEvent(event: SSEEvent): StreamChunk | null;
+    signal?: AbortSignal;
+}
+export declare function createStream(opts: StreamOptions): AsyncIterable<StreamChunk>;

package/dist/core/sse/client.js

@@ -0,0 +1,14 @@
+import { createTransport } from './transport.js';
+export async function* createStream(opts) {
+    const { parseEvent, signal, ...transportOpts } = opts;
+    const transport = createTransport({ ...transportOpts, signal });
+    if (signal) {
+        signal.addEventListener('abort', () => transport.abort());
+    }
+    for await (const event of transport.stream()) {
+        const chunk = parseEvent(event);
+        if (chunk) {
+            yield chunk;
+        }
+    }
+}

package/dist/core/sse/index.d.ts

@@ -0,0 +1,3 @@
+export { parseSSE, type SSEEvent } from './parser.js';
+export { createTransport, type TransportOptions, type Transport } from './transport.js';
+export { createStream, type StreamOptions } from './client.js';

package/dist/core/sse/index.js

@@ -0,0 +1,3 @@
+export { parseSSE } from './parser.js';
+export { createTransport } from './transport.js';
+export { createStream } from './client.js';

package/dist/core/sse/parser.d.ts

@@ -0,0 +1,7 @@
+export interface SSEEvent {
+    id?: string;
+    event?: string;
+    data: string;
+    retry?: number;
+}
+export declare function parseSSE(stream: ReadableStream<Uint8Array>): AsyncIterable<SSEEvent>;

package/dist/core/sse/parser.js

@@ -0,0 +1,102 @@
+export async function* parseSSE(stream) {
+    const decoder = new TextDecoder();
+    const reader = stream.getReader();
+    let buffer = '';
+    let eventId;
+    let eventType;
+    let eventData = '';
+    let retryMs;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let lineEnd = buffer.indexOf('\n');
+            while (lineEnd !== -1) {
+                const line = buffer.slice(0, lineEnd).trimEnd();
+                buffer = buffer.slice(lineEnd + 1);
+                if (line.startsWith(':')) {
+                    // Comment line, skip
+                }
+                else if (line === '') {
+                    // Empty line = event boundary
+                    if (eventData || eventType || eventId) {
+                        yield {
+                            id: eventId,
+                            event: eventType,
+                            data: eventData,
+                            retry: retryMs,
+                        };
+                        eventId = undefined;
+                        eventType = undefined;
+                        eventData = '';
+                    }
+                }
+                else {
+                    const colonIndex = line.indexOf(':');
+                    const field = colonIndex === -1 ? line : line.slice(0, colonIndex);
+                    const value = colonIndex === -1 ? '' : line.slice(colonIndex + 1).trimStart();
+                    switch (field) {
+                        case 'id':
+                            eventId = value;
+                            break;
+                        case 'event':
+                            eventType = value;
+                            break;
+                        case 'data':
+                            eventData = eventData ? eventData + '\n' + value : value;
+                            break;
+                        case 'retry': {
+                            const parsed = parseInt(value, 10);
+                            if (!isNaN(parsed))
+                                retryMs = parsed;
+                            break;
+                        }
+                    }
+                }
+                lineEnd = buffer.indexOf('\n');
+            }
+        }
+        // Flush remaining buffer
+        if (buffer.trim()) {
+            const line = buffer.trim();
+            if (line.startsWith(':')) {
+                // Comment, skip
+            }
+            else if (line === '') {
+                if (eventData || eventType || eventId) {
+                    yield { id: eventId, event: eventType, data: eventData, retry: retryMs };
+                }
+            }
+            else {
+                const colonIndex = line.indexOf(':');
+                const field = colonIndex === -1 ? line : line.slice(0, colonIndex);
+                const value = colonIndex === -1 ? '' : line.slice(colonIndex + 1).trimStart();
+                switch (field) {
+                    case 'id':
+                        eventId = value;
+                        break;
+                    case 'event':
+                        eventType = value;
+                        break;
+                    case 'data':
+                        eventData = eventData ? eventData + '\n' + value : value;
+                        break;
+                    case 'retry': {
+                        const parsed = parseInt(value, 10);
+                        if (!isNaN(parsed))
+                            retryMs = parsed;
+                        break;
+                    }
+                }
+                if (eventData || eventType || eventId) {
+                    yield { id: eventId, event: eventType, data: eventData, retry: retryMs };
+                }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

package/dist/core/sse/transport.d.ts

@@ -0,0 +1,16 @@
+import { SSEEvent } from './parser.js';
+export interface TransportOptions {
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    signal?: AbortSignal;
+    timeout?: number;
+    maxRetries?: number;
+    retryDelay?: number;
+}
+export interface Transport {
+    stream(): AsyncIterable<SSEEvent>;
+    abort(): void;
+}
+export declare function createTransport(opts: TransportOptions): Transport;

package/dist/core/sse/transport.js

@@ -0,0 +1,72 @@
+import { parseSSE } from './parser.js';
+export function createTransport(opts) {
+    const { url, method = 'POST', headers = {}, body, signal, timeout = 30000, maxRetries = 3, retryDelay = 1000, } = opts;
+    let aborted = false;
+    return {
+        stream() {
+            return streamWithRetry();
+        },
+        abort() {
+            aborted = true;
+        },
+    };
+    async function* streamWithRetry() {
+        let lastEventId;
+        let retries = 0;
+        while (!aborted && retries <= maxRetries) {
+            const requestHeaders = { ...headers };
+            if (lastEventId) {
+                requestHeaders['Last-Event-ID'] = lastEventId;
+            }
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), timeout);
+                if (signal) {
+                    signal.addEventListener('abort', () => controller.abort());
+                }
+                const response = await fetch(url, {
+                    method,
+                    headers: requestHeaders,
+                    body,
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    if (response.status >= 400 && response.status < 500) {
+                        const errorText = await response.text().catch(() => '');
+                        yield { event: 'error', data: `HTTP ${response.status}: ${errorText}` };
+                        return;
+                    }
+                    throw new Error(`HTTP ${response.status}`);
+                }
+                if (!response.body) {
+                    yield { event: 'error', data: 'No response body' };
+                    return;
+                }
+                retries = 0;
+                for await (const event of parseSSE(response.body)) {
+                    if (event.id)
+                        lastEventId = event.id;
+                    yield event;
+                }
+                return;
+            }
+            catch (e) {
+                if (aborted)
+                    return;
+                const isAbort = e instanceof DOMException && e.name === 'AbortError';
+                if (isAbort && retries >= maxRetries) {
+                    yield { event: 'error', data: 'Request timed out' };
+                    return;
+                }
+                retries++;
+                if (retries > maxRetries) {
+                    yield { event: 'error', data: e instanceof Error ? e.message : String(e) };
+                    return;
+                }
+                const delay = retryDelay * Math.pow(2, retries - 1);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+    }
+}

package/dist/plugins/cursor/plugin.js

@@ -1,5 +1,5 @@
-import { Cursor } from '@cursor/sdk';
 import { CursorBridgeSession } from './session.js';
+const CURSOR_API_BASE = 'https://api2.cursor.sh';
 export class CursorBridgePlugin {
     name = 'cursor';
     version = '2.0.0';
@@ -8,8 +8,10 @@ export class CursorBridgePlugin {
         if (!apiKey)
             return false;
         try {
-            await Cursor.me({ apiKey });
-            return true;
+            const response = await fetch(`${CURSOR_API_BASE}/auth/whoami`, {
+                headers: { Authorization: `Bearer ${apiKey}` },
+            });
+            return response.ok;
         }
         catch {
             return false;
@@ -19,18 +21,43 @@ export class CursorBridgePlugin {
         const apiKey = config.CURSOR_API_KEY;
         if (!apiKey)
             throw new Error('Missing CURSOR_API_KEY');
-        const models = await Cursor.models.list({ apiKey });
-        return models.map((m) => ({
-            id: m.id,
-            name: m.id,
-            capabilities: { streaming: true, tools: true },
-        }));
+        try {
+            const response = await fetch(`${CURSOR_API_BASE}/models`, {
+                headers: { Authorization: `Bearer ${apiKey}` },
+            });
+            if (!response.ok) {
+                return defaultModels();
+            }
+            const data = await response.json();
+            if (Array.isArray(data)) {
+                return data.map((m) => ({
+                    id: m.id ?? m.name ?? 'unknown',
+                    name: m.name ?? m.id ?? 'unknown',
+                    capabilities: { streaming: true, tools: true },
+                }));
+            }
+        }
+        catch {
+            // Fall through to defaults
+        }
+        return defaultModels();
     }
     async createSession(config, model) {
         const apiKey = config.CURSOR_API_KEY;
         if (!apiKey)
             throw new Error('Missing CURSOR_API_KEY');
-        const cwd = config.CURSOR_OPENCODE_BRIDGE_CWD ?? process.cwd();
-        return new CursorBridgeSession(apiKey, model, cwd);
+        return new CursorBridgeSession(apiKey, model);
     }
 }
+function defaultModels() {
+    return [
+        { id: 'composer-2', name: 'Composer 2', capabilities: { streaming: true, tools: true } },
+        { id: 'composer-2.5', name: 'Composer 2.5', capabilities: { streaming: true, tools: true } },
+        { id: 'gpt-4o', name: 'GPT-4o', capabilities: { streaming: true, tools: true } },
+        {
+            id: 'claude-3.5-sonnet',
+            name: 'Claude 3.5 Sonnet',
+            capabilities: { streaming: true, tools: true },
+        },
+    ];
+}

package/dist/plugins/cursor/session.d.ts

@@ -1,11 +1,8 @@
 import type { BridgeSession, Message, ToolDefinition, StreamChunk } from '../../core/index.js';
 export declare class CursorBridgeSession implements BridgeSession {
-    private agent;
     private apiKey;
     private modelId;
-    private cwd;
-    constructor(apiKey: string, modelId: string, cwd?: string);
+    constructor(apiKey: string, modelId: string);
     send(messages: Message[], tools?: ToolDefinition[]): AsyncIterable<StreamChunk>;
     dispose(): Promise<void>;
-    private buildPrompt;
 }

package/dist/plugins/cursor/session.js

@@ -1,73 +1,83 @@
-import { Agent } from '@cursor/sdk';
-import { translateTools } from './tools.js';
+import { createStream } from '../../core/index.js';
+const CURSOR_API_BASE = 'https://api2.cursor.sh';
 export class CursorBridgeSession {
-    agent = null;
     apiKey;
     modelId;
-    cwd;
-    constructor(apiKey, modelId, cwd = process.cwd()) {
+    constructor(apiKey, modelId) {
         this.apiKey = apiKey;
         this.modelId = modelId;
-        this.cwd = cwd;
     }
     async *send(messages, tools) {
-        const prompt = this.buildPrompt(messages);
-        const cursorTools = tools ? translateTools(tools) : undefined;
-        try {
-            this.agent = await Agent.create({
-                apiKey: this.apiKey,
-                model: { id: this.modelId },
-                local: { cwd: this.cwd, settingSources: [] },
-            });
-            const sendOptions = {
-                model: { id: this.modelId },
-                onDelta: ({ update }) => {
-                    if (update.type === 'text-delta' && 'text' in update && update.text) {
-                        // onDelta is synchronous callback, we buffer and yield in the loop
-                    }
-                },
-            };
-            const run = await this.agent.send(prompt, sendOptions);
-            const result = await run.wait();
-            if (result.status === 'error' || result.status === 'cancelled') {
-                yield {
-                    type: 'error',
-                    content: `Agent run ${result.status}: ${result.result ?? 'no details'}`,
-                    finishReason: 'error',
-                };
-                return;
-            }
-            yield { type: 'text', content: result.result ?? '', finishReason: 'stop' };
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            yield { type: 'error', content: msg, finishReason: 'error' };
+        const body = JSON.stringify({
+            model: this.modelId,
+            messages: messages.map((m) => ({
+                role: m.role,
+                content: m.content,
+                ...(m.tool_calls && { tool_calls: m.tool_calls }),
+                ...(m.tool_call_id && { tool_call_id: m.tool_call_id }),
+                ...(m.name && { name: m.name }),
+            })),
+            ...(tools && { tools: tools.map((t) => t) }),
+            stream: true,
+        });
+        for await (const chunk of createStream({
+            url: `${CURSOR_API_BASE}/aiserver.v1.AiService/StreamChat`,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.apiKey}`,
+                Accept: 'text/event-stream',
+            },
+            body,
+            parseEvent: parseCursorEvent,
+        })) {
+            yield chunk;
         }
     }
     async dispose() {
-        if (this.agent) {
-            try {
-                await this.agent[Symbol.asyncDispose]();
-            }
-            catch {
-                // Ignore dispose errors
+        // No state to dispose with direct HTTP
+    }
+}
+function parseCursorEvent(event) {
+    if (event.event === 'error') {
+        return { type: 'error', content: event.data, finishReason: 'error' };
+    }
+    if (event.data === '' || event.data === '[DONE]') {
+        return { type: 'done', finishReason: 'stop' };
+    }
+    try {
+        const json = JSON.parse(event.data);
+        if (json.error) {
+            return {
+                type: 'error',
+                content: json.error.message ?? JSON.stringify(json.error),
+                finishReason: 'error',
+            };
+        }
+        if (json.choices?.[0]?.delta?.content) {
+            return { type: 'text', content: json.choices[0].delta.content };
+        }
+        if (json.choices?.[0]?.delta?.tool_calls) {
+            for (const tc of json.choices[0].delta.tool_calls) {
+                return {
+                    type: 'tool_call',
+                    toolCall: {
+                        id: tc.id ?? `tc-${Date.now()}`,
+                        name: tc.function?.name ?? '',
+                        arguments: tc.function?.arguments ?? '',
+                    },
+                };
             }
-            this.agent = null;
         }
-    }
-    buildPrompt(messages) {
-        const blocks = [];
-        for (const m of messages) {
-            const text = typeof m.content === 'string'
-                ? m.content
-                : m.content != null
-                    ? JSON.stringify(m.content)
-                    : '';
-            if (!text)
-                continue;
-            const label = m.role === 'tool' ? `tool (${m.tool_call_id ?? m.name ?? 'result'})` : m.role;
-            blocks.push(`[${label}]\n${text}`);
+        if (json.choices?.[0]?.finish_reason) {
+            return {
+                type: 'done',
+                finishReason: json.choices[0].finish_reason === 'stop' ? 'stop' : 'tool_calls',
+            };
         }
-        return `\nFollow this conversation transcript and reply as the assistant.\n\n${blocks.join('\n\n---\n\n')}\n`;
     }
+    catch {
+        return null;
+    }
+    return null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ide-bridge/cli",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "type": "module",
   "bin": {
     "llm-bridge": "./dist/index.js"
@@ -15,7 +15,6 @@
   },
   "dependencies": {
     "@ai-ide-bridge/oauth": "workspace:*",
-    "@cursor/sdk": "^1.0.13",
     "zod": "^3.25.76"
   },
   "devDependencies": {

package/src/core/index.ts

@@ -7,3 +7,5 @@ export { PluginRegistry } from './registry.js';
 export { loadConfig, saveConfig, configPath } from './config.js';
 export { createDaemonManager, type DaemonManager } from './daemon.js';
 export { DaemonBridgeSession } from './daemon-session.js';
+export { parseSSE, createTransport, createStream } from './sse/index.js';
+export type { SSEEvent, TransportOptions, Transport, StreamOptions } from './sse/index.js';

package/src/core/sse/client.ts

@@ -0,0 +1,24 @@
+import type { StreamChunk } from '../types.js';
+import { createTransport, TransportOptions } from './transport.js';
+import { SSEEvent } from './parser.js';
+
+export interface StreamOptions extends Omit<TransportOptions, 'signal'> {
+  parseEvent(event: SSEEvent): StreamChunk | null;
+  signal?: AbortSignal;
+}
+
+export async function* createStream(opts: StreamOptions): AsyncIterable<StreamChunk> {
+  const { parseEvent, signal, ...transportOpts } = opts;
+  const transport = createTransport({ ...transportOpts, signal });
+
+  if (signal) {
+    signal.addEventListener('abort', () => transport.abort());
+  }
+
+  for await (const event of transport.stream()) {
+    const chunk = parseEvent(event);
+    if (chunk) {
+      yield chunk;
+    }
+  }
+}

package/src/core/sse/index.ts

@@ -0,0 +1,3 @@
+export { parseSSE, type SSEEvent } from './parser.js';
+export { createTransport, type TransportOptions, type Transport } from './transport.js';
+export { createStream, type StreamOptions } from './client.js';

package/src/core/sse/parser.ts

@@ -0,0 +1,109 @@
+export interface SSEEvent {
+  id?: string;
+  event?: string;
+  data: string;
+  retry?: number;
+}
+
+export async function* parseSSE(stream: ReadableStream<Uint8Array>): AsyncIterable<SSEEvent> {
+  const decoder = new TextDecoder();
+  const reader = stream.getReader();
+
+  let buffer = '';
+  let eventId: string | undefined;
+  let eventType: string | undefined;
+  let eventData = '';
+  let retryMs: number | undefined;
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+
+      let lineEnd = buffer.indexOf('\n');
+      while (lineEnd !== -1) {
+        const line = buffer.slice(0, lineEnd).trimEnd();
+        buffer = buffer.slice(lineEnd + 1);
+
+        if (line.startsWith(':')) {
+          // Comment line, skip
+        } else if (line === '') {
+          // Empty line = event boundary
+          if (eventData || eventType || eventId) {
+            yield {
+              id: eventId,
+              event: eventType,
+              data: eventData,
+              retry: retryMs,
+            };
+            eventId = undefined;
+            eventType = undefined;
+            eventData = '';
+          }
+        } else {
+          const colonIndex = line.indexOf(':');
+          const field = colonIndex === -1 ? line : line.slice(0, colonIndex);
+          const value = colonIndex === -1 ? '' : line.slice(colonIndex + 1).trimStart();
+
+          switch (field) {
+            case 'id':
+              eventId = value;
+              break;
+            case 'event':
+              eventType = value;
+              break;
+            case 'data':
+              eventData = eventData ? eventData + '\n' + value : value;
+              break;
+            case 'retry': {
+              const parsed = parseInt(value, 10);
+              if (!isNaN(parsed)) retryMs = parsed;
+              break;
+            }
+          }
+        }
+
+        lineEnd = buffer.indexOf('\n');
+      }
+    }
+
+    // Flush remaining buffer
+    if (buffer.trim()) {
+      const line = buffer.trim();
+      if (line.startsWith(':')) {
+        // Comment, skip
+      } else if (line === '') {
+        if (eventData || eventType || eventId) {
+          yield { id: eventId, event: eventType, data: eventData, retry: retryMs };
+        }
+      } else {
+        const colonIndex = line.indexOf(':');
+        const field = colonIndex === -1 ? line : line.slice(0, colonIndex);
+        const value = colonIndex === -1 ? '' : line.slice(colonIndex + 1).trimStart();
+        switch (field) {
+          case 'id':
+            eventId = value;
+            break;
+          case 'event':
+            eventType = value;
+            break;
+          case 'data':
+            eventData = eventData ? eventData + '\n' + value : value;
+            break;
+          case 'retry': {
+            const parsed = parseInt(value, 10);
+            if (!isNaN(parsed)) retryMs = parsed;
+            break;
+          }
+        }
+        if (eventData || eventType || eventId) {
+          yield { id: eventId, event: eventType, data: eventData, retry: retryMs };
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}

package/src/core/sse/transport.ts

@@ -0,0 +1,111 @@
+import { parseSSE, SSEEvent } from './parser.js';
+
+export interface TransportOptions {
+  url: string;
+  method?: string;
+  headers?: Record<string, string>;
+  body?: string;
+  signal?: AbortSignal;
+  timeout?: number;
+  maxRetries?: number;
+  retryDelay?: number;
+}
+
+export interface Transport {
+  stream(): AsyncIterable<SSEEvent>;
+  abort(): void;
+}
+
+export function createTransport(opts: TransportOptions): Transport {
+  const {
+    url,
+    method = 'POST',
+    headers = {},
+    body,
+    signal,
+    timeout = 30000,
+    maxRetries = 3,
+    retryDelay = 1000,
+  } = opts;
+
+  let aborted = false;
+
+  return {
+    stream(): AsyncIterable<SSEEvent> {
+      return streamWithRetry();
+    },
+    abort(): void {
+      aborted = true;
+    },
+  };
+
+  async function* streamWithRetry(): AsyncIterable<SSEEvent> {
+    let lastEventId: string | undefined;
+    let retries = 0;
+
+    while (!aborted && retries <= maxRetries) {
+      const requestHeaders: Record<string, string> = { ...headers };
+      if (lastEventId) {
+        requestHeaders['Last-Event-ID'] = lastEventId;
+      }
+
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+        if (signal) {
+          signal.addEventListener('abort', () => controller.abort());
+        }
+
+        const response = await fetch(url, {
+          method,
+          headers: requestHeaders,
+          body,
+          signal: controller.signal,
+        });
+
+        clearTimeout(timeoutId);
+
+        if (!response.ok) {
+          if (response.status >= 400 && response.status < 500) {
+            const errorText = await response.text().catch(() => '');
+            yield { event: 'error', data: `HTTP ${response.status}: ${errorText}` };
+            return;
+          }
+          throw new Error(`HTTP ${response.status}`);
+        }
+
+        if (!response.body) {
+          yield { event: 'error', data: 'No response body' };
+          return;
+        }
+
+        retries = 0;
+
+        for await (const event of parseSSE(response.body)) {
+          if (event.id) lastEventId = event.id;
+          yield event;
+        }
+
+        return;
+      } catch (e) {
+        if (aborted) return;
+
+        const isAbort = e instanceof DOMException && e.name === 'AbortError';
+        if (isAbort && retries >= maxRetries) {
+          yield { event: 'error', data: 'Request timed out' };
+          return;
+        }
+
+        retries++;
+        if (retries > maxRetries) {
+          yield { event: 'error', data: e instanceof Error ? e.message : String(e) };
+          return;
+        }
+
+        const delay = retryDelay * Math.pow(2, retries - 1);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+}

package/src/plugins/cursor/plugin.ts

@@ -1,7 +1,8 @@
-import { Cursor } from '@cursor/sdk';
 import type { BridgePlugin, BridgeSession, ModelInfo } from '../../core/index.js';
 import { CursorBridgeSession } from './session.js';
 
+const CURSOR_API_BASE = 'https://api2.cursor.sh';
+
 export class CursorBridgePlugin implements BridgePlugin {
   name = 'cursor';
   version = '2.0.0';
@@ -10,8 +11,10 @@ export class CursorBridgePlugin implements BridgePlugin {
     const apiKey = config.CURSOR_API_KEY;
     if (!apiKey) return false;
     try {
-      await Cursor.me({ apiKey });
-      return true;
+      const response = await fetch(`${CURSOR_API_BASE}/auth/whoami`, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+      });
+      return response.ok;
     } catch {
       return false;
     }
@@ -20,18 +23,47 @@ export class CursorBridgePlugin implements BridgePlugin {
   async listModels(config: Record<string, string>): Promise<ModelInfo[]> {
     const apiKey = config.CURSOR_API_KEY;
     if (!apiKey) throw new Error('Missing CURSOR_API_KEY');
-    const models = await Cursor.models.list({ apiKey });
-    return models.map((m) => ({
-      id: m.id,
-      name: m.id,
-      capabilities: { streaming: true, tools: true },
-    }));
+
+    try {
+      const response = await fetch(`${CURSOR_API_BASE}/models`, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+      });
+
+      if (!response.ok) {
+        return defaultModels();
+      }
+
+      const data = await response.json();
+      if (Array.isArray(data)) {
+        return data.map((m: { id?: string; name?: string }) => ({
+          id: m.id ?? m.name ?? 'unknown',
+          name: m.name ?? m.id ?? 'unknown',
+          capabilities: { streaming: true, tools: true },
+        }));
+      }
+    } catch {
+      // Fall through to defaults
+    }
+
+    return defaultModels();
   }
 
   async createSession(config: Record<string, string>, model: string): Promise<BridgeSession> {
     const apiKey = config.CURSOR_API_KEY;
     if (!apiKey) throw new Error('Missing CURSOR_API_KEY');
-    const cwd = config.CURSOR_OPENCODE_BRIDGE_CWD ?? process.cwd();
-    return new CursorBridgeSession(apiKey, model, cwd);
+    return new CursorBridgeSession(apiKey, model);
   }
 }
+
+function defaultModels(): ModelInfo[] {
+  return [
+    { id: 'composer-2', name: 'Composer 2', capabilities: { streaming: true, tools: true } },
+    { id: 'composer-2.5', name: 'Composer 2.5', capabilities: { streaming: true, tools: true } },
+    { id: 'gpt-4o', name: 'GPT-4o', capabilities: { streaming: true, tools: true } },
+    {
+      id: 'claude-3.5-sonnet',
+      name: 'Claude 3.5 Sonnet',
+      capabilities: { streaming: true, tools: true },
+    },
+  ];
+}

package/src/plugins/cursor/session.ts

@@ -1,83 +1,103 @@
-import { Agent } from '@cursor/sdk';
-import type { SDKAgent, SendOptions } from '@cursor/sdk';
-import type { BridgeSession, Message, ToolDefinition, StreamChunk } from '../../core/index.js';
-import { translateTools } from './tools.js';
+import type {
+  BridgeSession,
+  Message,
+  ToolDefinition,
+  StreamChunk,
+  SSEEvent,
+} from '../../core/index.js';
+import { createStream } from '../../core/index.js';
+
+const CURSOR_API_BASE = 'https://api2.cursor.sh';
 
 export class CursorBridgeSession implements BridgeSession {
-  private agent: SDKAgent | null = null;
   private apiKey: string;
   private modelId: string;
-  private cwd: string;
 
-  constructor(apiKey: string, modelId: string, cwd: string = process.cwd()) {
+  constructor(apiKey: string, modelId: string) {
     this.apiKey = apiKey;
     this.modelId = modelId;
-    this.cwd = cwd;
   }
 
   async *send(messages: Message[], tools?: ToolDefinition[]): AsyncIterable<StreamChunk> {
-    const prompt = this.buildPrompt(messages);
-    const cursorTools = tools ? translateTools(tools) : undefined;
+    const body = JSON.stringify({
+      model: this.modelId,
+      messages: messages.map((m) => ({
+        role: m.role,
+        content: m.content,
+        ...(m.tool_calls && { tool_calls: m.tool_calls }),
+        ...(m.tool_call_id && { tool_call_id: m.tool_call_id }),
+        ...(m.name && { name: m.name }),
+      })),
+      ...(tools && { tools: tools.map((t) => t) }),
+      stream: true,
+    });
 
-    try {
-      this.agent = await Agent.create({
-        apiKey: this.apiKey,
-        model: { id: this.modelId },
-        local: { cwd: this.cwd, settingSources: [] },
-      });
+    for await (const chunk of createStream({
+      url: `${CURSOR_API_BASE}/aiserver.v1.AiService/StreamChat`,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.apiKey}`,
+        Accept: 'text/event-stream',
+      },
+      body,
+      parseEvent: parseCursorEvent,
+    })) {
+      yield chunk;
+    }
+  }
 
-      const sendOptions: SendOptions = {
-        model: { id: this.modelId },
-        onDelta: ({ update }) => {
-          if (update.type === 'text-delta' && 'text' in update && update.text) {
-            // onDelta is synchronous callback, we buffer and yield in the loop
-          }
-        },
-      };
+  async dispose(): Promise<void> {
+    // No state to dispose with direct HTTP
+  }
+}
 
-      const run = await this.agent.send(prompt, sendOptions);
+function parseCursorEvent(event: SSEEvent): StreamChunk | null {
+  if (event.event === 'error') {
+    return { type: 'error', content: event.data, finishReason: 'error' };
+  }
 
-      const result = await run.wait();
-      if (result.status === 'error' || result.status === 'cancelled') {
-        yield {
-          type: 'error',
-          content: `Agent run ${result.status}: ${result.result ?? 'no details'}`,
-          finishReason: 'error',
-        };
-        return;
-      }
+  if (event.data === '' || event.data === '[DONE]') {
+    return { type: 'done', finishReason: 'stop' };
+  }
 
-      yield { type: 'text', content: result.result ?? '', finishReason: 'stop' };
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      yield { type: 'error', content: msg, finishReason: 'error' };
+  try {
+    const json = JSON.parse(event.data);
+
+    if (json.error) {
+      return {
+        type: 'error',
+        content: json.error.message ?? JSON.stringify(json.error),
+        finishReason: 'error',
+      };
     }
-  }
 
-  async dispose(): Promise<void> {
-    if (this.agent) {
-      try {
-        await this.agent[Symbol.asyncDispose]();
-      } catch {
-        // Ignore dispose errors
+    if (json.choices?.[0]?.delta?.content) {
+      return { type: 'text', content: json.choices[0].delta.content };
+    }
+
+    if (json.choices?.[0]?.delta?.tool_calls) {
+      for (const tc of json.choices[0].delta.tool_calls) {
+        return {
+          type: 'tool_call',
+          toolCall: {
+            id: tc.id ?? `tc-${Date.now()}`,
+            name: tc.function?.name ?? '',
+            arguments: tc.function?.arguments ?? '',
+          },
+        };
       }
-      this.agent = null;
     }
-  }
 
-  private buildPrompt(messages: Message[]): string {
-    const blocks: string[] = [];
-    for (const m of messages) {
-      const text =
-        typeof m.content === 'string'
-          ? m.content
-          : m.content != null
-            ? JSON.stringify(m.content)
-            : '';
-      if (!text) continue;
-      const label = m.role === 'tool' ? `tool (${m.tool_call_id ?? m.name ?? 'result'})` : m.role;
-      blocks.push(`[${label}]\n${text}`);
+    if (json.choices?.[0]?.finish_reason) {
+      return {
+        type: 'done',
+        finishReason: json.choices[0].finish_reason === 'stop' ? 'stop' : 'tool_calls',
+      };
     }
-    return `\nFollow this conversation transcript and reply as the assistant.\n\n${blocks.join('\n\n---\n\n')}\n`;
+  } catch {
+    return null;
   }
+
+  return null;
 }

package/dist/plugins/cursor/tools.d.ts

@@ -1,11 +0,0 @@
-import type { ToolDefinition } from '../../core/index.js';
-export interface CursorTool {
-    type: 'function';
-    function: {
-        name: string;
-        description?: string;
-        parameters: Record<string, unknown>;
-    };
-}
-export declare function translateTools(tools: ToolDefinition[]): CursorTool[];
-export declare function translateToolResult(toolCallId: string, result: string): string;

package/dist/plugins/cursor/tools.js

@@ -1,13 +0,0 @@
-export function translateTools(tools) {
-    return tools.map((tool) => ({
-        type: 'function',
-        function: {
-            name: tool.function.name,
-            description: tool.function.description,
-            parameters: tool.function.parameters,
-        },
-    }));
-}
-export function translateToolResult(toolCallId, result) {
-    return `[tool result for ${toolCallId}]\n${result}`;
-}

package/src/plugins/cursor/tools.ts

@@ -1,25 +0,0 @@
-import type { ToolDefinition } from '../../core/index.js';
-
-export interface CursorTool {
-  type: 'function';
-  function: {
-    name: string;
-    description?: string;
-    parameters: Record<string, unknown>;
-  };
-}
-
-export function translateTools(tools: ToolDefinition[]): CursorTool[] {
-  return tools.map((tool) => ({
-    type: 'function' as const,
-    function: {
-      name: tool.function.name,
-      description: tool.function.description,
-      parameters: tool.function.parameters as Record<string, unknown>,
-    },
-  }));
-}
-
-export function translateToolResult(toolCallId: string, result: string): string {
-  return `[tool result for ${toolCallId}]\n${result}`;
-}