@fudrouter/fsrouter 0.6.59 → 0.6.61

package/open-sse/executors/huggingchat.js

@@ -1,467 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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";