@oh-my-pi/pi-ai 4.2.2 → 4.3.0

package/src/stream.ts

@@ -3,6 +3,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { supportsXhigh } from "./models";
 import { type AnthropicOptions, streamAnthropic } from "./providers/anthropic";
+import { type CursorOptions, streamCursor } from "./providers/cursor";
 import { type GoogleOptions, streamGoogle } from "./providers/google";
 import {
 	type GoogleGeminiCliOptions,
@@ -82,6 +83,7 @@ export function getEnvApiKey(provider: any): string | undefined {
 		zai: "ZAI_API_KEY",
 		mistral: "MISTRAL_API_KEY",
 		opencode: "OPENCODE_API_KEY",
+		cursor: "CURSOR_ACCESS_TOKEN",
 	};
 
 	const envVar = envMap[provider];
@@ -128,6 +130,9 @@ export function stream<TApi extends Api>(
 				providerOptions as GoogleGeminiCliOptions,
 			);
 
+		case "cursor-agent":
+			return streamCursor(model as Model<"cursor-agent">, context, providerOptions as CursorOptions);
+
 		default: {
 			// This should never be reached if all Api cases are handled
 			const _exhaustive: never = api;
@@ -185,6 +190,7 @@ function mapOptionsForApi<TApi extends Api>(
 		signal: options?.signal,
 		apiKey: apiKey || options?.apiKey,
 		sessionId: options?.sessionId,
+		execHandlers: options?.execHandlers,
 	};
 
 	// Helper to clamp xhigh to high for providers that don't support it
@@ -353,6 +359,16 @@ function mapOptionsForApi<TApi extends Api>(
 			} satisfies GoogleVertexOptions;
 		}
 
+		case "cursor-agent": {
+			const execHandlers = options?.cursorExecHandlers ?? options?.execHandlers;
+			const onToolResult = options?.cursorOnToolResult ?? execHandlers?.onToolResult;
+			return {
+				...base,
+				execHandlers,
+				onToolResult,
+			} satisfies CursorOptions;
+		}
+
 		default: {
 			// Exhaustiveness check
 			const _exhaustive: never = model.api;

package/src/types.ts

@@ -1,4 +1,22 @@
 import type { AnthropicOptions } from "./providers/anthropic";
+import type { CursorOptions } from "./providers/cursor";
+import type {
+	DeleteArgs,
+	DeleteResult,
+	DiagnosticsArgs,
+	DiagnosticsResult,
+	GrepArgs,
+	GrepResult,
+	LsArgs,
+	LsResult,
+	McpResult,
+	ReadArgs,
+	ReadResult,
+	ShellArgs,
+	ShellResult,
+	WriteArgs,
+	WriteResult,
+} from "./providers/cursor/gen/agent_pb";
 import type { GoogleOptions } from "./providers/google";
 import type { GoogleGeminiCliOptions } from "./providers/google-gemini-cli";
 import type { GoogleVertexOptions } from "./providers/google-vertex";
@@ -16,7 +34,8 @@ export type Api =
 	| "anthropic-messages"
 	| "google-generative-ai"
 	| "google-gemini-cli"
-	| "google-vertex";
+	| "google-vertex"
+	| "cursor-agent";
 
 export interface ApiOptionsMap {
 	"anthropic-messages": AnthropicOptions;
@@ -26,6 +45,7 @@ export interface ApiOptionsMap {
 	"google-generative-ai": GoogleOptions;
 	"google-gemini-cli": GoogleGeminiCliOptions;
 	"google-vertex": GoogleVertexOptions;
+	"cursor-agent": CursorOptions;
 }
 
 // Compile-time exhaustiveness check - this will fail if ApiOptionsMap doesn't have all KnownApi keys
@@ -49,6 +69,7 @@ export type KnownProvider =
 	| "openai"
 	| "openai-codex"
 	| "github-copilot"
+	| "cursor"
 	| "xai"
 	| "groq"
 	| "cerebras"
@@ -80,6 +101,8 @@ export interface StreamOptions {
 	 * session-aware features. Ignored by providers that don't support it.
 	 */
 	sessionId?: string;
+	/** Cursor exec/MCP tool handlers (cursor-agent only). */
+	execHandlers?: CursorExecHandlers;
 }
 
 // Unified options with reasoning passed to streamSimple() and completeSimple()
@@ -87,6 +110,10 @@ export interface SimpleStreamOptions extends StreamOptions {
 	reasoning?: ThinkingLevel;
 	/** Custom token budgets for thinking levels (token-based providers only) */
 	thinkingBudgets?: ThinkingBudgets;
+	/** Cursor exec handlers for local tool execution */
+	cursorExecHandlers?: CursorExecHandlers;
+	/** Hook to handle tool results from Cursor exec */
+	cursorOnToolResult?: CursorToolResultHandler;
 }
 
 // Generic StreamFunction with typed options
@@ -169,6 +196,33 @@ export interface ToolResultMessage<TDetails = any> {
 
 export type Message = UserMessage | AssistantMessage | ToolResultMessage;
 
+export type CursorExecHandlerResult<T> = { result: T; toolResult?: ToolResultMessage } | T | ToolResultMessage;
+
+export type CursorToolResultHandler = (
+	result: ToolResultMessage,
+) => ToolResultMessage | undefined | Promise<ToolResultMessage | undefined>;
+
+export interface CursorMcpCall {
+	name: string;
+	providerIdentifier: string;
+	toolName: string;
+	toolCallId: string;
+	args: Record<string, unknown>;
+	rawArgs: Record<string, Uint8Array>;
+}
+
+export interface CursorExecHandlers {
+	read?: (args: ReadArgs) => Promise<CursorExecHandlerResult<ReadResult>>;
+	ls?: (args: LsArgs) => Promise<CursorExecHandlerResult<LsResult>>;
+	grep?: (args: GrepArgs) => Promise<CursorExecHandlerResult<GrepResult>>;
+	write?: (args: WriteArgs) => Promise<CursorExecHandlerResult<WriteResult>>;
+	delete?: (args: DeleteArgs) => Promise<CursorExecHandlerResult<DeleteResult>>;
+	shell?: (args: ShellArgs) => Promise<CursorExecHandlerResult<ShellResult>>;
+	diagnostics?: (args: DiagnosticsArgs) => Promise<CursorExecHandlerResult<DiagnosticsResult>>;
+	mcp?: (call: CursorMcpCall) => Promise<CursorExecHandlerResult<McpResult>>;
+	onToolResult?: CursorToolResultHandler;
+}
+
 import type { TSchema } from "@sinclair/typebox";
 
 export interface Tool<TParameters extends TSchema = TSchema> {

package/src/utils/oauth/cursor.ts

@@ -0,0 +1,157 @@
+import { generatePKCE } from "./pkce";
+import type { OAuthCredentials } from "./types";
+
+const CURSOR_LOGIN_URL = "https://cursor.com/loginDeepControl";
+const CURSOR_POLL_URL = "https://api2.cursor.sh/auth/poll";
+const CURSOR_REFRESH_URL = "https://api2.cursor.sh/auth/exchange_user_api_key";
+
+const POLL_MAX_ATTEMPTS = 150;
+const POLL_BASE_DELAY = 1000;
+const POLL_MAX_DELAY = 10000;
+const POLL_BACKOFF_MULTIPLIER = 1.2;
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export interface CursorAuthParams {
+	verifier: string;
+	challenge: string;
+	uuid: string;
+	loginUrl: string;
+}
+
+export async function generateCursorAuthParams(): Promise<CursorAuthParams> {
+	const { verifier, challenge } = await generatePKCE();
+	const uuid = crypto.randomUUID();
+
+	const params = new URLSearchParams({
+		challenge,
+		uuid,
+		mode: "login",
+		redirectTarget: "cli",
+	});
+
+	const loginUrl = `${CURSOR_LOGIN_URL}?${params.toString()}`;
+
+	return { verifier, challenge, uuid, loginUrl };
+}
+
+export async function pollCursorAuth(
+	uuid: string,
+	verifier: string,
+): Promise<{ accessToken: string; refreshToken: string }> {
+	let delay = POLL_BASE_DELAY;
+	let consecutiveErrors = 0;
+
+	for (let attempt = 0; attempt < POLL_MAX_ATTEMPTS; attempt++) {
+		await sleep(delay);
+
+		try {
+			const response = await fetch(`${CURSOR_POLL_URL}?uuid=${uuid}&verifier=${verifier}`);
+
+			if (response.status === 404) {
+				consecutiveErrors = 0;
+				delay = Math.min(delay * POLL_BACKOFF_MULTIPLIER, POLL_MAX_DELAY);
+				continue;
+			}
+
+			if (response.ok) {
+				const data = (await response.json()) as {
+					accessToken: string;
+					refreshToken: string;
+				};
+				return {
+					accessToken: data.accessToken,
+					refreshToken: data.refreshToken,
+				};
+			}
+
+			throw new Error(`Poll failed: ${response.status}`);
+		} catch (_error) {
+			consecutiveErrors++;
+			if (consecutiveErrors >= 3) {
+				throw new Error("Too many consecutive errors during Cursor auth polling");
+			}
+		}
+	}
+
+	throw new Error("Cursor authentication polling timeout");
+}
+
+export async function loginCursor(
+	onAuthUrl: (url: string) => void,
+	onPollStart?: () => void,
+): Promise<OAuthCredentials> {
+	const { verifier, uuid, loginUrl } = await generateCursorAuthParams();
+
+	onAuthUrl(loginUrl);
+	onPollStart?.();
+
+	const { accessToken, refreshToken } = await pollCursorAuth(uuid, verifier);
+
+	const expiresAt = getTokenExpiry(accessToken);
+
+	return {
+		access: accessToken,
+		refresh: refreshToken,
+		expires: expiresAt,
+	};
+}
+
+export async function refreshCursorToken(apiKeyOrRefreshToken: string): Promise<OAuthCredentials> {
+	const response = await fetch(CURSOR_REFRESH_URL, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${apiKeyOrRefreshToken}`,
+			"Content-Type": "application/json",
+		},
+		body: "{}",
+	});
+
+	if (!response.ok) {
+		const error = await response.text();
+		throw new Error(`Cursor token refresh failed: ${error}`);
+	}
+
+	const data = (await response.json()) as {
+		accessToken: string;
+		refreshToken: string;
+	};
+
+	const expiresAt = getTokenExpiry(data.accessToken);
+
+	return {
+		access: data.accessToken,
+		refresh: data.refreshToken || apiKeyOrRefreshToken,
+		expires: expiresAt,
+	};
+}
+
+function getTokenExpiry(token: string): number {
+	try {
+		const [, payload] = token.split(".");
+		if (!payload) {
+			return Date.now() + 3600 * 1000;
+		}
+		const decoded = JSON.parse(atob(payload.replace(/-/g, "+").replace(/_/g, "/")));
+		if (decoded.exp) {
+			return decoded.exp * 1000 - 5 * 60 * 1000;
+		}
+	} catch {
+		// Ignore parsing errors
+	}
+	return Date.now() + 3600 * 1000;
+}
+
+export function isTokenExpiringSoon(token: string, thresholdSeconds = 300): boolean {
+	try {
+		const [, payload] = token.split(".");
+		if (!payload) return true;
+		const decoded = JSON.parse(atob(payload.replace(/-/g, "+").replace(/_/g, "/")));
+		const currentTime = Math.floor(Date.now() / 1000);
+		return decoded.exp - currentTime < thresholdSeconds;
+	} catch {
+		return true;
+	}
+}

package/src/utils/oauth/index.ts

@@ -11,6 +11,14 @@
 
 // Anthropic
 export { loginAnthropic, refreshAnthropicToken } from "./anthropic";
+// Cursor
+export {
+	generateCursorAuthParams,
+	isTokenExpiringSoon as isCursorTokenExpiringSoon,
+	loginCursor,
+	pollCursorAuth,
+	refreshCursorToken,
+} from "./cursor";
 // GitHub Copilot
 export {
 	getGitHubCopilotBaseUrl,
@@ -41,6 +49,7 @@ export * from "./types";
 // ============================================================================
 
 import { refreshAnthropicToken } from "./anthropic";
+import { refreshCursorToken } from "./cursor";
 import { refreshGitHubCopilotToken } from "./github-copilot";
 import { refreshAntigravityToken } from "./google-antigravity";
 import { refreshGoogleCloudToken } from "./google-gemini-cli";
@@ -83,6 +92,9 @@ export async function refreshOAuthToken(
 		case "openai-codex":
 			newCredentials = await refreshOpenAICodexToken(credentials.refresh);
 			break;
+		case "cursor":
+			newCredentials = await refreshCursorToken(credentials.refresh);
+			break;
 		default:
 			throw new Error(`Unknown OAuth provider: ${provider}`);
 	}
@@ -153,5 +165,10 @@ export function getOAuthProviders(): OAuthProviderInfo[] {
 			name: "Antigravity (Gemini 3, Claude, GPT-OSS)",
 			available: true,
 		},
+		{
+			id: "cursor",
+			name: "Cursor (Claude, GPT, etc.)",
+			available: true,
+		},
 	];
 }

package/src/utils/oauth/types.ts

@@ -13,7 +13,8 @@ export type OAuthProvider =
 	| "github-copilot"
 	| "google-gemini-cli"
 	| "google-antigravity"
-	| "openai-codex";
+	| "openai-codex"
+	| "cursor";
 
 export type OAuthPrompt = {
 	message: string;