@ynhcj/xiaoyi 0.0.1-beta

package/dist/channel.js

@@ -0,0 +1,354 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xiaoyiPlugin = void 0;
+const runtime_js_1 = require("./runtime.js");
+const onboarding_js_1 = require("./onboarding.js");
+const session_manager_js_1 = require("./xy-tools/session-manager.js");
+// Special marker for default push delivery when no target is specified (cron/announce mode)
+const DEFAULT_PUSH_MARKER = "default";
+/**
+ * Track if message handlers have been registered to prevent duplicate registrations
+ * when startAccount() is called multiple times due to auto-restart attempts
+ */
+let handlersRegistered = false;
+/**
+ * XiaoYi Channel Plugin
+ * Implements OpenClaw ChannelPlugin interface for XiaoYi A2A protocol
+ * Single account mode only
+ */
+exports.xiaoyiPlugin = {
+    id: "xiaoyi",
+    meta: {
+        id: "xiaoyi",
+        label: "XiaoYi",
+        selectionLabel: "XiaoYi (小艺)",
+        docsPath: "/channels/xiaoyi",
+        blurb: "小艺 A2A 协议支持，通过 WebSocket 连接。",
+        aliases: ["xiaoyi"],
+    },
+    capabilities: {
+        chatTypes: ["direct"],
+        polls: false,
+        reactions: false,
+        threads: false,
+        media: true,
+        nativeCommands: false,
+    },
+    /**
+     * Config schema for UI form rendering
+     */
+    configSchema: {
+        schema: {
+            type: "object",
+            properties: {
+                enabled: {
+                    type: "boolean",
+                    default: false,
+                    description: "Enable XiaoYi channel",
+                },
+                wsUrl1: {
+                    type: "string",
+                    default: "wss://hag.cloud.huawei.com/openclaw/v1/ws/link",
+                    description: "Primary WebSocket server URL",
+                },
+                wsUrl2: {
+                    type: "string",
+                    default: "wss://116.63.174.231/openclaw/v1/ws/link",
+                    description: "Secondary WebSocket server URL",
+                },
+                ak: {
+                    type: "string",
+                    description: "Access Key",
+                },
+                sk: {
+                    type: "string",
+                    description: "Secret Key",
+                },
+                agentId: {
+                    type: "string",
+                    description: "Agent ID",
+                },
+                debug: {
+                    type: "boolean",
+                    default: false,
+                    description: "Enable debug logging",
+                },
+                apiId: {
+                    type: "string",
+                    default: "",
+                    description: "API ID for push notifications",
+                },
+                pushId: {
+                    type: "string",
+                    default: "",
+                    description: "Push ID for push notifications",
+                },
+                taskTimeoutMs: {
+                    type: "number",
+                    default: 3600000,
+                    description: "Task timeout in milliseconds (default: 1 hour)",
+                },
+            },
+        },
+    },
+    onboarding: onboarding_js_1.xiaoyiOnboardingAdapter,
+    /**
+     * Config adapter - single account mode
+     */
+    config: {
+        listAccountIds: (cfg) => {
+            const channelConfig = cfg?.channels?.xiaoyi;
+            if (!channelConfig || !channelConfig.enabled) {
+                return [];
+            }
+            // Single account mode: always return "default"
+            return ["default"];
+        },
+        resolveAccount: (cfg, accountId) => {
+            // Single account mode: always use "default"
+            const resolvedAccountId = "default";
+            // Access channel config from cfg.channels.xiaoyi
+            const channelConfig = cfg?.channels?.xiaoyi;
+            // If channel is not configured yet, return empty config
+            if (!channelConfig) {
+                return {
+                    accountId: resolvedAccountId,
+                    config: {
+                        enabled: false,
+                        wsUrl: "",
+                        wsUrl1: "",
+                        wsUrl2: "",
+                        ak: "",
+                        sk: "",
+                        agentId: "",
+                    },
+                    enabled: false,
+                };
+            }
+            return {
+                accountId: resolvedAccountId,
+                config: channelConfig,
+                enabled: channelConfig.enabled !== false,
+            };
+        },
+        defaultAccountId: (cfg) => {
+            const channelConfig = cfg?.channels?.xiaoyi;
+            if (!channelConfig || !channelConfig.enabled) {
+                return undefined;
+            }
+            // Single account mode: always return "default"
+            return "default";
+        },
+        isConfigured: (account, cfg) => {
+            // Safely check if all required fields are present and non-empty
+            if (!account || !account.config) {
+                return false;
+            }
+            const config = account.config;
+            // Check each field is a string and has content after trimming
+            // Note: wsUrl1/wsUrl2 are optional (defaults will be used if not provided)
+            const hasAk = typeof config.ak === 'string' && config.ak.trim().length > 0;
+            const hasSk = typeof config.sk === 'string' && config.sk.trim().length > 0;
+            const hasAgentId = typeof config.agentId === 'string' && config.agentId.trim().length > 0;
+            return hasAk && hasSk && hasAgentId;
+        },
+        isEnabled: (account, cfg) => {
+            return account?.enabled !== false;
+        },
+        disabledReason: (account, cfg) => {
+            return "Channel is disabled in configuration";
+        },
+        unconfiguredReason: (account, cfg) => {
+            return "Missing required configuration: ak, sk, or agentId (wsUrl1/wsUrl2 are optional, defaults will be used)";
+        },
+        describeAccount: (account, cfg) => ({
+            accountId: account.accountId,
+            name: 'XiaoYi',
+            enabled: account.enabled,
+            configured: Boolean(account.config?.ak && account.config?.sk && account.config?.agentId),
+        }),
+    },
+    /**
+     * Gateway adapter - manage connections
+     * Using xy-monitor for message handling (xy_channel architecture)
+     */
+    gateway: {
+        startAccount: async (ctx) => {
+            console.log("XiaoYi: startAccount() called - START");
+            const { monitorXYProvider } = await Promise.resolve().then(() => __importStar(require("./xy-monitor.js")));
+            const account = ctx.account;
+            const config = ctx.cfg;
+            console.log(`[xiaoyi] Starting xiaoyi channel with xy_monitor architecture`);
+            console.log(`[xiaoyi] Account ID: ${account.accountId}`);
+            console.log(`[xiaoyi] Agent ID: ${account.config.agentId}`);
+            return monitorXYProvider({
+                config: config,
+                runtime: ctx.runtime,
+                abortSignal: ctx.abortSignal,
+                accountId: account.accountId,
+                setStatus: ctx.setStatus,
+            });
+        },
+        stopAccount: async (ctx) => {
+            const runtime = (0, runtime_js_1.getXiaoYiRuntime)();
+            runtime.stop();
+        },
+    },
+    /**
+     * Outbound adapter - send messages via push
+     */
+    outbound: {
+        deliveryMode: "direct",
+        textChunkLimit: 4000,
+        resolveTarget: ({ cfg, to, accountId, mode }) => {
+            if (!to || to.trim() === "") {
+                console.log(`[xiaoyi.resolveTarget] No target specified, using default push marker`);
+                return { ok: true, to: DEFAULT_PUSH_MARKER };
+            }
+            const trimmedTo = to.trim();
+            if (!trimmedTo.includes("::")) {
+                console.log(`[xiaoyi.resolveTarget] Target "${trimmedTo}" missing taskId, looking up session context`);
+                const sessionContext = (0, session_manager_js_1.getLatestSessionContext)();
+                if (sessionContext && sessionContext.sessionId === trimmedTo) {
+                    const enhancedTarget = `${trimmedTo}::${sessionContext.taskId}`;
+                    console.log(`[xiaoyi.resolveTarget] Enhanced target: ${enhancedTarget}`);
+                    return { ok: true, to: enhancedTarget };
+                }
+                console.log(`[xiaoyi.resolveTarget] Could not find matching session context for "${trimmedTo}"`);
+            }
+            return { ok: true, to: trimmedTo };
+        },
+        sendText: async (ctx) => {
+            const { cfg, to, text, accountId } = ctx;
+            console.log(`[xiaoyi.sendText] Called with: to=${to}, textLength=${text?.length || 0}`);
+            const { resolveXYConfig } = await Promise.resolve().then(() => __importStar(require("./xy-config.js")));
+            const { XiaoYiPushService } = await Promise.resolve().then(() => __importStar(require("./push.js")));
+            const { configManager } = await Promise.resolve().then(() => __importStar(require("./xy-utils/config-manager.js")));
+            const config = { ...resolveXYConfig(cfg) };
+            // Resolve actual target (strip taskId portion if present)
+            let actualTo = to;
+            if (to === DEFAULT_PUSH_MARKER) {
+                actualTo = config.defaultSessionId || "";
+            }
+            else if (to.includes("::")) {
+                actualTo = to.split("::")[0];
+            }
+            // Override pushId with dynamic per-session pushId if available
+            const dynamicPushId = configManager.getPushId(actualTo);
+            if (dynamicPushId) {
+                config.pushId = dynamicPushId;
+            }
+            const pushService = new XiaoYiPushService(config);
+            // Extract title (first line, up to 57 chars)
+            const title = text.split("\n")[0].slice(0, 57);
+            // Truncate content to 1000 chars
+            const pushText = text.length > 1000 ? text.slice(0, 1000) : text;
+            await pushService.sendPush(pushText, title);
+            console.log(`[xiaoyi.sendText] Push sent successfully`);
+            return {
+                channel: "xiaoyi",
+                messageId: Date.now().toString(),
+                chatId: actualTo,
+            };
+        },
+        sendMedia: async (ctx) => {
+            throw new Error("暂不支持文件回传");
+        },
+    },
+    /**
+     * Messaging adapter - normalize targets
+     * In new openclaw version, normalizeTarget receives a string and returns a normalized string
+     */
+    messaging: {
+        normalizeTarget: (raw) => {
+            // For XiaoYi, we use sessionId as the target
+            // The raw input is already the normalized target (sessionId)
+            return raw;
+        },
+    },
+    /**
+     * Status adapter - health checks
+     * Using buildAccountSnapshot for compatibility with new openclaw version
+     */
+    status: {
+        buildAccountSnapshot: async (params) => {
+            const runtime = (0, runtime_js_1.getXiaoYiRuntime)();
+            const connection = runtime.getConnection();
+            if (!connection) {
+                return {
+                    accountId: params.account.accountId,
+                    state: "offline",
+                    lastEventAt: Date.now(),
+                    issues: [{
+                            severity: "error",
+                            message: "Not connected",
+                        }],
+                };
+            }
+            const state = connection.getState();
+            if (state.connected && state.authenticated) {
+                return {
+                    accountId: params.account.accountId,
+                    state: "ready",
+                    lastEventAt: Date.now(),
+                    lastInboundAt: Date.now(),
+                };
+            }
+            else if (state.connected) {
+                return {
+                    accountId: params.account.accountId,
+                    state: "authenticating",
+                    lastEventAt: Date.now(),
+                    issues: [{
+                            severity: "warning",
+                            message: "Connected but not authenticated",
+                        }],
+                };
+            }
+            else {
+                return {
+                    accountId: params.account.accountId,
+                    state: "offline",
+                    lastEventAt: Date.now(),
+                    issues: [{
+                            severity: "error",
+                            message: `Reconnect attempts: ${state.reconnectAttempts}/${state.maxReconnectAttempts}`,
+                        }],
+                };
+            }
+        },
+    },
+};

package/dist/config-schema.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+/**
+ * XiaoYi configuration schema using Zod
+ * Defines the structure for XiaoYi A2A protocol configuration
+ */
+export declare const XiaoYiConfigSchema: z.ZodObject<{
+    /** Account name (optional display name) */
+    name: z.ZodOptional<z.ZodString>;
+    /** Whether this channel is enabled */
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /** First WebSocket server URL */
+    wsUrl1: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    /** Second WebSocket server URL */
+    wsUrl2: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    /** Access Key for authentication */
+    ak: z.ZodOptional<z.ZodString>;
+    /** Secret Key for authentication */
+    sk: z.ZodOptional<z.ZodString>;
+    /** Agent ID for this XiaoYi agent */
+    agentId: z.ZodOptional<z.ZodString>;
+    /** Enable debug logging */
+    debug: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    /** Multi-account configuration */
+    accounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    enabled?: boolean;
+    wsUrl1?: string;
+    wsUrl2?: string;
+    ak?: string;
+    sk?: string;
+    agentId?: string;
+    name?: string;
+    debug?: boolean;
+    accounts?: Record<string, unknown>;
+}, {
+    enabled?: boolean;
+    wsUrl1?: string;
+    wsUrl2?: string;
+    ak?: string;
+    sk?: string;
+    agentId?: string;
+    name?: string;
+    debug?: boolean;
+    accounts?: Record<string, unknown>;
+}>;
+export type XiaoYiConfig = z.infer<typeof XiaoYiConfigSchema>;

package/dist/config-schema.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XiaoYiConfigSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * XiaoYi configuration schema using Zod
+ * Defines the structure for XiaoYi A2A protocol configuration
+ */
+exports.XiaoYiConfigSchema = zod_1.z.object({
+    /** Account name (optional display name) */
+    name: zod_1.z.string().optional(),
+    /** Whether this channel is enabled */
+    enabled: zod_1.z.boolean().optional().default(false),
+    /** First WebSocket server URL */
+    wsUrl1: zod_1.z.string().optional().default("wss://hag.cloud.huawei.com/openclaw/v1/ws/link"),
+    /** Second WebSocket server URL */
+    wsUrl2: zod_1.z.string().optional().default("wss://116.63.174.231/openclaw/v1/ws/link"),
+    /** Access Key for authentication */
+    ak: zod_1.z.string().optional(),
+    /** Secret Key for authentication */
+    sk: zod_1.z.string().optional(),
+    /** Agent ID for this XiaoYi agent */
+    agentId: zod_1.z.string().optional(),
+    /** Enable debug logging */
+    debug: zod_1.z.boolean().optional().default(false),
+    /** Multi-account configuration */
+    accounts: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+});

package/dist/file-download.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Download a file from URL to local path.
+ */
+export declare function downloadFile(url: string, destPath: string): Promise<void>;
+/**
+ * Download files from A2A file parts.
+ * Returns array of local file paths.
+ */
+export declare function downloadFilesFromParts(fileParts: Array<{
+    name: string;
+    mimeType: string;
+    uri: string;
+}>, tempDir?: string): Promise<Array<{
+    path: string;
+    name: string;
+    mimeType: string;
+}>>;

package/dist/file-download.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFile = downloadFile;
+exports.downloadFilesFromParts = downloadFilesFromParts;
+// File download utilities
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const logger_js_1 = require("./xy-utils/logger.js");
+/**
+ * Download a file from URL to local path.
+ */
+async function downloadFile(url, destPath) {
+    logger_js_1.logger.debug(`Downloading file from ${url} to ${destPath}`);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 30000); // 30 seconds timeout
+    try {
+        const response = await (0, node_fetch_1.default)(url, { signal: controller.signal });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        await promises_1.default.writeFile(destPath, buffer);
+        logger_js_1.logger.debug(`File downloaded successfully: ${destPath}`);
+    }
+    catch (error) {
+        if (error.name === 'AbortError') {
+            logger_js_1.logger.error(`Download timeout (30s) for ${url}`);
+            throw new Error(`Download timeout after 30 seconds`);
+        }
+        logger_js_1.logger.error(`Failed to download file from ${url}:`, error);
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Download files from A2A file parts.
+ * Returns array of local file paths.
+ */
+async function downloadFilesFromParts(fileParts, tempDir = "/tmp/xy_channel") {
+    // Create temp directory if it doesn't exist
+    await promises_1.default.mkdir(tempDir, { recursive: true });
+    const downloadedFiles = [];
+    for (const filePart of fileParts) {
+        const { name, mimeType, uri } = filePart;
+        // Generate safe file name
+        const safeName = name.replace(/[^a-zA-Z0-9._-]/g, "_");
+        const destPath = path_1.default.join(tempDir, `${Date.now()}_${safeName}`);
+        try {
+            await downloadFile(uri, destPath);
+            downloadedFiles.push({
+                path: destPath,
+                name,
+                mimeType,
+            });
+        }
+        catch (error) {
+            logger_js_1.logger.error(`Failed to download file ${name}:`, error);
+            // Continue with other files
+        }
+    }
+    return downloadedFiles;
+}

package/dist/file-handler.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Simple file and image handler for XiaoYi Channel
+ * Handles downloading and extracting content from URIs
+ */
+export interface InputImageContent {
+    type: "image";
+    data: string;
+    mimeType: string;
+}
+export interface ImageLimits {
+    allowUrl: boolean;
+    allowedMimes: Set<string>;
+    maxBytes: number;
+    maxRedirects: number;
+    timeoutMs: number;
+}
+/**
+ * Extract image content from URL
+ */
+export declare function extractImageFromUrl(url: string, limits?: Partial<ImageLimits>): Promise<InputImageContent>;
+/**
+ * Extract text content from URL (for text-based files)
+ */
+export declare function extractTextFromUrl(url: string, maxBytes?: number, timeoutMs?: number): Promise<string>;
+/**
+ * Check if a MIME type is an image
+ */
+export declare function isImageMimeType(mimeType: string | undefined): boolean;
+/**
+ * Check if a MIME type is a PDF
+ */
+export declare function isPdfMimeType(mimeType: string | undefined): boolean;
+/**
+ * Check if a MIME type is text-based
+ */
+export declare function isTextMimeType(mimeType: string | undefined): boolean;

package/dist/file-handler.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Simple file and image handler for XiaoYi Channel
+ * Handles downloading and extracting content from URIs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractImageFromUrl = extractImageFromUrl;
+exports.extractTextFromUrl = extractTextFromUrl;
+exports.isImageMimeType = isImageMimeType;
+exports.isPdfMimeType = isPdfMimeType;
+exports.isTextMimeType = isTextMimeType;
+// Default limits
+const DEFAULT_IMAGE_MIMES = new Set(["image/jpeg", "image/png", "image/gif", "image/webp"]);
+const DEFAULT_MAX_BYTES = 10000000; // 10MB
+const DEFAULT_TIMEOUT = 30000; // 30 seconds
+const DEFAULT_MAX_REDIRECTS = 3;
+/**
+ * Fetch content from URL with basic validation
+ */
+async function fetchFromUrl(url, maxBytes, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            signal: controller.signal,
+            headers: { "User-Agent": "XiaoYi-Channel/1.0" },
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        // Check content-length header if available
+        const contentLength = response.headers.get("content-length");
+        if (contentLength) {
+            const size = parseInt(contentLength, 10);
+            if (size > maxBytes) {
+                throw new Error(`File too large: ${size} bytes (limit: ${maxBytes})`);
+            }
+        }
+        const buffer = Buffer.from(await response.arrayBuffer());
+        if (buffer.byteLength > maxBytes) {
+            throw new Error(`File too large: ${buffer.byteLength} bytes (limit: ${maxBytes})`);
+        }
+        // Detect MIME type
+        const contentType = response.headers.get("content-type");
+        const mimeType = contentType?.split(";")[0]?.trim() || "application/octet-stream";
+        return { buffer, mimeType };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Extract image content from URL
+ */
+async function extractImageFromUrl(url, limits) {
+    const finalLimits = {
+        allowUrl: limits?.allowUrl ?? true,
+        allowedMimes: limits?.allowedMimes ?? DEFAULT_IMAGE_MIMES,
+        maxBytes: limits?.maxBytes ?? DEFAULT_MAX_BYTES,
+        maxRedirects: limits?.maxRedirects ?? DEFAULT_MAX_REDIRECTS,
+        timeoutMs: limits?.timeoutMs ?? DEFAULT_TIMEOUT,
+    };
+    if (!finalLimits.allowUrl) {
+        throw new Error("URL sources are disabled");
+    }
+    const { buffer, mimeType } = await fetchFromUrl(url, finalLimits.maxBytes, finalLimits.timeoutMs);
+    if (!finalLimits.allowedMimes.has(mimeType)) {
+        throw new Error(`Unsupported image type: ${mimeType}`);
+    }
+    return {
+        type: "image",
+        data: buffer.toString("base64"),
+        mimeType,
+    };
+}
+/**
+ * Extract text content from URL (for text-based files)
+ */
+async function extractTextFromUrl(url, maxBytes = 5000000, timeoutMs = 30000) {
+    const { buffer, mimeType } = await fetchFromUrl(url, maxBytes, timeoutMs);
+    // Only process text-based MIME types
+    const textMimes = ["text/plain", "text/markdown", "text/html", "text/csv", "application/json", "application/xml"];
+    if (!textMimes.some((tm) => mimeType.startsWith(tm) || mimeType === tm)) {
+        throw new Error(`Unsupported text type: ${mimeType}`);
+    }
+    // Try to decode as UTF-8
+    return buffer.toString("utf-8");
+}
+/**
+ * Check if a MIME type is an image
+ */
+function isImageMimeType(mimeType) {
+    if (!mimeType)
+        return false;
+    return DEFAULT_IMAGE_MIMES.has(mimeType.toLowerCase());
+}
+/**
+ * Check if a MIME type is a PDF
+ */
+function isPdfMimeType(mimeType) {
+    return mimeType?.toLowerCase() === "application/pdf" || false;
+}
+/**
+ * Check if a MIME type is text-based
+ */
+function isTextMimeType(mimeType) {
+    if (!mimeType)
+        return false;
+    const lower = mimeType.toLowerCase();
+    return (lower.startsWith("text/") ||
+        lower === "application/json" ||
+        lower === "application/xml");
+}