@evanovation/open-cursor 2.4.15

package/src/provider/backend.ts

@@ -0,0 +1,71 @@
+export {
+  isUsableSdkApiKey,
+  normalizeAuthorizationHeader,
+  resolveSdkApiKey,
+  type ResolveSdkApiKeyInput,
+} from "../auth.js";
+import { isUsableSdkApiKey } from "../auth.js";
+
+export type CursorBackendPreference = "auto" | "cursor-agent" | "sdk";
+export type CursorRuntimeBackend = "cursor-agent" | "sdk";
+
+export interface BackendPreferenceParseResult {
+  preference: CursorBackendPreference;
+  valid: boolean;
+}
+
+export interface SelectBackendForRequestInput {
+  preference: CursorBackendPreference;
+  cursorAgentAvailable: boolean;
+  sdkApiKey?: string;
+}
+
+export function parseCursorBackendPreference(
+  value: string | undefined,
+): BackendPreferenceParseResult {
+  if (value === undefined || value.trim() === "") {
+    return { preference: "auto", valid: true };
+  }
+
+  const normalized = value.trim().toLowerCase();
+  if (
+    normalized === "auto" ||
+    normalized === "cursor-agent" ||
+    normalized === "sdk"
+  ) {
+    return { preference: normalized, valid: true };
+  }
+
+  return { preference: "auto", valid: false };
+}
+
+export function selectInitialBackend(
+  preference: CursorBackendPreference,
+): CursorRuntimeBackend {
+  return preference === "sdk" ? "sdk" : "cursor-agent";
+}
+
+export function shouldFallbackToSdk(
+  preference: CursorBackendPreference,
+  sdkApiKey: string | undefined,
+): boolean {
+  return preference === "auto" && isUsableSdkApiKey(sdkApiKey);
+}
+
+export function selectBackendForRequest(
+  input: SelectBackendForRequestInput,
+): CursorRuntimeBackend {
+  if (input.preference === "sdk") {
+    return "sdk";
+  }
+
+  if (
+    input.preference === "auto" &&
+    !input.cursorAgentAvailable &&
+    isUsableSdkApiKey(input.sdkApiKey)
+  ) {
+    return "sdk";
+  }
+
+  return "cursor-agent";
+}

package/src/provider/boundary.ts

@@ -0,0 +1,168 @@
+import type { OpenAiToolCall, ToolLoopMeta, ToolCallExtractionResult } from "../proxy/tool-loop.js";
+import {
+  createToolCallCompletionResponse,
+  createToolCallStreamChunks,
+  extractOpenAiToolCall,
+} from "../proxy/tool-loop.js";
+import type { StreamJsonToolCallEvent } from "../streaming/types.js";
+
+export type ToolLoopMode = "opencode" | "proxy-exec" | "off";
+
+export type ProviderBoundaryMode = "legacy" | "v1";
+
+export type ToolOptionResolution = {
+  tools: unknown;
+  action: "preserve" | "override" | "none";
+};
+
+export interface ToolLoopFlags {
+  proxyExecuteToolCalls: boolean;
+  suppressConverterToolEvents: boolean;
+  shouldEmitToolUpdates: boolean;
+}
+
+export interface ProviderBoundary {
+  readonly mode: ProviderBoundaryMode;
+  readonly providerId: string;
+  resolveChatParamTools(
+    toolLoopMode: ToolLoopMode,
+    existingTools: unknown,
+    refreshedTools: Array<any>,
+  ): ToolOptionResolution;
+  computeToolLoopFlags(
+    toolLoopMode: ToolLoopMode,
+    forwardToolCalls: boolean,
+    emitToolUpdates: boolean,
+  ): ToolLoopFlags;
+  matchesProvider(inputModel: any): boolean;
+  normalizeRuntimeModel(model: unknown): string;
+  resolveRuntimeModel(model: unknown, cursorModel: unknown): string;
+  applyChatParamDefaults(
+    output: any,
+    proxyBaseURL: string | undefined,
+    defaultBaseURL: string,
+    defaultApiKey: string,
+  ): void;
+  maybeExtractToolCall(
+    event: StreamJsonToolCallEvent,
+    allowedToolNames: Set<string>,
+    toolLoopMode: ToolLoopMode,
+  ): ToolCallExtractionResult;
+  createNonStreamToolCallResponse(meta: ToolLoopMeta, toolCall: OpenAiToolCall): any;
+  createStreamToolCallChunks(meta: ToolLoopMeta, toolCall: OpenAiToolCall): Array<any>;
+}
+
+export function parseProviderBoundaryMode(
+  value: string | undefined,
+): { mode: ProviderBoundaryMode; valid: boolean } {
+  const normalized = (value ?? "v1").trim().toLowerCase();
+  if (normalized === "legacy" || normalized === "v1") {
+    return { mode: normalized, valid: true };
+  }
+  return { mode: "v1", valid: false };
+}
+
+export function createProviderBoundary(
+  mode: ProviderBoundaryMode,
+  providerId: string,
+): ProviderBoundary {
+  const shared = createSharedBoundary(providerId);
+  if (mode === "v1") {
+    return { ...shared, mode: "v1" };
+  }
+  return { ...shared, mode: "legacy" };
+}
+
+function createSharedBoundary(
+  providerId: string,
+): Omit<ProviderBoundary, "mode"> {
+  return {
+    providerId,
+
+    resolveChatParamTools(toolLoopMode, existingTools, refreshedTools) {
+      if (toolLoopMode === "proxy-exec") {
+        if (refreshedTools.length > 0) {
+          return { tools: refreshedTools, action: "override" };
+        }
+        return { tools: existingTools, action: "none" };
+      }
+
+      if (toolLoopMode === "opencode") {
+        if (existingTools != null) {
+          return { tools: existingTools, action: "preserve" };
+        }
+        return { tools: existingTools, action: "none" };
+      }
+
+      return { tools: existingTools, action: "none" };
+    },
+
+    computeToolLoopFlags(toolLoopMode, forwardToolCalls, emitToolUpdates) {
+      const proxyExec = toolLoopMode === "proxy-exec";
+      return {
+        proxyExecuteToolCalls: proxyExec && forwardToolCalls,
+        suppressConverterToolEvents: proxyExec && !forwardToolCalls,
+        shouldEmitToolUpdates: proxyExec && emitToolUpdates,
+      };
+    },
+
+    matchesProvider(inputModel: any) {
+      if (!inputModel || typeof inputModel !== "object") {
+        return false;
+      }
+
+      const modelProviderId =
+        (typeof inputModel.providerID === "string" && inputModel.providerID)
+        || (typeof inputModel.providerId === "string" && inputModel.providerId)
+        || (typeof inputModel.provider === "string" && inputModel.provider)
+        || "";
+
+      return modelProviderId === providerId;
+    },
+
+    normalizeRuntimeModel(model) {
+      const raw = typeof model === "string" ? model.trim() : "";
+      if (raw.length === 0) {
+        return "auto";
+      }
+
+      const prefix = `${providerId}/`;
+      if (raw.startsWith(prefix)) {
+        const stripped = raw.slice(prefix.length).trim();
+        return stripped.length > 0 ? stripped : "auto";
+      }
+
+      return raw;
+    },
+
+    resolveRuntimeModel(model, cursorModel) {
+      const rawCursorModel = typeof cursorModel === "string" ? cursorModel.trim() : "";
+      if (rawCursorModel.length > 0) {
+        return this.normalizeRuntimeModel(rawCursorModel);
+      }
+
+      return this.normalizeRuntimeModel(model);
+    },
+
+    applyChatParamDefaults(output, proxyBaseURL, defaultBaseURL, defaultApiKey) {
+      output.options = output.options || {};
+      output.options.baseURL = proxyBaseURL || defaultBaseURL;
+      output.options.apiKey = output.options.apiKey || defaultApiKey;
+    },
+
+    maybeExtractToolCall(event, allowedToolNames, toolLoopMode) {
+      if (toolLoopMode !== "opencode") {
+        return { action: "skip" as const, skipReason: "tool_loop_mode_not_opencode" };
+      }
+      return extractOpenAiToolCall(event, allowedToolNames);
+    },
+
+    createNonStreamToolCallResponse(meta, toolCall) {
+      return createToolCallCompletionResponse(meta, toolCall);
+    },
+
+    createStreamToolCallChunks(meta, toolCall) {
+      return createToolCallStreamChunks(meta, toolCall);
+    },
+  };
+}

package/src/provider/passthrough-tracker.ts

@@ -0,0 +1,38 @@
+/**
+ * PassThroughTracker - Tracks MCP tools passed through to cursor-agent
+ *
+ * Used to collect tool names for end-of-response toast notifications
+ * when cursor-agent MCP tools (like Playwright) are invoked.
+ */
+
+export interface PassThroughSummary {
+  tools: string[];
+  errors: string[];
+  hasActivity: boolean;
+}
+
+export class PassThroughTracker {
+  private tools: Set<string> = new Set();
+  private errors: string[] = [];
+
+  trackTool(name: string): void {
+    this.tools.add(name);
+  }
+
+  trackError(toolName: string, message: string): void {
+    this.errors.push(`${toolName}: ${message}`);
+  }
+
+  getSummary(): PassThroughSummary {
+    return {
+      tools: Array.from(this.tools),
+      errors: [...this.errors],
+      hasActivity: this.tools.size > 0,
+    };
+  }
+
+  reset(): void {
+    this.tools.clear();
+    this.errors.length = 0;
+  }
+}