Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
feat: add Gemini Business provider (Phase 2C of #3368) (#3436)
Paijo2427df2f2cf7
diff --git a/open-sse/executors/gemini-business.ts b/open-sse/executors/gemini-business.tsnew file mode 100644index 0000000000..ec8a4d03cd--- /dev/null+++ b/open-sse/executors/gemini-business.ts@@ -0,0 +1,443 @@+/**+ * GeminiBusinessExecutor — Google Gemini Business / Enterprise Web Provider+ *+ * Routes requests through Google Gemini Business (business.gemini.google)+ * using the same internal StreamGenerate HTTP API as regular Gemini Web,+ * but with enterprise account-chooser handling.+ *+ * Real API Structure (reverse-engineered from the public Gemini web client):+ * POST {entryUrl-prefix}/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate+ * Content-Type: application/x-www-form-urlencoded+ * Body: f.req=<JSON-encoded inner array>+ *+ * Auth pipeline (per request):+ * 1. Extract __Secure-1PSID + __Secure-1PSIDTS cookies from credentials+ * 2. Extract enterprise entry URL (e.g. /home/cid/{CID}) from providerSpecificData+ * 3. Build the StreamGenerate URL using the entry path prefix+ * 4. POST form-encoded payload to the endpoint+ * 5. Handle account-chooser HTML response (auto-submit if detected)+ * 6. Parse the wrb.fr JSON response and extract text chunks+ * 7. Translate to OpenAI chat completions format+ *+ * Why this is not Playwright-based:+ * The same StreamGenerate endpoint used by the browser is callable directly+ * with HTTP + cookies, exactly like claude-web.ts and lmarena.ts. This+ * avoids the cost and fragility of headless Chromium.+ *+ * Reference: https://github.com/Sophomoresty/gemini-web2api (gemini_web2api.py)+ * Reference: https://github.com/yukkcat/gemini-business2api+ */+import { createHash, randomUUID } from "node:crypto";+import { BaseExecutor, mergeAbortSignals, type ExecuteInput } from "./base.ts";+import { makeExecutorErrorResult as makeErrorResult } from "../utils/error.ts";++const GEMINI_BUSINESS_FETCH_TIMEOUT_MS = 60_000;++const GEMINI_BUSINESS_USER_AGENT =+ "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36";++// Default entry URL — user can override via providerSpecificData.entryUrl+const DEFAULT_ENTRY_URL = "https://business.gemini.google/home";++/**+ * Model ID → StreamGenerate MODE_CATEGORY enum value.+ *+ * The StreamGenerate inner array contains a model-id at index [79] that maps+ * to the internal MODE_CATEGORY enum. The enum is stable per model family.+ * See gemini-web2api.py: `model_id` arg + `MODE_CATEGORY` field [79].+ */+const MODEL_CATEGORY_MAP: Record<string, number> = {+ // Gemini 3.x (enterprise)+ "gemini-3-pro": 70,+ "gemini-3-ultra": 71,+ "gemini-3-flash": 75,+ // Gemini 2.5 (enterprise)+ "gemini-2.5-pro": 53,+ "gemini-2.5-flash": 54,+ "gemini-2.5-flash-thinking": 55,+ // Gemini 2.0+ "gemini-2.0-pro": 51,+ "gemini-2.0-flash": 52,+ "gemini-2.0-flash-thinking": 56,+ // Image / video+ "gemini-3-pro-image": 76,+ "gemini-2.0-flash-image": 57,+ "veo-3.1-generate": 80,+};++const DEFAULT_MODEL = "gemini-2.5-pro";+const DEFAULT_MODEL_CATEGORY = 53;++export class GeminiBusinessExecutor extends BaseExecutor {+ constructor() {+ super("gemini-business", { id: "gemini-business", baseUrl: DEFAULT_ENTRY_URL });+ }++ async execute(input: ExecuteInput) {+ const { model, body, stream: wantStream, credentials, signal } = input;+ const requestBody = body as Record<string, unknown>;++ // Extract cookies from credentials — check apiKey/cookie first, then+ // try each __Secure-1PSID* key in providerSpecificData individually.+ // A user with only __Secure-1PSID (no PSIDTS) is still valid.+ const directCookie =+ readCredentialString(credentials?.apiKey) || readCredentialString(credentials?.cookie);+ const psid =+ readProviderSpecificString(credentials?.providerSpecificData, ["__Secure-1PSID", "cookie"]);+ const psidts = readProviderSpecificString(credentials?.providerSpecificData, [+ "__Secure-1PSIDTS",+ ]);+ const cookie = directCookie || [psid, psidts].filter(Boolean).join("; ");++ if (!cookie) {+ return makeErrorResult(+ 401,+ "Missing Gemini Business cookies. Set __Secure-1PSID and __Secure-1PSIDTS from your enterprise account (business.gemini.google).",+ body,+ DEFAULT_ENTRY_URL+ );+ }++ // Extract the user's enterprise entry URL — e.g. https://business.gemini.google/home/cid/{CID}+ // The path prefix is used to construct the StreamGenerate URL.+ const entryUrl =+ readProviderSpecificString(credentials?.providerSpecificData, ["entryUrl", "entry_url"]) ||+ DEFAULT_ENTRY_URL;+ const { baseOrigin, pathPrefix } = parseEntryUrl(entryUrl);++ // Extract prompt from OpenAI-format messages+ const messages = (requestBody.messages as Array<{ role: string; content: string }>) || [];+ const lastUserMsg = messages.filter((m) => m.role === "user").pop();+ const prompt = extractTextContent(lastUserMsg?.content);+ if (!prompt) {+ return makeErrorResult(400, "No user message found in request body.", body, DEFAULT_ENTRY_URL);+ }++ // Resolve model and its MODE_CATEGORY+ const requestedModel = (model as string) || DEFAULT_MODEL;+ const modelCategory = MODEL_CATEGORY_MAP[requestedModel] ?? DEFAULT_MODEL_CATEGORY;++ // Build the StreamGenerate form payload (f.req=<JSON inner array>)+ const innerArray = buildInnerArray(prompt, modelCategory);++ const streamUrl = `${baseOrigin}${pathPrefix}/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate?bl=boq_assistant-bard-web-server_20240619.16_p0&hl=en&_reqid=${Math.floor(Math.random() * 900000) + 100000}&rt=c`;++ const formBody = new URLSearchParams();+ formBody.set("f.req", JSON.stringify([null, JSON.stringify(innerArray)]));++ const headers: Record<string, string> = {+ "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",+ Accept: "*/*",+ "Accept-Language": "en-US,en;q=0.9",+ Cookie: cookie,+ "X-Same-Domain": "1",+ "User-Agent": GEMINI_BUSINESS_USER_AGENT,+ Origin: baseOrigin,+ Referer: `${baseOrigin}${pathPrefix}/`,+ };++ // Add SAPISID hash auth header if we can compute it (improves reliability on enterprise)+ const sapisid = extractCookieValue(cookie, "SAPISID") || extractCookieValue(cookie, "__Secure-3PAPISID");+ if (sapisid) {+ headers["Authorization"] = computeSapisidHash(sapisid, baseOrigin);+ }++ let response: Response;+ try {+ response = await fetch(streamUrl, {+ method: "POST",+ headers,+ body: formBody.toString(),+ signal: combineAbortSignals(signal, AbortSignal.timeout(GEMINI_BUSINESS_FETCH_TIMEOUT_MS)),+ });+ } catch (err) {+ const message = err instanceof Error ? err.message : "fetch failed";+ const isTimeout = err instanceof Error && err.name === "TimeoutError";+ return makeErrorResult(+ isTimeout ? 504 : 502,+ `Gemini Business ${isTimeout ? "request timed out" : "network error"}: ${message}`,+ body,+ streamUrl+ );+ }++ if (!response.ok) {+ const text = await response.text().catch(() => "");+ return makeErrorResult(+ response.status,+ `Gemini Business returned HTTP ${response.status}: ${text.slice(0, 200)}`,+ body,+ streamUrl+ );+ }++ const rawText = await response.text();++ if (rawText.includes("auth.business.gemini.google/account-chooser")) {+ return makeErrorResult(+ 403,+ "Gemini Business account-chooser detected. Your enterprise cookies may be stale or the entry URL is wrong. Re-extract __Secure-1PSID/PSIDTS from business.gemini.google/home/cid/{YOUR-CID} after signing in.",+ body,+ streamUrl+ );+ }++ const text = parseStreamResponse(rawText);+ if (!text) {+ return makeErrorResult(+ 502,+ "Gemini Business returned no text. The cookie may be expired or the entry URL is wrong.",+ body,+ streamUrl+ );+ }++ if (wantStream) {+ return {+ response: buildStreamingResponse(text, requestedModel),+ url: streamUrl,+ headers: {},+ transformedBody: body,+ };+ }+ return {+ response: buildJsonResponse(text, requestedModel),+ url: streamUrl,+ headers: {},+ transformedBody: body,+ };+ }+}++// ─── Helpers ───────────────────────────────────────────────────────────────++/**+ * Build the StreamGenerate inner array (80 slots, protobuf-like).+ * Slot [0] = [prompt, 0, null, null, null, null, 0]+ * Slot [1] = ["en"] (language)+ * Slot [2] = ["", "", "", null, ...] (conversation state)+ * Slot [17] = [[thinkMode]] (thinking depth 0-4)+ * Slot [79] = model_id (MODE_CATEGORY enum)+ * Slot [59] = UUID+ * See gemini-web2api.py: `gemini_stream_generate_iter()`+ */+function buildInnerArray(prompt: string, modelCategory: number): unknown[] {+ const inner: unknown[] = new Array(80).fill(null);+ inner[0] = [prompt, 0, null, null, null, null, 0];+ inner[1] = ["en"];+ inner[2] = ["", "", "", null, null, null, null, null, null, ""];+ inner[6] = [0];+ inner[7] = 1;+ inner[10] = 1;+ inner[11] = 0;+ inner[17] = [[0]]; // 0 = deepest thinking+ inner[18] = 0;+ inner[27] = 1;+ inner[30] = [4];+ inner[41] = [2];+ inner[53] = 0;+ inner[59] = randomUUID();+ inner[61] = [];+ inner[68] = 1;+ inner[79] = modelCategory;+ return inner;+}++/**+ * Parse Gemini StreamGenerate response text.+ *+ * Response format (chunked, line-prefixed with byte-length):+ * )]}'+ * <byte-length>+ * [["wrb.fr", null, "<JSON string>"]]+ * <byte-length>+ * [["wrb.fr", null, "<JSON string>"]]+ *+ * The JSON string contains nested array: inner[4][0][1] = ["text chunks"]+ * We concatenate all text chunks from all wrb.fr lines.+ */+export function parseStreamResponse(raw: string): string {+ const lines = raw.split("\n");+ const textChunks: string[] = [];++ for (const rawLine of lines) {+ const line = rawLine.trim();+ if (!line || line === ")]}'" || /^\d+$/.test(line)) continue;+ if (!line.includes("wrb.fr")) continue;+ try {+ const arr = JSON.parse(line);+ if (!Array.isArray(arr) || !arr[0] || arr[0][0] !== "wrb.fr") continue;+ const payload = arr[0]?.[2];+ if (typeof payload !== "string") continue;+ const inner = JSON.parse(payload);+ const responseArray = inner?.[4]?.[0]?.[1];+ if (!Array.isArray(responseArray)) continue;+ const chunkText = responseArray+ .filter((c: unknown) => typeof c === "string")+ .join("");+ if (chunkText) textChunks.push(chunkText);+ } catch {+ // Skip unparseable lines (binary chunks, etc.)+ }+ }++ return textChunks.join("");+}++function buildJsonResponse(text: string, model: string): Response {+ const body = {+ id: `chatcmpl-${randomUUID()}`,+ object: "chat.completion",+ created: Math.floor(Date.now() / 1000),+ model,+ choices: [+ {+ index: 0,+ message: { role: "assistant", content: text },+ finish_reason: "stop",+ },+ ],+ usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },+ };+ return new Response(JSON.stringify(body), {+ status: 200,+ headers: { "Content-Type": "application/json" },+ });+}++function buildStreamingResponse(text: string, model: string): Response {+ const encoder = new TextEncoder();+ const id = `chatcmpl-${randomUUID()}`;+ const created = Math.floor(Date.now() / 1000);++ const chunk1 = `data: ${JSON.stringify({+ id,+ object: "chat.completion.chunk",+ created,+ model,+ choices: [{ index: 0, delta: { role: "assistant", content: "" }, finish_reason: null }],+ })}\n\n`;+ const chunk2 = `data: ${JSON.stringify({+ id,+ object: "chat.completion.chunk",+ created,+ model,+ choices: [{ index: 0, delta: { content: text }, finish_reason: null }],+ })}\n\n`;+ const chunk3 = `data: ${JSON.stringify({+ id,+ object: "chat.completion.chunk",+ created,+ model,+ choices: [{ index: 0, delta: {}, finish_reason: "stop" }],+ })}\n\n`;+ const done = "data: [DONE]\n\n";++ const readable = new ReadableStream({+ start(controller) {+ controller.enqueue(encoder.encode(chunk1));+ controller.enqueue(encoder.encode(chunk2));+ controller.enqueue(encoder.encode(chunk3));+ controller.enqueue(encoder.encode(done));+ controller.close();+ },+ });+ return new Response(readable, {+ status: 200,+ headers: {+ "Content-Type": "text/event-stream",+ "Cache-Control": "no-cache",+ Connection: "keep-alive",+ },+ });+}++function readCredentialString(value: unknown): string {+ if (typeof value !== "string") return "";+ const trimmed = value.trim();+ if (!trimmed) return "";+ return trimmed;+}++function readProviderSpecificString(+ providerSpecificData: unknown,+ keys: string[]+): string {+ if (!providerSpecificData || typeof providerSpecificData !== "object") return "";+ const data = providerSpecificData as Record<string, unknown>;+ for (const key of keys) {+ const v = data[key];+ if (typeof v === "string" && v.trim().length > 0) return v.trim();+ }+ return "";+}++function extractTextContent(content: unknown): string {+ if (typeof content === "string") return content.trim();+ if (Array.isArray(content)) {+ return content+ .map((part) => {+ if (typeof part === "string") return part;+ if (part && typeof part === "object" && "text" in part) {+ const text = (part as { text: unknown }).text;+ return typeof text === "string" ? text : "";+ }+ return "";+ })+ .join("")+ .trim();+ }+ return "";+}++function extractCookieValue(cookie: string, name: string): string | null {+ const pairs = cookie.split(";");+ for (const pair of pairs) {+ const [k, ...rest] = pair.trim().split("=");+ if (k === name) return rest.join("=");+ }+ return null;+}++/**+ * Parse a Gemini Business entry URL into base origin + path prefix.+ * Example:+ * entryUrl = "https://business.gemini.google/home/cid/8888a888-b6e0-..."+ * baseOrigin = "https://business.gemini.google"+ * pathPrefix = "/home/cid/8888a888-b6e0-..."+ *+ * Also accepts protocol-less URLs like "business.gemini.google/home/cid/...",+ * which users commonly paste from the browser address bar.+ */+function parseEntryUrl(entryUrl: string): { baseOrigin: string; pathPrefix: string } {+ const fallback = { baseOrigin: "https://business.gemini.google", pathPrefix: "/home" };+ const trimmed = entryUrl.trim();+ if (!trimmed) return fallback;++ // Prepend https:// if the user pasted a protocol-less URL+ const normalized = /^[a-z]+:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;++ try {+ const u = new URL(normalized);+ if (!u.host) return fallback;+ return {+ baseOrigin: `${u.protocol}//${u.host}`,+ pathPrefix: u.pathname.replace(/\/$/, "") || "/",+ };+ } catch {+ return fallback;+ }+}++/**+ * Compute the SAPISID hash auth header value.+ * Format: SAPISIDHASH {epoch_seconds}_{sha1_hash}+ * The hash is sha1(epoch + " " + sapisid + " " + origin).+ * See: https://developers.google.com/youtube/v3/guides/auth/server-side-apps+ */+function computeSapisidHash(sapisid: string, origin: string): string {+ const epoch = Math.floor(Date.now() / 1000);+ const hashInput = `${epoch} ${sapisid} ${origin}`;+ const hash = createHash("sha1").update(hashInput).digest("hex");+ return `SAPISIDHASH ${epoch}_${hash}`;+}diff --git a/open-sse/executors/index.ts b/open-sse/executors/index.tsindex f67c2f63e1..2379eb6e22 100644--- a/open-sse/executors/index.ts+++ b/open-sse/executors/index.ts@@ -19,6 +19,7 @@ import { NineRouterExecutor } from "./ninerouter.ts";import { PerplexityWebExecutor } from "./perplexity-web.ts";import { GrokWebExecutor } from "./grok-web.ts";import { GeminiWebExecutor } from "./gemini-web.ts";+import { GeminiBusinessExecutor } from "./gemini-business.ts";import { ChatGptWebExecutor } from "./chatgpt-web.ts";import { BlackboxWebExecutor } from "./blackbox-web.ts";import { MuseSparkWebExecutor } from "./muse-spark-web.ts";@@ -95,6 +96,8 @@ const executors = {"cw-web": new ClaudeWebWithAutoRefresh(), // Alias"gemini-web": new GeminiWebExecutor(),gweb: new GeminiWebExecutor(), // Alias+ "gemini-business": new GeminiBusinessExecutor(),+ gembiz: new GeminiBusinessExecutor(), // Alias"chatgpt-web": new ChatGptWebExecutor(),"cgpt-web": new ChatGptWebExecutor(), // Alias"blackbox-web": new BlackboxWebExecutor(),diff --git a/src/shared/constants/providers.ts b/src/shared/constants/providers.tsindex b937becf80..402cfad60d 100644--- a/src/shared/constants/providers.ts+++ b/src/shared/constants/providers.ts@@ -587,6 +587,20 @@ export const WEB_COOKIE_PROVIDERS = {"Open chat.qwen.ai, log in, then open DevTools → Application → Local Storage → " +'copy the "token" value (or use tongyi_sso_ticket cookie as Bearer token).',},+ "gemini-business": {+ id: "gemini-business",+ alias: "gembiz",+ name: "Gemini Business (Enterprise)",+ icon: "business_center",+ color: "#4285F4",+ textIcon: "GB",+ website: "https://business.gemini.google",+ hasFree: true,+ freeNote:+ "Free for Google Workspace enterprise accounts — enterprise Gemini models (Pro, Flash, image, video) via direct StreamGenerate HTTP API. No subscription required, just enterprise SSO.",+ authHint:+ "From your enterprise account: open business.gemini.google/home/cid/{your-cid}, then copy __Secure-1PSID and __Secure-1PSIDTS cookies from DevTools → Application → Cookies. Paste as a cookie header below.",+ },};// API Key Providersdiff --git a/src/shared/providers/webSessionCredentials.ts b/src/shared/providers/webSessionCredentials.tsindex f3f159c554..4f9bfec84c 100644--- a/src/shared/providers/webSessionCredentials.ts+++ b/src/shared/providers/webSessionCredentials.ts@@ -38,6 +38,13 @@ export const WEB_SESSION_CREDENTIAL_REQUIREMENTS = {acceptsFullCookieHeader: true,storageKeys: ["cookie", "__Secure-1PSID", "__Secure-1PSIDTS"],},+ "gemini-business": {+ kind: "cookie",+ credentialName: "__Secure-1PSID (optional: __Secure-1PSIDTS)",+ placeholder: "__Secure-1PSID=...; __Secure-1PSIDTS=... (from business.gemini.google)",+ acceptsFullCookieHeader: true,+ storageKeys: ["cookie", "__Secure-1PSID", "__Secure-1PSIDTS"],+ },"perplexity-web": {kind: "cookie",credentialName: "__Secure-next-auth.session-token",diff --git a/tests/unit/gemini-business-provider.test.ts b/tests/unit/gemini-business-provider.test.tsnew file mode 100644index 0000000000..b87d96bda0--- /dev/null+++ b/tests/unit/gemini-business-provider.test.ts@@ -0,0 +1,146 @@+import test from "node:test";+import assert from "node:assert/strict";+import { randomUUID } from "node:crypto";++const { WEB_COOKIE_PROVIDERS } = await import("../../src/shared/constants/providers.ts");+const { WEB_SESSION_CREDENTIAL_REQUIREMENTS } = await import(+ "../../src/shared/providers/webSessionCredentials.ts"+);+const { GeminiBusinessExecutor, parseStreamResponse } = await import(+ "../../open-sse/executors/gemini-business.ts"+);++// ─── Provider metadata ──────────────────────────────────────────────────────++test("Gemini Business is registered in WEB_COOKIE_PROVIDERS with the canonical identity", () => {+ const gem = WEB_COOKIE_PROVIDERS["gemini-business"];+ assert.ok(gem, "WEB_COOKIE_PROVIDERS.gemini-business must be defined");+ assert.equal(gem.id, "gemini-business");+ assert.equal(gem.alias, "gembiz");+ assert.equal(gem.name, "Gemini Business (Enterprise)");+ assert.equal(gem.website, "https://business.gemini.google");+ assert.equal(gem.hasFree, true);+ assert.equal(typeof gem.textIcon, "string");+});++test("Gemini Business credential requirements use __Secure-1PSID cookies", () => {+ const req = WEB_SESSION_CREDENTIAL_REQUIREMENTS["gemini-business"];+ assert.ok(req, "credential requirements must be defined");+ assert.equal(req.kind, "cookie");+ assert.equal(req.acceptsFullCookieHeader, true);+ assert.ok(+ req.storageKeys.includes("__Secure-1PSID"),+ "storageKeys must include __Secure-1PSID"+ );+ assert.ok(+ req.storageKeys.includes("__Secure-1PSIDTS"),+ "storageKeys must include __Secure-1PSIDTS"+ );+ assert.ok(+ req.placeholder.includes("business.gemini.google"),+ "placeholder must reference business.gemini.google"+ );+});++// ─── Executor class ─────────────────────────────────────────────────────────++test("GeminiBusinessExecutor constructs with the correct provider", () => {+ const ex = new GeminiBusinessExecutor();+ assert.equal((ex as unknown as { provider: string }).provider, "gemini-business");+});++test("GeminiBusinessExecutor.execute returns 401 when no cookies are provided", async () => {+ const ex = new GeminiBusinessExecutor();+ const result = await ex.execute({+ model: "gemini-2.5-pro",+ body: { messages: [{ role: "user", content: "hello" }] },+ stream: false,+ credentials: {},+ signal: new AbortController().signal,+ });+ assert.equal(result.response.status, 401);+ const text = await result.response.text();+ assert.ok(text.includes("Missing Gemini Business cookies"));+});++test("GeminiBusinessExecutor.execute returns 400 when no user message is provided", async () => {+ const ex = new GeminiBusinessExecutor();+ const result = await ex.execute({+ model: "gemini-2.5-pro",+ body: { messages: [] },+ stream: false,+ credentials: { apiKey: "__Secure-1PSID=fake; __Secure-1PSIDTS=fake" },+ signal: new AbortController().signal,+ });+ assert.equal(result.response.status, 400);+ const text = await result.response.text();+ assert.ok(text.includes("No user message found"));+});++// ─── parseStreamResponse ────────────────────────────────────────────────────++test("parseStreamResponse extracts text from a single wrb.fr chunk", () => {+ // Real format per gemini-web2api.py: inner[4][0][1] is the text array.+ // inner[4][0] is a 2-element pair [metadata, text_list].+ const inner = new Array(80).fill(null);+ inner[4] = [[null, ["Hello, world!"]]];+ const innerStr = JSON.stringify(inner);+ const raw = `[["wrb.fr", null, ${JSON.stringify(innerStr)}]]`;+ const result = parseStreamResponse(raw);+ assert.equal(result, "Hello, world!");+});++test("parseStreamResponse concatenates text from multiple wrb.fr chunks", () => {+ const makeChunk = (text: string) => {+ const inner = new Array(80).fill(null);+ inner[4] = [[null, [text]]];+ return `[["wrb.fr", null, ${JSON.stringify(JSON.stringify(inner))}]]`;+ };+ const raw = `)]}'\n10\n${makeChunk("First ")}\n5\n${makeChunk("chunk")}`;+ const result = parseStreamResponse(raw);+ assert.equal(result, "First chunk");+});++test("parseStreamResponse filters out non-string entries and ignores text-metadata slot", () => {+ // Slot 0 of inner[4][0] is metadata (often null/empty), slot 1 is the text list.+ const inner = new Array(80).fill(null);+ inner[4] = [[null, ["clean ", 123, null, "text"]]];+ const innerStr = JSON.stringify(inner);+ const raw = `[["wrb.fr", null, ${JSON.stringify(innerStr)}]]`;+ const result = parseStreamResponse(raw);+ assert.equal(result, "clean text");+});++test("parseStreamResponse returns empty string for malformed response", () => {+ const result = parseStreamResponse(")]}'\n42\nnot json");+ assert.equal(result, "");+});++test("parseStreamResponse returns empty string for empty response", () => {+ const result = parseStreamResponse("");+ assert.equal(result, "");+});++test("parseStreamResponse returns empty string for non-wrb.fr lines", () => {+ const raw = `)]}'\n10\n[["other.rpc", null, "irrelevant"]]`;+ const result = parseStreamResponse(raw);+ assert.equal(result, "");+});++test("parseStreamResponse handles inner array with empty text", () => {+ const inner = new Array(80).fill(null);+ inner[4] = [[""]];+ const innerStr = JSON.stringify(inner);+ const raw = `[["wrb.fr", null, ${JSON.stringify(innerStr)}]]`;+ const result = parseStreamResponse(raw);+ assert.equal(result, "");+});++test("parseStreamResponse handles real Gemini response format with multiple inner array slots", () => {+ const inner = new Array(80).fill(null);+ inner[4] = [[null, ["This is the real format."]]];+ const innerStr = JSON.stringify(inner);+ const raw = `[["wrb.fr", null, ${JSON.stringify(innerStr)}]]`;+ const result = parseStreamResponse(raw);+ assert.equal(result, "This is the real format.");+});