feat: add LMArena provider (Phase 2A of #3368)

open-sse/executors/index.ts

@@ -49,6 +49,7 @@ import { QwenWebExecutor } from "./qwen-web.ts";
 import { KimiExecutor } from "./kimi.ts"
 import { TheOldLlmExecutor } from "./theoldllm.ts";
 import { ChipotleExecutor } from "./chipotle.ts";
+import { LMArenaExecutor } from "./lmarena.ts";
 
 const executors = {
   antigravity: new AntigravityExecutor(),
@@ -140,6 +141,8 @@ const executors = {
   tllm: new TheOldLlmExecutor(), // Alias
   chipotle: new ChipotleExecutor(),
   pepper: new ChipotleExecutor(), // Alias
+  lmarena: new LMArenaExecutor(),
+  lma: new LMArenaExecutor(), // Alias
 };
 
 const defaultCache = new Map();
@@ -198,3 +201,4 @@ export { InnerAiExecutor } from "./inner-ai.ts";
 export { QwenWebExecutor } from "./qwen-web.ts";
 export { TheOldLlmExecutor } from "./theoldllm.ts";
 export { ChipotleExecutor } from "./chipotle.ts";
+export { LMArenaExecutor } from "./lmarena.ts";

open-sse/executors/lmarena.ts

@@ -0,0 +1,100 @@
+/**
+ * LMArenaExecutor — LMArena Web Session Provider
+ *
+ * Routes requests through LMArena's web interface using session credentials.
+ * LMArena is a model comparison platform with 40+ models (GPT, Claude, Gemini, Llama).
+ *
+ * API Structure (to be completed based on actual LMArena API):
+ *   Endpoint: https://lmarena.ai/api/chat (placeholder)
+ *   Method: POST
+ *   Content-Type: application/json
+ *   Accept: text/event-stream
+ *
+ * Auth pipeline (per request):
+ *   1. Extract session cookie from credentials
+ *   2. Build request with model and messages
+ *   3. Make authenticated POST request to LMArena API
+ *   4. Handle SSE response stream
+ *
+ * NOTE: This is a skeleton implementation. The actual LMArena API integration
+ * needs to be completed based on reverse-engineering or official documentation.
+ * See issue #3368 for tracking.
+ */
+import { BaseExecutor, type ExecuteInput } from "./base.ts";
+
+const LMARENA_API_BASE = "https://lmarena.ai/api";
+
+function readLMArenaCookie(credentials: unknown): string {
+  if (!credentials || typeof credentials !== "object") return "";
+  const c = credentials as Record<string, unknown>;
+  const direct = typeof c.cookie === "string" ? c.cookie : "";
+  if (direct.trim()) return direct;
+  const apiKey = typeof c.apiKey === "string" ? c.apiKey : "";
+  if (apiKey.trim()) return apiKey;
+  const psd = c.providerSpecificData;
+  if (psd && typeof psd === "object") {
+    const nested = (psd as Record<string, unknown>).cookie;
+    if (typeof nested === "string" && nested.trim()) return nested;
+  }
+  return "";
+}
+
+export class LMArenaExecutor extends BaseExecutor {
+  constructor(providerConfig = {}) {
+    super("lmarena", { format: "openai", ...providerConfig });
+  }
+
+  protected buildUrl(_model: string, _credentials: unknown): string {
+    // TODO: Implement actual LMArena API endpoint
+    return `${LMARENA_API_BASE}/chat`;
+  }
+
+  protected buildHeaders(
+    _model: string,
+    credentials: unknown,
+    _body: unknown
+  ): Record<string, string> {
+    const cookie = readLMArenaCookie(credentials);
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      Accept: "text/event-stream",
+      "User-Agent":
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    };
+
+    if (cookie) {
+      headers.Cookie = cookie;
+    }
+
+    return headers;
+  }
+
+  protected transformRequest(body: unknown, _model: string): unknown {
+    // TODO: Transform OpenAI format to LMArena format
+    // For now, pass through as-is
+    return body;
+  }
+
+  async execute(input: ExecuteInput): Promise<Response> {
+    const { model, body, stream, credentials, signal, log } = input;
+
+    log?.info?.("LMArenaExecutor", `Executing request for model: ${model}`);
+
+    // TODO: Implement actual LMArena API call
+    // This is a placeholder that returns an error indicating the API is not yet implemented
+    return new Response(
+      JSON.stringify({
+        error: {
+          message:
+            "LMArena executor is not yet fully implemented. API integration pending.",
+          type: "not_implemented",
+          code: "not_implemented",
+        },
+      }),
+      {
+        status: 501,
+        headers: { "Content-Type": "application/json" },
+      }
+    );
+  }
+}

src/shared/constants/providers.ts

@@ -470,6 +470,20 @@ export const WEB_COOKIE_PROVIDERS = {
     authHint:
       "Paste your __client cookie value from .clerk.agent.adapta.one (DevTools → Application → Cookies)",
   },
+  lmarena: {
+    id: "lmarena",
+    alias: "lma",
+    name: "LMArena (Free)",
+    icon: "auto_awesome",
+    color: "#FF6B6B",
+    textIcon: "LMA",
+    website: "https://lmarena.ai",
+    hasFree: true,
+    freeNote: "Free model comparison platform — 40+ models (GPT, Claude, Gemini, Llama). No subscription required.",
+    authHint:
+      "Paste your session cookie from lmarena.ai (DevTools → Application → Cookies). Optional — works with free tier for basic comparisons.",
+    riskNoticeVariant: "webCookie",
+  },
   huggingchat: {
     id: "huggingchat",
     // "hc" belongs to the hackclub provider; huggingchat uses its own id as alias.

src/shared/providers/webSessionCredentials.ts

@@ -192,6 +192,13 @@ export const WEB_SESSION_CREDENTIAL_REQUIREMENTS = {
     acceptsFullCookieHeader: true,
     storageKeys: ["cookie", "manus_session"],
   },
+  lmarena: {
+    kind: "cookie",
+    credentialName: "session",
+    placeholder: "session=... or full Cookie header from lmarena.ai",
+    acceptsFullCookieHeader: true,
+    storageKeys: ["cookie", "session"],
+  },
 } satisfies Record<keyof typeof WEB_COOKIE_PROVIDERS, WebSessionCredentialRequirement>;
 
 export function getWebSessionCredentialRequirement(

tests/unit/lmarena-provider.test.ts

@@ -0,0 +1,133 @@
+/**
+ * LMArena Provider — Unit Tests (Phase 2A of issue #3368)
+ *
+ * Run: node --import tsx/esm --test tests/unit/lmarena-provider.test.ts
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { WEB_COOKIE_PROVIDERS } from "../../src/shared/constants/providers.ts";
+import {
+  getWebSessionCredentialRequirement,
+  requiresWebSessionCredential,
+  hasUsableWebSessionCredential,
+} from "../../src/shared/providers/webSessionCredentials.ts";
+import { LMArenaExecutor } from "../../open-sse/executors/lmarena.ts";
+
+describe("LMArena Provider Definition", () => {
+  it("is registered in WEB_COOKIE_PROVIDERS", () => {
+    assert.ok(WEB_COOKIE_PROVIDERS.lmarena, "lmarena should be in WEB_COOKIE_PROVIDERS");
+    assert.equal(WEB_COOKIE_PROVIDERS.lmarena.id, "lmarena");
+    assert.equal(WEB_COOKIE_PROVIDERS.lmarena.alias, "lma");
+    assert.equal(WEB_COOKIE_PROVIDERS.lmarena.name, "LMArena (Free)");
+    assert.equal(WEB_COOKIE_PROVIDERS.lmarena.website, "https://lmarena.ai");
+    assert.equal(WEB_COOKIE_PROVIDERS.lmarena.hasFree, true);
+    assert.equal(WEB_COOKIE_PROVIDERS.lmarena.riskNoticeVariant, "webCookie");
+  });
+
+  it("has correct metadata", () => {
+    const provider = WEB_COOKIE_PROVIDERS.lmarena;
+    assert.ok(provider.freeNote, "Should have freeNote");
+    assert.ok(provider.authHint, "Should have authHint");
+    assert.ok(provider.icon, "Should have icon");
+    assert.ok(provider.color, "Should have color");
+    assert.ok(provider.textIcon, "Should have textIcon");
+  });
+});
+
+describe("LMArena Credential Requirements", () => {
+  it("requires web session credential", () => {
+    assert.equal(requiresWebSessionCredential("lmarena"), true);
+  });
+
+  it("has correct credential requirement", () => {
+    const req = getWebSessionCredentialRequirement("lmarena");
+    assert.ok(req, "Should have credential requirement");
+    assert.equal(req.kind, "cookie");
+    assert.equal(req.credentialName, "session");
+    assert.ok(req.placeholder.includes("lmarena.ai"));
+    assert.equal(req.acceptsFullCookieHeader, true);
+    assert.ok(req.storageKeys.includes("cookie"));
+    assert.ok(req.storageKeys.includes("session"));
+  });
+
+  it("validates usable credentials correctly", () => {
+    assert.equal(
+      hasUsableWebSessionCredential("lmarena", { cookie: "session=abc123" }),
+      true
+    );
+    assert.equal(
+      hasUsableWebSessionCredential("lmarena", { session: "abc123" }),
+      true
+    );
+    assert.equal(
+      hasUsableWebSessionCredential("lmarena", { cookie: "" }),
+      false
+    );
+    assert.equal(
+      hasUsableWebSessionCredential("lmarena", {}),
+      false
+    );
+  });
+});
+
+describe("LMArena Executor", () => {
+  it("can be instantiated", () => {
+    const executor = new LMArenaExecutor();
+    assert.ok(executor, "Executor should be instantiated");
+  });
+
+  it("has correct provider ID", () => {
+    const executor = new LMArenaExecutor();
+    assert.equal((executor as any).provider, "lmarena");
+  });
+
+  it("builds correct URL", () => {
+    const executor = new LMArenaExecutor();
+    const url = (executor as any).buildUrl("gpt-4", {});
+    assert.ok(url.includes("lmarena.ai"), "URL should include lmarena.ai");
+  });
+
+  it("builds headers with cookie", () => {
+    const executor = new LMArenaExecutor();
+    const headers = (executor as any).buildHeaders("gpt-4", { cookie: "session=abc123" }, {});
+    assert.ok(headers.Cookie, "Should have Cookie header");
+    assert.equal(headers.Cookie, "session=abc123");
+    assert.equal(headers["Content-Type"], "application/json");
+    assert.equal(headers.Accept, "text/event-stream");
+  });
+
+  it("builds headers without cookie when not provided", () => {
+    const executor = new LMArenaExecutor();
+    const headers = (executor as any).buildHeaders("gpt-4", {}, {});
+    assert.ok(!headers.Cookie, "Should not have Cookie header when no cookie provided");
+  });
+
+  it("reads cookie from credentials correctly", () => {
+    const executor = new LMArenaExecutor();
+
+    // Direct cookie field
+    let headers = (executor as any).buildHeaders("gpt-4", { cookie: "session=abc" }, {});
+    assert.equal(headers.Cookie, "session=abc");
+
+    // apiKey field (dashboard form)
+    headers = (executor as any).buildHeaders("gpt-4", { apiKey: "session=def" }, {});
+    assert.equal(headers.Cookie, "session=def");
+
+    // providerSpecificData.cookie
+    headers = (executor as any).buildHeaders(
+      "gpt-4",
+      { providerSpecificData: { cookie: "session=ghi" } },
+      {}
+    );
+    assert.equal(headers.Cookie, "session=ghi");
+
+    // Priority: direct > apiKey > providerSpecificData
+    headers = (executor as any).buildHeaders(
+      "gpt-4",
+      { cookie: "session=abc", apiKey: "session=def" },
+      {}
+    );
+    assert.equal(headers.Cookie, "session=abc");
+  });
+});