@fudrouter/fsrouter 0.6.64 → 0.6.66

package/open-sse/executors/huggingchat.js

@@ -0,0 +1,467 @@
+import {
+  BaseExecutor,
+  mergeAbortSignals,
+  mergeUpstreamExtraHeaders
+} from "./base.ts";
+import { FETCH_TIMEOUT_MS } from "../config/constants.ts";
+import { buildErrorBody, sanitizeErrorMessage } from "../utils/error.js";
+import { normalizeSessionCookieHeader } from '../../dist/lib/providers/webCookieAuth.js';
+import { streamJsonlToOpenAi, readJsonlResponse } from "./huggingchat/jsonlStream.ts";
+const HUGGINGFACE_BASE = "https://huggingface.co";
+const CONVERSATION_URL = `${HUGGINGFACE_BASE}/chat/conversation`;
+const API_CONVERSATIONS_URL = `${HUGGINGFACE_BASE}/chat/api/v2/conversations`;
+const DEFAULT_COOKIE_NAME = "hf-chat";
+const USER_AGENT = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36";
+const DEFAULT_MODEL = "baidu/ERNIE-4.5-VL-424B-A47B-Base-PT";
+function normalizeHuggingChatCookieHeader(apiKey) {
+  return normalizeSessionCookieHeader(apiKey, DEFAULT_COOKIE_NAME);
+}
+function isEncryptedCredentialBlob(value) {
+  return typeof value === "string" && value.trim().startsWith("enc:v1:");
+}
+function extractTextFromContent(content) {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => {
+    if (!part || typeof part !== "object") return "";
+    const item = part;
+    if (item.type === "text" && typeof item.text === "string") return item.text;
+    if (item.type === "input_text" && typeof item.text === "string") return item.text;
+    return "";
+  }).filter((p) => p.trim().length > 0).join("\n").trim();
+}
+function buildConversationPrompt(messages) {
+  const systemParts = [];
+  const conversationParts = [];
+  for (const msg of messages) {
+    const role = String(msg.role || "user");
+    const text = extractTextFromContent(msg.content);
+    if (!text) continue;
+    if (role === "system" || role === "developer") {
+      systemParts.push(text);
+    } else if (role === "user" || role === "assistant") {
+      conversationParts.push({ role, content: text });
+    }
+  }
+  if (conversationParts.length === 0) {
+    return { inputs: systemParts.join("\n\n"), systemPrompt: null };
+  }
+  if (conversationParts.length === 1 && conversationParts[0].role === "user") {
+    return {
+      inputs: conversationParts[0].content,
+      systemPrompt: systemParts.length > 0 ? systemParts.join("\n\n") : null
+    };
+  }
+  const lines = [];
+  for (const part of conversationParts) {
+    const label = part.role === "user" ? "User" : "Assistant";
+    lines.push(`${label}: ${part.content}`);
+  }
+  lines.push("Assistant:");
+  return {
+    inputs: lines.join("\n\n"),
+    systemPrompt: systemParts.length > 0 ? systemParts.join("\n\n") : null
+  };
+}
+function estimateTokens(text) {
+  return Math.max(1, Math.ceil((text || "").length / 4));
+}
+function getLocalTimezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+async function readUpstreamErrorDetails(response) {
+  const contentType = response.headers.get("content-type") || "";
+  const text = await response.text().catch(() => "");
+  if (!text) return { message: null, details: null };
+  if (contentType.includes("json")) {
+    try {
+      const parsed = JSON.parse(text);
+      const message = typeof parsed.message === "string" ? parsed.message : typeof parsed.error === "string" ? parsed.error : parsed.error && typeof parsed.error === "object" && typeof parsed.error.message === "string" ? String(parsed.error.message) : null;
+      return { message: message ? sanitizeErrorMessage(message) : null, details: parsed };
+    } catch {
+    }
+  }
+  return { message: sanitizeErrorMessage(text), details: { body: text } };
+}
+function unwrapSuperjsonPayload(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const record = value;
+  return record.json && typeof record.json === "object" ? record.json : value;
+}
+function extractInitialParentMessageId(value) {
+  const payload = unwrapSuperjsonPayload(value);
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return null;
+  const record = payload;
+  if (typeof record.rootMessageId === "string" && record.rootMessageId.trim()) {
+    return record.rootMessageId;
+  }
+  const messages = Array.isArray(record.messages) ? record.messages : [];
+  const lastMessage = messages.at(-1);
+  if (lastMessage && typeof lastMessage === "object") {
+    const id = lastMessage.id;
+    if (typeof id === "string" && id.trim()) return id;
+  }
+  return null;
+}
+async function fetchInitialParentMessageId(conversationId, headers, signal) {
+  const res = await fetch(`${API_CONVERSATIONS_URL}/${conversationId}`, {
+    method: "GET",
+    headers,
+    signal
+  });
+  if (!res.ok) return null;
+  const text = await res.text().catch(() => "");
+  if (!text) return null;
+  try {
+    return extractInitialParentMessageId(JSON.parse(text));
+  } catch {
+    return null;
+  }
+}
+function splitCombinedSetCookieHeader(header) {
+  return header.split(/,(?=\s*[^;,=\s]+=)/).map((value) => value.trim()).filter(Boolean);
+}
+function getSetCookieHeaders(headers) {
+  const maybeGetSetCookie = headers.getSetCookie;
+  if (typeof maybeGetSetCookie === "function") {
+    return maybeGetSetCookie.call(headers).filter(Boolean);
+  }
+  const combined = headers.get("set-cookie");
+  return combined ? splitCombinedSetCookieHeader(combined) : [];
+}
+function parseSetCookiePair(setCookie) {
+  const pair = setCookie.split(";", 1)[0]?.trim() || "";
+  const eq = pair.indexOf("=");
+  if (eq <= 0) return null;
+  return { name: pair.slice(0, eq).trim(), value: pair.slice(eq + 1) };
+}
+function mergeCookieHeaderWithSetCookie(cookieHeader, setCookieHeaders) {
+  const cookieMap = /* @__PURE__ */ new Map();
+  for (const part of cookieHeader.split(";")) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq <= 0) continue;
+    cookieMap.set(trimmed.slice(0, eq).trim(), trimmed.slice(eq + 1));
+  }
+  for (const setCookie of setCookieHeaders) {
+    const parsed = parseSetCookiePair(setCookie);
+    if (!parsed || !parsed.value) continue;
+    cookieMap.set(parsed.name, parsed.value);
+  }
+  return [...cookieMap.entries()].map(([name, value]) => `${name}=${value}`).join("; ");
+}
+class HuggingChatExecutor extends BaseExecutor {
+  constructor() {
+    super("huggingchat", { id: "huggingchat", baseUrl: HUGGINGFACE_BASE });
+  }
+  async execute(input) {
+    const { model, body, stream, credentials, signal, log, upstreamExtraHeaders } = input;
+    const messages = body.messages;
+    if (!messages || !Array.isArray(messages) || messages.length === 0) {
+      return {
+        response: new Response(
+          JSON.stringify({
+            error: { message: "Missing or empty messages array", type: "invalid_request" }
+          }),
+          { status: 400, headers: { "Content-Type": "application/json" } }
+        ),
+        url: CONVERSATION_URL,
+        headers: {},
+        transformedBody: body
+      };
+    }
+    if (isEncryptedCredentialBlob(credentials.apiKey)) {
+      return {
+        response: new Response(
+          JSON.stringify({
+            error: {
+              message: "HuggingChat credentials are encrypted but STORAGE_ENCRYPTION_KEY is not loaded. Restore the encryption key or re-save the HuggingChat cookie.",
+              type: "auth_error"
+            }
+          }),
+          { status: 401, headers: { "Content-Type": "application/json" } }
+        ),
+        url: CONVERSATION_URL,
+        headers: {},
+        transformedBody: body
+      };
+    }
+    let cookieHeader = normalizeHuggingChatCookieHeader(credentials.apiKey || "");
+    if (!cookieHeader) {
+      return {
+        response: new Response(
+          JSON.stringify({
+            error: {
+              message: "HuggingChat requires a session cookie. Log in to huggingface.co/chat, open DevTools > Application > Cookies, and copy the hf-chat cookie value.",
+              type: "auth_error"
+            }
+          }),
+          { status: 401, headers: { "Content-Type": "application/json" } }
+        ),
+        url: CONVERSATION_URL,
+        headers: {},
+        transformedBody: body
+      };
+    }
+    const resolvedModel = model || DEFAULT_MODEL;
+    const { inputs, systemPrompt } = buildConversationPrompt(messages);
+    if (!inputs.trim()) {
+      return {
+        response: new Response(
+          JSON.stringify({
+            error: { message: "Empty prompt after processing messages", type: "invalid_request" }
+          }),
+          { status: 400, headers: { "Content-Type": "application/json" } }
+        ),
+        url: CONVERSATION_URL,
+        headers: {},
+        transformedBody: body
+      };
+    }
+    const baseHeaders = {
+      Cookie: cookieHeader,
+      "User-Agent": USER_AGENT,
+      Origin: HUGGINGFACE_BASE,
+      Referer: `${HUGGINGFACE_BASE}/chat/`
+    };
+    const timeoutSignal = AbortSignal.timeout(FETCH_TIMEOUT_MS);
+    const combinedSignal = signal ? mergeAbortSignals(signal, timeoutSignal) : timeoutSignal;
+    let conversationId;
+    try {
+      const createBody = { model: resolvedModel };
+      if (systemPrompt) createBody.preprompt = systemPrompt;
+      const createRes = await fetch(CONVERSATION_URL, {
+        method: "POST",
+        headers: { ...baseHeaders, "Content-Type": "application/json" },
+        body: JSON.stringify(createBody),
+        signal: combinedSignal
+      });
+      if (!createRes.ok) {
+        const status = createRes.status;
+        const upstreamError = await readUpstreamErrorDetails(createRes);
+        let message = `HuggingChat conversation creation failed (HTTP ${status})`;
+        if (status === 401 || status === 403) {
+          message = "HuggingChat auth failed -- your hf-chat session cookie may be missing or expired. Log in to huggingface.co/chat and re-paste your cookie.";
+        } else if (status === 429) {
+          message = "HuggingChat rate limited. Wait a moment and retry.";
+        }
+        if (upstreamError.message) {
+          message = `${message}: ${upstreamError.message}`;
+        }
+        return {
+          response: new Response(
+            JSON.stringify(buildErrorBody(status, message, upstreamError.details)),
+            { status, headers: { "Content-Type": "application/json" } }
+          ),
+          url: CONVERSATION_URL,
+          headers: baseHeaders,
+          transformedBody: body
+        };
+      }
+      const createData = await createRes.json();
+      conversationId = createData.conversationId;
+      const createSetCookieHeaders = getSetCookieHeaders(createRes.headers);
+      cookieHeader = mergeCookieHeaderWithSetCookie(cookieHeader, createSetCookieHeaders);
+      baseHeaders.Cookie = cookieHeader;
+      if (!conversationId) {
+        return {
+          response: new Response(
+            JSON.stringify({
+              error: {
+                message: "HuggingChat did not return a conversationId",
+                type: "upstream_error"
+              }
+            }),
+            { status: 502, headers: { "Content-Type": "application/json" } }
+          ),
+          url: CONVERSATION_URL,
+          headers: baseHeaders,
+          transformedBody: body
+        };
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log?.error?.("HUGGINGCHAT", `Conversation creation failed: ${message}`);
+      return {
+        response: new Response(
+          JSON.stringify({
+            error: { message: `HuggingChat connection failed: ${message}`, type: "upstream_error" }
+          }),
+          { status: 502, headers: { "Content-Type": "application/json" } }
+        ),
+        url: CONVERSATION_URL,
+        headers: baseHeaders,
+        transformedBody: body
+      };
+    }
+    const parentMessageId = await fetchInitialParentMessageId(
+      conversationId,
+      baseHeaders,
+      combinedSignal
+    );
+    if (!parentMessageId) {
+      return {
+        response: new Response(
+          JSON.stringify({
+            error: {
+              message: "HuggingChat did not return an initial parent message id",
+              type: "upstream_error"
+            }
+          }),
+          { status: 502, headers: { "Content-Type": "application/json" } }
+        ),
+        url: `${API_CONVERSATIONS_URL}/${conversationId}`,
+        headers: baseHeaders,
+        transformedBody: body
+      };
+    }
+    const messageUrl = `${CONVERSATION_URL}/${conversationId}`;
+    const formData = new FormData();
+    const sendDataPayload = {
+      inputs,
+      is_retry: false,
+      is_continue: false,
+      generationId: crypto.randomUUID(),
+      selectedMcpServerNames: [],
+      selectedMcpServers: [],
+      timezone: getLocalTimezone(),
+      id: parentMessageId
+    };
+    formData.append("data", JSON.stringify(sendDataPayload));
+    mergeUpstreamExtraHeaders(baseHeaders, upstreamExtraHeaders);
+    let upstreamResponse;
+    try {
+      upstreamResponse = await fetch(messageUrl, {
+        method: "POST",
+        headers: baseHeaders,
+        body: formData,
+        signal: combinedSignal
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log?.error?.("HUGGINGCHAT", `Message send failed: ${message}`);
+      return {
+        response: new Response(
+          JSON.stringify({
+            error: { message: `HuggingChat connection failed: ${message}`, type: "upstream_error" }
+          }),
+          { status: 502, headers: { "Content-Type": "application/json" } }
+        ),
+        url: messageUrl,
+        headers: baseHeaders,
+        transformedBody: sendDataPayload
+      };
+    }
+    if (!upstreamResponse.ok) {
+      const status = upstreamResponse.status;
+      const upstreamError = await readUpstreamErrorDetails(upstreamResponse);
+      let message = `HuggingChat returned HTTP ${status}`;
+      if (status === 401 || status === 403) {
+        message = "HuggingChat auth failed -- session cookie may be expired.";
+      } else if (status === 429) {
+        message = "HuggingChat rate limited. Wait a moment and retry.";
+      } else if (status === 404) {
+        message = `HuggingChat model not found: ${resolvedModel}. Check the model ID.`;
+      }
+      if (upstreamError.message) {
+        message = `${message}: ${upstreamError.message}`;
+      }
+      return {
+        response: new Response(
+          JSON.stringify(buildErrorBody(status, message, upstreamError.details)),
+          { status, headers: { "Content-Type": "application/json" } }
+        ),
+        url: messageUrl,
+        headers: baseHeaders,
+        transformedBody: sendDataPayload
+      };
+    }
+    if (!upstreamResponse.body) {
+      return {
+        response: new Response(
+          JSON.stringify({
+            error: { message: "HuggingChat returned empty response body", type: "upstream_error" }
+          }),
+          { status: 502, headers: { "Content-Type": "application/json" } }
+        ),
+        url: messageUrl,
+        headers: baseHeaders,
+        transformedBody: sendDataPayload
+      };
+    }
+    const id = `chatcmpl-huggingchat-${crypto.randomUUID().slice(0, 12)}`;
+    const created = Math.floor(Date.now() / 1e3);
+    if (stream) {
+      const encoder = new TextEncoder();
+      const jsonlStream = streamJsonlToOpenAi(
+        upstreamResponse.body,
+        resolvedModel,
+        id,
+        created,
+        signal
+      );
+      const sseStream = new ReadableStream({
+        async start(controller) {
+          try {
+            for await (const chunk of jsonlStream) {
+              controller.enqueue(encoder.encode(chunk));
+            }
+          } catch (err) {
+            log?.error?.("HUGGINGCHAT", `Stream error: ${err}`);
+          } finally {
+            controller.close();
+          }
+        }
+      });
+      return {
+        response: new Response(sseStream, {
+          status: 200,
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            "X-Accel-Buffering": "no"
+          }
+        }),
+        url: messageUrl,
+        headers: baseHeaders,
+        transformedBody: sendDataPayload
+      };
+    }
+    const fullText = await readJsonlResponse(upstreamResponse.body, signal);
+    const completionTokens = estimateTokens(fullText);
+    return {
+      response: new Response(
+        JSON.stringify({
+          id,
+          object: "chat.completion",
+          created,
+          model: resolvedModel,
+          choices: [
+            {
+              index: 0,
+              message: { role: "assistant", content: fullText },
+              finish_reason: "stop"
+            }
+          ],
+          usage: {
+            prompt_tokens: estimateTokens(inputs),
+            completion_tokens: completionTokens,
+            total_tokens: estimateTokens(inputs) + completionTokens
+          }
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } }
+      ),
+      url: messageUrl,
+      headers: baseHeaders,
+      transformedBody: sendDataPayload
+    };
+  }
+}
+export {
+  HuggingChatExecutor
+};

package/open-sse/executors/iflow.js

@@ -0,0 +1,108 @@
+import crypto from "crypto";
+import { BaseExecutor } from "./base.js";
+import { PROVIDERS } from "../config/providers.js";
+
+/**
+ * IFlowExecutor - Executor for iFlow API with HMAC-SHA256 signature
+ */
+export class IFlowExecutor extends BaseExecutor {
+  constructor() {
+    super("iflow", PROVIDERS.iflow);
+  }
+
+  /**
+   * Generate UUID v4
+   * @returns {string} UUID v4 string
+   */
+  generateUUID() {
+    return crypto.randomUUID();
+  }
+
+  /**
+   * Create iFlow signature using HMAC-SHA256
+   * @param {string} userAgent - User agent string
+   * @param {string} sessionID - Session ID
+   * @param {number} timestamp - Unix timestamp in milliseconds
+   * @param {string} apiKey - API key for signing
+   * @returns {string} Hex-encoded signature
+   */
+  createIFlowSignature(userAgent, sessionID, timestamp, apiKey) {
+    if (!apiKey) return "";
+    const payload = `${userAgent}:${sessionID}:${timestamp}`;
+    const hmac = crypto.createHmac("sha256", apiKey);
+    hmac.update(payload);
+    return hmac.digest("hex");
+  }
+
+  /**
+   * Build headers with iFlow-specific signature
+   * @param {object} credentials - Provider credentials
+   * @param {boolean} stream - Whether streaming is enabled
+   * @returns {object} Headers object
+   */
+  buildHeaders(credentials, stream = true) {
+    // Generate session ID and timestamp
+    const sessionID = `session-${this.generateUUID()}`;
+    const timestamp = Date.now();
+
+    // Get user agent from config
+    const userAgent = this.config.headers["User-Agent"] || "iFlow-Cli";
+
+    // Get API key (prefer apiKey, fallback to accessToken)
+    const apiKey = credentials.apiKey || credentials.accessToken || "";
+
+    // Create signature
+    const signature = this.createIFlowSignature(userAgent, sessionID, timestamp, apiKey);
+
+    // Build headers
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.headers,
+      "session-id": sessionID,
+      "x-iflow-timestamp": timestamp.toString(),
+      "x-iflow-signature": signature
+    };
+
+    // Add authorization
+    if (credentials.apiKey) {
+      headers["Authorization"] = `Bearer ${credentials.apiKey}`;
+    }
+
+    // Add streaming header
+    if (stream) {
+      headers["Accept"] = "text/event-stream";
+    }
+
+    return headers;
+  }
+
+  /**
+   * Build URL for iFlow API
+   * @param {string} model - Model name
+   * @param {boolean} stream - Whether streaming is enabled
+   * @param {number} urlIndex - URL index for fallback
+   * @param {object} credentials - Provider credentials
+   * @returns {string} API URL
+   */
+  buildUrl(model, stream, urlIndex = 0, credentials = null) {
+    return this.config.baseUrl;
+  }
+
+  /**
+   * Transform request body - inject stream_options for usage data
+   * @param {string} model - Model name
+   * @param {object} body - Request body
+   * @param {boolean} stream - Whether streaming is enabled
+   * @param {object} credentials - Provider credentials
+   * @returns {object} Transformed body
+   */
+  transformRequest(model, body, stream, credentials) {
+    // Inject stream_options for streaming requests to get usage data
+    if (stream && body.messages && !body.stream_options) {
+      body.stream_options = { include_usage: true };
+    }
+    return body;
+  }
+}
+
+export default IFlowExecutor;

package/open-sse/executors/index.js

@@ -0,0 +1,78 @@
+import { AntigravityExecutor } from "./antigravity.js";
+import { AzureExecutor } from "./azure.js";
+import { GeminiCLIExecutor } from "./gemini-cli.js";
+import { GithubExecutor } from "./github.js";
+import { IFlowExecutor } from "./iflow.js";
+import { QoderExecutor } from "./qoder.js";
+import { KiroExecutor } from "./kiro.js";
+import { CodexExecutor } from "./codex.js";
+import { CursorExecutor } from "./cursor.js";
+import { VertexExecutor } from "./vertex.js";
+import { QwenExecutor } from "./qwen.js";
+import { OpenCodeExecutor } from "./opencode.js";
+import { OpenCodeGoExecutor } from "./opencode-go.js";
+import { GrokWebExecutor } from "./grok-web.js";
+import { GrokCliExecutor } from "./grok-cli.js";
+import { PerplexityWebExecutor } from "./perplexity-web.js";
+import { OllamaLocalExecutor } from "./ollama-local.js";
+import { CommandCodeExecutor } from "./commandcode.js";
+import { XiaomiTokenplanExecutor } from "./xiaomi-tokenplan.js";
+import { DefaultExecutor } from "./default.js";
+
+const executors = {
+  antigravity: new AntigravityExecutor(),
+  azure: new AzureExecutor(),
+  "gemini-cli": new GeminiCLIExecutor(),
+  github: new GithubExecutor(),
+  iflow: new IFlowExecutor(),
+  qoder: new QoderExecutor(),
+  kiro: new KiroExecutor(),
+  codex: new CodexExecutor(),
+  cursor: new CursorExecutor(),
+  cu: new CursorExecutor(), // Alias for cursor
+  vertex: new VertexExecutor("vertex"),
+  "vertex-partner": new VertexExecutor("vertex-partner"),
+  qwen: new QwenExecutor(),
+  opencode: new OpenCodeExecutor(),
+  "opencode-go": new OpenCodeGoExecutor(),
+  "grok-web": new GrokWebExecutor(),
+  "grok-cli": new GrokCliExecutor(),
+  "perplexity-web": new PerplexityWebExecutor(),
+  "ollama-local": new OllamaLocalExecutor(),
+  commandcode: new CommandCodeExecutor(),
+  "xiaomi-tokenplan": new XiaomiTokenplanExecutor(),
+};
+
+const defaultCache = new Map();
+
+export function getExecutor(provider) {
+  if (executors[provider]) return executors[provider];
+  if (!defaultCache.has(provider)) defaultCache.set(provider, new DefaultExecutor(provider));
+  return defaultCache.get(provider);
+}
+
+export function hasSpecializedExecutor(provider) {
+  return !!executors[provider];
+}
+
+export { BaseExecutor } from "./base.js";
+export { AntigravityExecutor } from "./antigravity.js";
+export { AzureExecutor } from "./azure.js";
+export { GeminiCLIExecutor } from "./gemini-cli.js";
+export { GithubExecutor } from "./github.js";
+export { IFlowExecutor } from "./iflow.js";
+export { QoderExecutor } from "./qoder.js";
+export { KiroExecutor } from "./kiro.js";
+export { CodexExecutor } from "./codex.js";
+export { CursorExecutor } from "./cursor.js";
+export { VertexExecutor } from "./vertex.js";
+export { DefaultExecutor } from "./default.js";
+export { QwenExecutor } from "./qwen.js";
+export { OpenCodeExecutor } from "./opencode.js";
+export { OpenCodeGoExecutor } from "./opencode-go.js";
+export { GrokWebExecutor } from "./grok-web.js";
+export { GrokCliExecutor } from "./grok-cli.js";
+export { PerplexityWebExecutor } from "./perplexity-web.js";
+export { OllamaLocalExecutor } from "./ollama-local.js";
+export { CommandCodeExecutor } from "./commandcode.js";
+export { XiaomiTokenplanExecutor } from "./xiaomi-tokenplan.js";