cursor-openai-byok 1.0.2

package/lib/daemon-entry.js

@@ -0,0 +1,1128 @@
+#!/usr/bin/env node
+"use strict";
+
+const __bundlePath = require("path");
+const __bundleRoot = __bundlePath.resolve(__dirname, "..");
+const __bundleModules = {
+"src/daemon-entry.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const { startServer } = require("./daemon/server");
+const { pidPath } = require("./paths");
+const fs = require("fs");
+
+fs.writeFileSync(pidPath(), String(process.pid));
+const server = startServer();
+
+function shutdown() {
+  try { fs.unlinkSync(pidPath()); } catch {}
+  server.close(() => process.exit(0));
+  setTimeout(() => process.exit(0), 1000).unref();
+}
+
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
+process.on("exit", () => {
+  try { fs.unlinkSync(pidPath()); } catch {}
+});
+
+},
+"src/daemon/server.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const http = require("http");
+const { loadConfig, listModels, resolveModel } = require("../config");
+const { log } = require("../logger");
+const { DEFAULT_PORT } = require("../paths");
+const { cursorPayloadToOpenAI } = require("../cursor-agent-adapter/messages");
+const {
+  proxyOpenAIRequest,
+  streamProviderEvents,
+  callProviderOnce,
+} = require("../provider-adapters/openai-compatible");
+
+function readJson(req, limit = 30 * 1024 * 1024) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.setEncoding("utf8");
+    req.on("data", (chunk) => {
+      body += chunk;
+      if (body.length > limit) {
+        reject(new Error("request too large"));
+        req.destroy();
+      }
+    });
+    req.on("end", () => {
+      try {
+        resolve(body ? JSON.parse(body) : {});
+      } catch (err) {
+        reject(err);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+function sendJson(res, status, body) {
+  res.writeHead(status, corsHeaders({ "content-type": "application/json; charset=utf-8" }));
+  res.end(JSON.stringify(body));
+}
+
+function corsHeaders(extra = {}) {
+  return {
+    "access-control-allow-origin": "*",
+    "access-control-allow-methods": "GET,POST,OPTIONS",
+    "access-control-allow-headers": "content-type,authorization,openai-beta",
+    ...extra,
+  };
+}
+
+async function pipeProviderResponse(res, providerResponse) {
+  const headers = {
+    "content-type": providerResponse.headers.get("content-type") || "application/json; charset=utf-8",
+  };
+  res.writeHead(providerResponse.status, corsHeaders(headers));
+  if (!providerResponse.body) {
+    res.end(await providerResponse.text());
+    return;
+  }
+  for await (const chunk of providerResponse.body) res.write(chunk);
+  res.end();
+}
+
+async function sendNdjson(res, iterator) {
+  res.writeHead(200, corsHeaders({ "content-type": "application/x-ndjson; charset=utf-8" }));
+  try {
+    for await (const event of iterator) {
+      res.write(JSON.stringify(event) + "\n");
+    }
+  } catch (err) {
+    const message = err && err.message ? err.message : String(err);
+    log("stream-error", { error: err && err.stack ? err.stack : message });
+    res.write(JSON.stringify({ type: "error", error: message }) + "\n");
+  }
+  res.write(JSON.stringify({ type: "done" }) + "\n");
+  res.end();
+}
+
+async function* runCursorAgentLoop(config, payload) {
+  const requestedModel = payload.model || payload.modelName || payload?.runRequest?.requestedModel?.modelId;
+  const route = resolveModel(config, requestedModel);
+  const openaiBody = cursorPayloadToOpenAI(payload, route);
+  log("cursor-run", {
+    model: route.model.displayName,
+    provider: route.provider.id,
+    conversationId: payload.conversationId,
+    generationUUID: payload.generationUUID,
+  });
+
+  if (route.model.supportsStreaming === false) {
+    const text = await callProviderOnce(config, route, openaiBody);
+    if (text) yield { type: "text_delta", text };
+    return;
+  }
+
+  const pendingTools = new Map();
+  for await (const event of streamProviderEvents(config, route, openaiBody)) {
+    if (event.type === "tool_call_delta") {
+      const key = event.id || String(event.index || pendingTools.size);
+      const existing = pendingTools.get(key) || { id: key, name: event.name, arguments: "" };
+      existing.name = event.name || existing.name;
+      existing.arguments += event.argumentsDelta || "";
+      pendingTools.set(key, existing);
+      yield event;
+      continue;
+    }
+    if (event.type === "tool_call") {
+      pendingTools.set(event.id, event);
+      yield event;
+      continue;
+    }
+    if (event.type === "finish" && pendingTools.size > 0) {
+      yield { type: "tool_calls_ready", toolCalls: [...pendingTools.values()] };
+      pendingTools.clear();
+      return;
+    }
+    yield event;
+  }
+}
+
+function createServer() {
+  return http.createServer(async (req, res) => {
+    try {
+      if (req.method === "OPTIONS") return sendJson(res, 204, {});
+      const config = loadConfig();
+      const url = new URL(req.url, "http://127.0.0.1");
+
+      if (req.method === "GET" && url.pathname === "/health") {
+        return sendJson(res, 200, {
+          ok: true,
+          app: "cursor-openai-byok",
+          models: listModels(config).map((m) => m.displayName),
+        });
+      }
+
+      if (req.method === "GET" && url.pathname === "/cursor/v1/models") {
+        return sendJson(res, 200, { ok: true, models: listModels(config) });
+      }
+
+      if (req.method === "GET" && url.pathname === "/cursor/v1/should-handle") {
+        const model = url.searchParams.get("model");
+        try {
+          const route = resolveModel(config, model);
+          return sendJson(res, 200, { ok: true, handle: true, model: route.model });
+        } catch {
+          return sendJson(res, 200, { ok: true, handle: false });
+        }
+      }
+
+      if (req.method === "POST" && url.pathname === "/cursor/v1/run-agent-loop") {
+        const payload = await readJson(req);
+        return sendNdjson(res, runCursorAgentLoop(config, payload));
+      }
+
+      if (req.method === "POST" && url.pathname === "/cursor/v1/tool-result") {
+        const payload = await readJson(req);
+        log("tool-result", {
+          conversationId: payload.conversationId,
+          callId: payload.callId,
+          ok: payload.ok !== false,
+        });
+        return sendJson(res, 200, { ok: true });
+      }
+
+      if (req.method === "POST" && url.pathname === "/v1/responses") {
+        const body = await readJson(req);
+        return pipeProviderResponse(res, await proxyOpenAIRequest(config, "responses", body, req.headers));
+      }
+
+      if (req.method === "POST" && url.pathname === "/v1/chat/completions") {
+        const body = await readJson(req);
+        return pipeProviderResponse(res, await proxyOpenAIRequest(config, "chat", body, req.headers));
+      }
+
+      sendJson(res, 404, { ok: false, error: "not found" });
+    } catch (err) {
+      log("error", { url: req.url, error: err && err.stack ? err.stack : String(err) });
+      sendJson(res, 500, { ok: false, error: err && err.message ? err.message : String(err) });
+    }
+  });
+}
+
+function startServer(options = {}) {
+  const config = loadConfig();
+  const host = options.host || config.server?.host || "127.0.0.1";
+  const port = Number(options.port || config.server?.port || DEFAULT_PORT);
+  const server = createServer();
+  server.listen(port, host, () => {
+    log("listening", { host, port });
+    console.log(`cursor-openai-byok listening on http://${host}:${port}`);
+  });
+  return server;
+}
+
+module.exports = { createServer, startServer, runCursorAgentLoop, readJson };
+
+},
+"src/config.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { configDir, configPath, DEFAULT_PORT } = require("./paths");
+
+const DEFAULT_CONFIG = {
+  $schemaVersion: 1,
+  server: {
+    host: "127.0.0.1",
+    port: DEFAULT_PORT,
+  },
+  defaults: {
+    model: "fastskills-gpt-5.5",
+  },
+  providers: [
+    {
+      id: "fastskills",
+      name: "FastSkills",
+      type: "openai-responses",
+      baseUrl: "https://api-hw.fastskills.ai/v1",
+      apiKey: "sk-REPLACE_ME",
+      models: [
+        {
+          displayName: "fastskills-gpt-5.5",
+          apiModel: "gpt-5.5",
+        supportsTools: true,
+        supportsStreaming: true,
+        supportsImages: true,
+        contextTokenLimit: 258000,
+        maxOutputTokens: 32000,
+        },
+      ],
+    },
+  ],
+};
+
+function ensureConfigDir() {
+  fs.mkdirSync(configDir(), { recursive: true });
+}
+
+function writeDefaultConfig(target = configPath()) {
+  ensureConfigDir();
+  if (!fs.existsSync(target)) {
+    fs.writeFileSync(target, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n", { mode: 0o600 });
+  }
+  return target;
+}
+
+function readJsonFile(file) {
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+function loadConfig(file = configPath()) {
+  if (!fs.existsSync(file)) writeDefaultConfig(file);
+  const config = readJsonFile(file);
+  validateConfig(config, file);
+  return config;
+}
+
+function validateConfig(config, file = configPath()) {
+  if (!config || typeof config !== "object") throw new Error(`${file}: config must be an object`);
+  if (!Array.isArray(config.providers) || config.providers.length === 0) {
+    throw new Error(`${file}: providers must be a non-empty array`);
+  }
+  const modelNames = new Set();
+  for (const provider of config.providers) {
+    if (!provider.id || typeof provider.id !== "string") throw new Error(`${file}: provider.id is required`);
+    if (!["openai-responses", "openai-chat-completions"].includes(provider.type)) {
+      throw new Error(`${file}: provider ${provider.id} type must be openai-responses or openai-chat-completions`);
+    }
+    if (!provider.baseUrl || typeof provider.baseUrl !== "string") {
+      throw new Error(`${file}: provider ${provider.id} baseUrl is required`);
+    }
+    const key = resolveApiKey(provider, false);
+    if (!key || key === "sk-REPLACE_ME") {
+      throw new Error(`${file}: provider ${provider.id} apiKey or apiKeyEnv must be configured`);
+    }
+    if (!Array.isArray(provider.models) || provider.models.length === 0) {
+      throw new Error(`${file}: provider ${provider.id} models must be a non-empty array`);
+    }
+    for (const model of provider.models) {
+      if (!model.displayName || typeof model.displayName !== "string") {
+        throw new Error(`${file}: provider ${provider.id} model.displayName is required`);
+      }
+      if (modelNames.has(model.displayName)) {
+        throw new Error(`${file}: duplicate model displayName ${model.displayName}`);
+      }
+      modelNames.add(model.displayName);
+      if (model.apiModel !== undefined && typeof model.apiModel !== "string") {
+        throw new Error(`${file}: model ${model.displayName} apiModel must be a string`);
+      }
+    }
+  }
+}
+
+function resolveApiKey(provider, throwOnMissing = true) {
+  const key = provider.apiKeyEnv ? process.env[provider.apiKeyEnv] : provider.apiKey;
+  if ((!key || key === "sk-REPLACE_ME") && throwOnMissing) {
+    throw new Error(`Missing API key for provider ${provider.id}`);
+  }
+  return key;
+}
+
+function listModels(config) {
+  const models = [];
+  for (const provider of config.providers || []) {
+    for (const model of provider.models || []) {
+      models.push({
+        providerId: provider.id,
+        providerName: provider.name || provider.id,
+        providerType: provider.type,
+        displayName: model.displayName,
+        apiModel: model.apiModel || model.displayName,
+        supportsTools: model.supportsTools !== false,
+        supportsStreaming: model.supportsStreaming !== false,
+        supportsImages: model.supportsImages !== false,
+        contextTokenLimit: model.contextTokenLimit || 128000,
+        maxOutputTokens: model.maxOutputTokens || 8192,
+      });
+    }
+  }
+  return models;
+}
+
+function resolveModel(config, requestedModel) {
+  const models = listModels(config);
+  const fallback = config.defaults && config.defaults.model;
+  const target = requestedModel || fallback || (models[0] && models[0].displayName);
+  const found = models.find((m) => m.displayName === target || m.apiModel === target);
+  if (!found) {
+    throw new Error(`Model ${target || "<empty>"} is not configured`);
+  }
+  const provider = config.providers.find((p) => p.id === found.providerId);
+  return { provider, model: found };
+}
+
+function maskSecret(value) {
+  if (!value || typeof value !== "string") return value;
+  if (value.length <= 8) return "***";
+  return `${value.slice(0, 3)}***${value.slice(-4)}`;
+}
+
+function redactConfig(config) {
+  return {
+    ...config,
+    providers: (config.providers || []).map((provider) => ({
+      ...provider,
+      apiKey: provider.apiKey ? maskSecret(provider.apiKey) : undefined,
+    })),
+  };
+}
+
+function bundledTemplatePath() {
+  return path.resolve(__dirname, "..", "config.example.json");
+}
+
+module.exports = {
+  DEFAULT_CONFIG,
+  ensureConfigDir,
+  writeDefaultConfig,
+  loadConfig,
+  validateConfig,
+  resolveApiKey,
+  resolveModel,
+  listModels,
+  redactConfig,
+  bundledTemplatePath,
+};
+
+},
+"src/paths.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const os = require("os");
+const path = require("path");
+const fs = require("fs");
+
+const APP_NAME = "cursor-openai-byok";
+const DEFAULT_PORT = 39832;
+
+function homeDir() {
+  return os.homedir();
+}
+
+function configDir() {
+  return path.join(homeDir(), `.${APP_NAME}`);
+}
+
+function configPath() {
+  return path.join(configDir(), "config.json");
+}
+
+function logPath() {
+  return path.join(configDir(), "daemon.log");
+}
+
+function pidPath() {
+  return path.join(configDir(), "daemon.pid");
+}
+
+function runtimePath(name) {
+  return path.join(configDir(), name);
+}
+
+function platformName() {
+  if (process.platform === "darwin") return "macos";
+  if (process.platform === "win32") return "windows";
+  return process.platform;
+}
+
+function cursorExtensionsDir() {
+  return path.join(homeDir(), ".cursor", "extensions");
+}
+
+function installedExtensionDir() {
+  const version = require("../package.json").version;
+  return path.join(cursorExtensionsDir(), `cursor-openai-byok.cursor-openai-byok-${version}`);
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+module.exports = {
+  APP_NAME,
+  DEFAULT_PORT,
+  homeDir,
+  configDir,
+  configPath,
+  logPath,
+  pidPath,
+  runtimePath,
+  platformName,
+  cursorExtensionsDir,
+  installedExtensionDir,
+  ensureDir,
+};
+
+},
+"package.json": function(module, exports, require, __filename, __dirname) {
+module.exports = {
+  "name": "cursor-openai-byok",
+  "version": "1.0.2",
+  "description": "Local BYOK bridge for Cursor using OpenAI-compatible providers.",
+  "displayName": "Cursor OpenAI BYOK",
+  "publisher": "cursor-openai-byok",
+  "type": "commonjs",
+  "main": "./lib/extension.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://git.3weijia.com/base/ai/cursor-openai-byok.git"
+  },
+  "keywords": [
+    "cursor",
+    "byok",
+    "openai",
+    "openai-compatible",
+    "local-bridge"
+  ],
+  "files": [
+    "bin/",
+    "lib/",
+    "scripts/install.sh",
+    "scripts/uninstall.sh",
+    "scripts/install.ps1",
+    "scripts/uninstall.ps1",
+    "config.example.json",
+    "README.md",
+    "TROUBLESHOOTING.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "activationEvents": [
+    "*"
+  ],
+  "contributes": {
+    "commands": [
+      {
+        "command": "cursorOpenaiByok.openSettings",
+        "title": "Cursor OpenAI BYOK: Open Settings"
+      },
+      {
+        "command": "cursorOpenaiByok.startServer",
+        "title": "Cursor OpenAI BYOK: Start Server"
+      },
+      {
+        "command": "cursorOpenaiByok.stopServer",
+        "title": "Cursor OpenAI BYOK: Stop Server"
+      },
+      {
+        "command": "cursorOpenaiByok.restartServer",
+        "title": "Cursor OpenAI BYOK: Restart Server"
+      },
+      {
+        "command": "cursorOpenaiByok.showStatus",
+        "title": "Cursor OpenAI BYOK: Show Status"
+      }
+    ]
+  },
+  "bin": {
+    "cursor-openai-byok": "bin/cursor-openai-byok.js"
+  },
+  "scripts": {
+    "build:npm": "node scripts/build-npm.js",
+    "test": "node --test",
+    "doctor": "node bin/cursor-openai-byok.js doctor",
+    "prepack": "npm run build:npm",
+    "package": "npm run build:npm && node scripts/package.js"
+  },
+  "engines": {
+    "vscode": "^1.99.0",
+    "node": ">=20"
+  },
+  "license": "UNLICENSED"
+};
+},
+"src/logger.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const fs = require("fs");
+const { ensureConfigDir } = require("./config");
+const { logPath } = require("./paths");
+
+function redactText(text) {
+  return String(text)
+    .replace(/sk-[A-Za-z0-9_-]{8,}/g, "sk-***")
+    .replace(/Bearer\s+[A-Za-z0-9._-]{8,}/gi, "Bearer ***");
+}
+
+function log(event, meta) {
+  ensureConfigDir();
+  const suffix = meta === undefined ? "" : " " + redactText(JSON.stringify(meta));
+  fs.appendFileSync(logPath(), `[${new Date().toISOString()}] ${event}${suffix}\n`);
+}
+
+function tailLog(lines = 120) {
+  if (!fs.existsSync(logPath())) return "";
+  const data = fs.readFileSync(logPath(), "utf8");
+  return data.split(/\r?\n/).slice(-lines).join("\n");
+}
+
+module.exports = { log, tailLog, redactText };
+
+},
+"src/cursor-agent-adapter/messages.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const IMAGE_EXTENSIONS = new Set([".png", ".jpg", ".jpeg", ".webp", ".gif"]);
+const IMAGE_MIME_BY_EXT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+};
+const MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+
+function looksLikeNoise(key, value) {
+  const k = String(key || "").toLowerCase();
+  if (k.includes("id") || k.includes("uuid") || k.includes("path") || k.includes("url")) return true;
+  if (k.includes("model") || k.includes("token") || k.includes("hash")) return true;
+  if (/^[a-z0-9_-]{24,}$/i.test(value) && !value.includes(" ")) return true;
+  return value.length > 120000;
+}
+
+function collectStrings(value, out = [], pathParts = []) {
+  if (value == null) return out;
+  if (typeof value === "string") {
+    const key = pathParts[pathParts.length - 1] || "";
+    const text = value.trim();
+    if (text && !looksLikeNoise(key, text)) {
+      const lower = String(key).toLowerCase();
+      let score = 1;
+      if (["text", "content", "prompt", "userMessage", "message", "instruction", "instructions", "query"].includes(key)) score += 20;
+      if (lower.includes("text") || lower.includes("content") || lower.includes("prompt") || lower.includes("message")) score += 10;
+      if (/[\u4e00-\u9fff]/.test(text)) score += 2;
+      out.push({ text, score, path: pathParts.join(".") });
+    }
+    return out;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, i) => collectStrings(item, out, pathParts.concat(String(i))));
+    return out;
+  }
+  if (typeof value === "object") {
+    for (const [key, child] of Object.entries(value)) collectStrings(child, out, pathParts.concat(key));
+  }
+  return out;
+}
+
+function extractUserText(payload) {
+  const direct =
+    payload?.userText ||
+    payload?.text ||
+    payload?.runRequest?.action?.userMessageAction?.userMessage?.text ||
+    payload?.runRequest?.action?.userMessageAction?.prependUserMessages?.at?.(-1)?.text;
+  if (typeof direct === "string" && direct.trim()) return direct.trim();
+  const candidates = collectStrings(payload)
+    .filter((candidate) => candidate.text.length <= 20000)
+    .sort((a, b) => a.score - b.score);
+  const chosen = candidates[candidates.length - 1];
+  return chosen ? chosen.text : "";
+}
+
+function parseJsonMaybe(value) {
+  if (value == null) return undefined;
+  if (typeof value === "object") return value;
+  if (typeof value !== "string") return undefined;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return undefined;
+  }
+}
+
+function extractConversationMessages(payload) {
+  const messages = [];
+  const turns = payload?.runRequest?.conversationState?.turns || payload?.conversationState?.turns || [];
+  for (const turn of turns) {
+    const parsed = parseJsonMaybe(turn);
+    const text = extractUserText(parsed || turn);
+    if (text) messages.push({ role: "user", content: text });
+  }
+  const current = extractUserText(payload);
+  const images = extractImages(payload);
+  if (current || images.length > 0) messages.push({ role: "user", content: current, images });
+  if (messages.length === 0) messages.push({ role: "user", content: "Please reply briefly." });
+  return compactMessages(messages);
+}
+
+function compactMessages(messages) {
+  const out = [];
+  for (const message of messages) {
+    if (!message.content && !message.images?.length) continue;
+    const prev = out[out.length - 1];
+    if (prev && prev.role === message.role && prev.content === message.content) continue;
+    const images = Array.isArray(message.images) && message.images.length > 0 ? message.images : undefined;
+    out.push({
+      role: message.role,
+      content: message.content || "",
+      ...(images ? { images } : {}),
+    });
+  }
+  return out.slice(-32);
+}
+
+function toResponsesInput(messages) {
+  return messages.map((message) => ({
+    role: message.role === "assistant" ? "assistant" : "user",
+    content: toResponsesContent(message),
+  }));
+}
+
+function toChatMessages(messages) {
+  return messages.map((message) => ({
+    role: message.role === "assistant" ? "assistant" : "user",
+    content: toChatContent(message),
+  }));
+}
+
+function toResponsesContent(message) {
+  const content = [];
+  const text = String(message.content || "");
+  if (text || !message.images?.length) {
+    content.push({
+      type: message.role === "assistant" ? "output_text" : "input_text",
+      text,
+    });
+  }
+  if (message.role !== "assistant") {
+    for (const image of message.images || []) {
+      content.push({ type: "input_image", image_url: image.url });
+    }
+  }
+  return content;
+}
+
+function toChatContent(message) {
+  if (message.role === "assistant" || !message.images?.length) return String(message.content || "");
+  const content = [];
+  const text = String(message.content || "");
+  if (text) content.push({ type: "text", text });
+  for (const image of message.images) content.push({ type: "image_url", image_url: { url: image.url } });
+  return content;
+}
+
+function cursorPayloadToOpenAI(payload, route) {
+  const messages = extractConversationMessages(payload);
+  const max = route.model.maxOutputTokens;
+  if (route.provider.type === "openai-responses") {
+    return {
+      model: route.model.apiModel,
+      stream: true,
+      input: toResponsesInput(messages),
+      tools: normalizeTools(payload?.tools || payload?.runRequest?.mcpTools),
+      tool_choice: payload?.tool_choice || "auto",
+      parallel_tool_calls: payload?.parallel_tool_calls !== false,
+      max_output_tokens: payload?.max_output_tokens || max,
+    };
+  }
+  return {
+    model: route.model.apiModel,
+    stream: true,
+    messages: toChatMessages(messages),
+    tools: normalizeTools(payload?.tools || payload?.runRequest?.mcpTools),
+    tool_choice: payload?.tool_choice || "auto",
+    parallel_tool_calls: payload?.parallel_tool_calls !== false,
+    max_tokens: payload?.max_tokens || payload?.max_output_tokens || max,
+  };
+}
+
+function normalizeTools(tools) {
+  if (!tools) return undefined;
+  if (Array.isArray(tools)) return tools;
+  const values = Object.values(tools);
+  if (values.length === 0) return undefined;
+  return values;
+}
+
+function extractImages(payload) {
+  const images = [];
+  const seen = new Set();
+  collectImages(payload, images, seen, []);
+  return images.slice(0, 8);
+}
+
+function collectImages(value, out, seen, pathParts) {
+  if (value == null || out.length >= 8) return;
+  if (typeof value === "string") {
+    const image = imageFromString(value, pathParts);
+    if (image && !seen.has(image.url)) {
+      seen.add(image.url);
+      out.push(image);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => collectImages(item, out, seen, pathParts.concat(String(index))));
+    return;
+  }
+  if (typeof value !== "object") return;
+
+  const direct = imageFromObject(value, pathParts);
+  if (direct && !seen.has(direct.url)) {
+    seen.add(direct.url);
+    out.push(direct);
+  }
+  for (const [key, child] of Object.entries(value)) collectImages(child, out, seen, pathParts.concat(key));
+}
+
+function imageFromObject(value, pathParts) {
+  const mime = value.mimeType || value.mimetype || value.contentType || value.type;
+  if (typeof mime === "string" && mime.startsWith("image/")) {
+    const data = value.data || value.base64 || value.bytes || value.content;
+    if (typeof data === "string") {
+      if (data.startsWith("data:image/")) return { url: data, source: pathParts.join(".") };
+      if (looksLikeImageBase64(data)) return { url: `data:${mime};base64,${stripBase64(data)}`, source: pathParts.join(".") };
+    }
+  }
+  const file = value.path || value.filePath || value.fsPath || value.uri;
+  if (typeof file === "string") return imageFromString(file, pathParts);
+  const url = value.url || value.imageUrl || value.image_url;
+  if (typeof url === "string") return imageFromString(url, pathParts);
+  return null;
+}
+
+function imageFromString(value, pathParts = []) {
+  const text = value.trim();
+  if (!text) return null;
+  if (/^data:image\/[a-z0-9.+-]+;base64,/i.test(text)) return { url: text, source: pathParts.join(".") };
+  if (/^https?:\/\//i.test(text) && looksLikeImagePath(text)) return { url: text, source: pathParts.join(".") };
+  if (text.startsWith("file://")) return imageFromFilePath(decodeURIComponent(new URL(text).pathname), pathParts);
+  if (looksLikeImagePath(text)) return imageFromFilePath(text, pathParts);
+  if (pathParts.some((part) => /image|base64|bytes|data/i.test(part)) && looksLikeImageBase64(text)) {
+    const mime = mimeFromImageBase64(text);
+    if (mime) return { url: `data:${mime};base64,${stripBase64(text)}`, source: pathParts.join(".") };
+  }
+  return null;
+}
+
+function imageFromFilePath(file, pathParts) {
+  try {
+    const resolved = path.resolve(String(file).replace(/^~(?=\/|\\)/, process.env.HOME || ""));
+    if (!looksLikeImagePath(resolved)) return null;
+    const stat = fs.statSync(resolved);
+    if (!stat.isFile() || stat.size > MAX_IMAGE_BYTES) return null;
+    const ext = path.extname(resolved).toLowerCase();
+    const mime = IMAGE_MIME_BY_EXT[ext] || "image/png";
+    return { url: `data:${mime};base64,${fs.readFileSync(resolved).toString("base64")}`, source: pathParts.join(".") };
+  } catch {
+    return null;
+  }
+}
+
+function looksLikeImagePath(value) {
+  try {
+    const clean = String(value).split(/[?#]/)[0];
+    return IMAGE_EXTENSIONS.has(path.extname(clean).toLowerCase());
+  } catch {
+    return false;
+  }
+}
+
+function looksLikeImageBase64(value) {
+  const stripped = stripBase64(value);
+  if (stripped.length < 32 || stripped.length > MAX_IMAGE_BYTES * 2) return false;
+  return !!mimeFromImageBase64(stripped);
+}
+
+function mimeFromImageBase64(value) {
+  const stripped = stripBase64(value);
+  if (stripped.startsWith("iVBORw0KGgo")) return "image/png";
+  if (stripped.startsWith("/9j/")) return "image/jpeg";
+  if (stripped.startsWith("UklGR")) return "image/webp";
+  if (stripped.startsWith("R0lGOD")) return "image/gif";
+  return null;
+}
+
+function stripBase64(value) {
+  return String(value).replace(/^data:image\/[a-z0-9.+-]+;base64,/i, "").replace(/\s+/g, "");
+}
+
+module.exports = {
+  extractUserText,
+  extractConversationMessages,
+  extractImages,
+  cursorPayloadToOpenAI,
+  toResponsesInput,
+  toChatMessages,
+};
+
+},
+"src/provider-adapters/openai-compatible.js": function(module, exports, require, __filename, __dirname) {
+"use strict";
+
+const { resolveApiKey, resolveModel } = require("../config");
+
+function endpointFor(provider, kind) {
+  const base = provider.baseUrl.replace(/\/+$/, "");
+  if (kind === "responses") return `${base}/responses`;
+  if (kind === "chat") return `${base}/chat/completions`;
+  throw new Error(`Unknown endpoint kind ${kind}`);
+}
+
+function routeRequestModel(config, body, preferredKind) {
+  const route = resolveModel(config, body && body.model);
+  const kind = preferredKind || (route.provider.type === "openai-responses" ? "responses" : "chat");
+  const mapped = { ...(body || {}), model: route.model.apiModel };
+  return { ...route, body: mapped, kind };
+}
+
+async function proxyOpenAIRequest(config, kind, body, headers = {}) {
+  const route = routeRequestModel(config, body, kind);
+  return fetchProviderWithUnsupportedParamRetry(route.provider, route.kind, route.body, headers);
+}
+
+function outboundHeaders(provider, incoming = {}) {
+  const headers = {
+    "content-type": "application/json",
+    authorization: `Bearer ${resolveApiKey(provider)}`,
+  };
+  for (const [key, value] of Object.entries(incoming || {})) {
+    const lower = key.toLowerCase();
+    if (lower.startsWith("x-") || lower === "openai-beta") headers[key] = value;
+  }
+  return headers;
+}
+
+async function* streamProviderEvents(config, route, openaiBody) {
+  const kind = route.provider.type === "openai-responses" ? "responses" : "chat";
+  const body = {
+    ...openaiBody,
+    model: route.model.apiModel,
+    stream: true,
+  };
+  const res = await fetchProviderWithUnsupportedParamRetry(route.provider, kind, body);
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Provider ${res.status}: ${text.slice(0, 1200)}`);
+  }
+  if (!res.body) throw new Error("Provider response is not streamable");
+  for await (const event of parseSse(res.body)) {
+    if (event === "[DONE]") break;
+    let json;
+    try {
+      json = JSON.parse(event);
+    } catch {
+      continue;
+    }
+    yield* normalizeProviderEvent(kind, json);
+  }
+}
+
+async function callProviderOnce(config, route, openaiBody) {
+  const kind = route.provider.type === "openai-responses" ? "responses" : "chat";
+  const body = { ...openaiBody, model: route.model.apiModel, stream: false };
+  const res = await fetchProviderWithUnsupportedParamRetry(route.provider, kind, body);
+  const text = await res.text();
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    throw new Error(`Provider returned non-JSON ${res.status}: ${text.slice(0, 500)}`);
+  }
+  if (!res.ok) throw new Error(`Provider ${res.status}: ${JSON.stringify(json).slice(0, 1200)}`);
+  return extractFinalText(kind, json);
+}
+
+async function fetchProviderWithUnsupportedParamRetry(provider, kind, body, headers = {}) {
+  const attempted = new Set();
+  let current = sanitizeBodyForProvider(provider, body);
+  for (;;) {
+    const res = await fetch(endpointFor(provider, kind), {
+      method: "POST",
+      headers: outboundHeaders(provider, headers),
+      body: JSON.stringify(current),
+    });
+    if (res.ok) return res;
+
+    const text = await res.text();
+    const unsupported = parseUnsupportedParameter(text);
+    if (!unsupported || attempted.has(unsupported) || !Object.prototype.hasOwnProperty.call(current, unsupported)) {
+      return responseFromText(text, res);
+    }
+    attempted.add(unsupported);
+    current = { ...current };
+    delete current[unsupported];
+  }
+}
+
+function sanitizeBodyForProvider(provider, body) {
+  const out = { ...(body || {}) };
+  for (const param of provider.omitParams || provider.unsupportedParams || []) {
+    delete out[param];
+  }
+  return out;
+}
+
+function parseUnsupportedParameter(text) {
+  if (!text) return null;
+  try {
+    const json = JSON.parse(text);
+    const message = json?.error?.message || json?.message || "";
+    const param = json?.error?.param || json?.param || "";
+    if (param && /unsupported parameter/i.test(message)) return param;
+    const fromMessage = message.match(/Unsupported parameter:\s*['"]?([A-Za-z0-9_.-]+)['"]?/i);
+    if (fromMessage) return fromMessage[1];
+  } catch {}
+  const match = String(text).match(/Unsupported parameter:\s*['"]?([A-Za-z0-9_.-]+)['"]?/i);
+  return match ? match[1] : null;
+}
+
+function responseFromText(text, res) {
+  return new Response(text, {
+    status: res.status,
+    statusText: res.statusText,
+    headers: Object.fromEntries(res.headers.entries()),
+  });
+}
+
+async function* parseSse(body) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  for await (const chunk of body) {
+    buffer += decoder.decode(chunk, { stream: true });
+    let idx;
+    while ((idx = buffer.indexOf("\n\n")) >= 0) {
+      const raw = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 2);
+      const data = raw
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).trimStart())
+        .join("\n");
+      if (data) yield data;
+    }
+  }
+  buffer += decoder.decode();
+  const data = buffer
+    .split(/\r?\n/)
+    .filter((line) => line.startsWith("data:"))
+    .map((line) => line.slice(5).trimStart())
+    .join("\n");
+  if (data) yield data;
+}
+
+function* normalizeProviderEvent(kind, event) {
+  if (kind === "chat") {
+    const choice = event.choices && event.choices[0];
+    const delta = choice && choice.delta;
+    if (delta && typeof delta.content === "string" && delta.content) {
+      yield { type: "text_delta", text: delta.content };
+    }
+    for (const toolCall of delta?.tool_calls || []) {
+      yield {
+        type: "tool_call_delta",
+        id: toolCall.id,
+        index: toolCall.index,
+        name: toolCall.function && toolCall.function.name,
+        argumentsDelta: toolCall.function && toolCall.function.arguments,
+      };
+    }
+    if (choice && choice.finish_reason) yield { type: "finish", reason: choice.finish_reason };
+    return;
+  }
+
+  if (event.type === "response.output_text.delta" && typeof event.delta === "string") {
+    yield { type: "text_delta", text: event.delta };
+    return;
+  }
+  if (event.type === "response.function_call_arguments.delta") {
+    yield {
+      type: "tool_call_delta",
+      id: event.item_id,
+      name: event.name,
+      argumentsDelta: event.delta || "",
+    };
+    return;
+  }
+  if (event.type === "response.output_item.done" && event.item && event.item.type === "function_call") {
+    yield {
+      type: "tool_call",
+      id: event.item.call_id || event.item.id,
+      name: event.item.name,
+      arguments: event.item.arguments || "{}",
+    };
+    return;
+  }
+  if (event.type === "response.completed") yield { type: "finish", reason: "completed" };
+}
+
+function extractFinalText(kind, response) {
+  if (kind === "chat") {
+    return response?.choices?.[0]?.message?.content || "";
+  }
+  if (typeof response.output_text === "string") return response.output_text;
+  const parts = [];
+  for (const item of response.output || []) {
+    for (const content of item.content || []) {
+      if (typeof content.text === "string") parts.push(content.text);
+    }
+  }
+  return parts.join("");
+}
+
+module.exports = {
+  endpointFor,
+  routeRequestModel,
+  proxyOpenAIRequest,
+  streamProviderEvents,
+  callProviderOnce,
+  parseSse,
+  normalizeProviderEvent,
+  extractFinalText,
+  fetchProviderWithUnsupportedParamRetry,
+  parseUnsupportedParameter,
+  sanitizeBodyForProvider,
+};
+
+}
+};
+const __bundleCache = Object.create(null);
+const __bundleNodeRequire = require;
+
+function __bundleNormalize(id) {
+  return id.split(__bundlePath.sep).join("/");
+}
+
+function __bundleResolve(fromId, request) {
+  if (!request.startsWith(".")) return null;
+  const base = __bundlePath.resolve(__bundleRoot, __bundlePath.dirname(fromId), request);
+  for (const candidate of [base, base + ".js", __bundlePath.join(base, "index.js")]) {
+    const id = __bundleNormalize(__bundlePath.relative(__bundleRoot, candidate));
+    if (__bundleModules[id]) return id;
+  }
+  throw new Error("Cannot resolve " + request + " from " + fromId);
+}
+
+function __bundleRequire(id) {
+  if (__bundleCache[id]) return __bundleCache[id].exports;
+  const factory = __bundleModules[id];
+  if (!factory) return __bundleNodeRequire(id);
+  const module = { exports: {} };
+  __bundleCache[id] = module;
+  const filename = __bundlePath.join(__bundleRoot, id);
+  const dirname = __bundlePath.dirname(filename);
+  function localRequire(request) {
+    const localId = __bundleResolve(id, request);
+    return localId ? __bundleRequire(localId) : __bundleNodeRequire(request);
+  }
+  factory(module, module.exports, localRequire, filename, dirname);
+  return module.exports;
+}
+
+__bundleRequire("src/daemon-entry.js");