@undefineds.co/xpod 0.4.14 → 0.4.16

package/dist/tunnel/TunnelLifecycle.js

@@ -1,8 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTunnelStatus = createTunnelStatus;
 exports.mergeTunnelError = mergeTunnelError;
 exports.describeSpawnError = describeSpawnError;
+const node_path_1 = __importDefault(require("node:path"));
+const TunnelClientResolver_1 = require("./TunnelClientResolver");
+const TunnelProviderCatalog_1 = require("./TunnelProviderCatalog");
 /**
  * Tunnel readiness is a sequence, not a boolean.
  *
@@ -23,12 +29,27 @@ function createTunnelStatus(stage, patch = {}) {
 function mergeTunnelError(previous, next) {
     return next ?? previous;
 }
-/** Recognizes a missing client binary, which is a deployment fact, not a network failure. */
+/**
+ * Recognizes a missing client binary, which is a deployment fact, not a network failure.
+ *
+ * The prefix stays `binary-missing:<provider>:<binary>` (callers and acceptance assert on it);
+ * `<provider>` is resolved to the catalog id first, so an implementation that calls itself
+ * `sakura-frp` cannot put a provider id into the message that no catalog lookup resolves.
+ * The install hint from the provider catalog is appended so an operator reading the failure
+ * knows what to install instead of having to search (audit N16).
+ */
 function describeSpawnError(provider, binary, error) {
     const code = typeof error === 'object' && error && 'code' in error ? String(error.code) : '';
+    // `spawn-failed` is a plain diagnostic, but its provider segment is normalized the same way
+    // so both families of message name the same provider.
+    const id = (0, TunnelProviderCatalog_1.canonicalTunnelProviderId)(provider) ?? provider;
     if (code === 'ENOENT') {
-        return `binary-missing:${provider}:${binary}`;
+        // The prefix stays `binary-missing:<provider>:<binary name>` because callers assert on it;
+        // when the command was an absolute path, which file was tried is appended for the operator.
+        const name = node_path_1.default.basename(binary);
+        const message = (0, TunnelClientResolver_1.describeTunnelClientMissing)(id, name);
+        return name === binary ? message : `${message} (tried: ${binary})`;
     }
-    return `spawn-failed:${provider}:${error?.message ?? String(error)}`;
+    return `spawn-failed:${id}:${error?.message ?? String(error)}`;
 }
 //# sourceMappingURL=TunnelLifecycle.js.map

package/dist/tunnel/TunnelProviderCatalog.d.ts

@@ -21,9 +21,32 @@ export interface TunnelProviderParameterField {
     key: string;
     label: string;
 }
+/**
+ * The local client this provider needs (audit N16).
+ *
+ * Declared here so there is one place that knows the executable name, how an operator points at
+ * a specific build, whether the artifact may ship the binary at all, and what to tell them when
+ * it is missing. Providers consume it instead of each keeping its own default string.
+ */
+export interface TunnelProviderClient {
+    /** Executable name; also the name reported in `binary-missing:<provider>:<binary>`. */
+    binary: string;
+    /** Env var that names an explicit path; highest precedence, and never silently ignored. */
+    envKey: string;
+    /** Where an operator can get it (shown next to a missing-binary failure). */
+    installHint: string;
+    /**
+     * Whether the release artifact may ship this binary. ngrok and the natfrp frpc fork are not
+     * ours to redistribute; cloudflared and upstream frpc are Apache-2.0 and could be bundled.
+     */
+    redistributable: boolean;
+    /** Upstream licence / redistribution note, for whoever changes that decision later. */
+    license: string;
+}
 export interface TunnelProviderDescriptor {
     id: TunnelProviderId;
     label: string;
+    client: TunnelProviderClient;
     /** Legacy provider-scoped credential key, still honoured for single-profile setups. */
     legacyCredentialEnvKey: string;
     /** Legacy env keys that used to declare this provider's public entry. */
@@ -52,6 +75,15 @@ export interface TunnelProviderDescriptor {
 export declare const TUNNEL_PROVIDERS: readonly TunnelProviderDescriptor[];
 /** Normalizes any stored/legacy spelling onto the canonical provider vocabulary. */
 export declare function parseTunnelProvider(value: unknown): ActiveTunnelProvider | undefined;
+/**
+ * The one spelling of a provider that may appear in machine-readable messages.
+ *
+ * Provider implementations and callers historically used their own hyphenated names
+ * (`sakura-frp`), which is how a failure detail ended up carrying a provider id that no
+ * catalog lookup could resolve. Anything that renders a provider into a message resolves it
+ * here first, so the catalog id is the only one that can reach an operator.
+ */
+export declare function canonicalTunnelProviderId(value: unknown): TunnelProviderId | undefined;
 export declare function isTunnelProviderId(value: unknown): value is TunnelProviderId;
 export declare function tunnelProviderDescriptor(id: unknown): TunnelProviderDescriptor | undefined;
 export declare function tunnelProviderIds(): TunnelProviderId[];

package/dist/tunnel/TunnelProviderCatalog.js

@@ -11,6 +11,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TUNNEL_PROFILE_CREDENTIAL_PREFIX = exports.TUNNEL_PROVIDERS = exports.TUNNEL_PROVIDER_IDS = void 0;
 exports.parseTunnelProvider = parseTunnelProvider;
+exports.canonicalTunnelProviderId = canonicalTunnelProviderId;
 exports.isTunnelProviderId = isTunnelProviderId;
 exports.tunnelProviderDescriptor = tunnelProviderDescriptor;
 exports.tunnelProviderIds = tunnelProviderIds;
@@ -32,6 +33,14 @@ exports.TUNNEL_PROVIDERS = [
     {
         id: 'ngrok',
         label: 'ngrok',
+        client: {
+            binary: 'ngrok',
+            envKey: 'NGROK_BIN',
+            installHint: 'install the ngrok agent and put it on PATH (or set NGROK_BIN)',
+            // ngrok's agent is proprietary: bundling it in our artifact needs their permission.
+            redistributable: false,
+            license: 'proprietary (ngrok terms of service)',
+        },
         legacyCredentialEnvKey: 'NGROK_AUTHTOKEN',
         legacyPublicUrlKeys: ['NGROK_URL'],
         endpointSource: 'discovered',
@@ -46,6 +55,13 @@ exports.TUNNEL_PROVIDERS = [
     {
         id: 'cloudflare',
         label: 'Cloudflare Tunnel',
+        client: {
+            binary: 'cloudflared',
+            envKey: 'CLOUDFLARED_BIN',
+            installHint: 'install cloudflared and put it on PATH (or set CLOUDFLARED_BIN)',
+            redistributable: true,
+            license: 'Apache-2.0',
+        },
         legacyCredentialEnvKey: 'CLOUDFLARE_TUNNEL_TOKEN',
         legacyPublicUrlKeys: ['CLOUDFLARE_TUNNEL_URL', 'XPOD_TUNNEL_PUBLIC_URL'],
         // The hostname is configured in the Cloudflare dashboard and cloudflared is only
@@ -61,6 +77,14 @@ exports.TUNNEL_PROVIDERS = [
     {
         id: 'sakura_frp',
         label: 'Sakura FRP',
+        client: {
+            binary: 'frpc',
+            envKey: 'FRPC_BIN',
+            // The official client is required: upstream frpc cannot express `-f <token>`.
+            installHint: 'install the natfrp client (its frpc accepts `-f <token>`) and put it on PATH',
+            redistributable: false,
+            license: 'natfrp fork (no published source; redistribution needs their permission)',
+        },
         legacyCredentialEnvKey: 'SAKURA_TUNNEL_TOKEN',
         legacyPublicUrlKeys: ['SAKURA_TUNNEL_URL', 'XPOD_TUNNEL_PUBLIC_URL'],
         // The console only asks for a node and a local port: the public entry (node host +
@@ -76,6 +100,13 @@ exports.TUNNEL_PROVIDERS = [
     {
         id: 'frp',
         label: 'FRP',
+        client: {
+            binary: 'frpc',
+            envKey: 'FRPC_BIN',
+            installHint: 'install upstream frpc and put it on PATH (or set FRPC_BIN)',
+            redistributable: true,
+            license: 'Apache-2.0',
+        },
         legacyCredentialEnvKey: 'FRP_TUNNEL_TOKEN',
         legacyPublicUrlKeys: ['FRP_TUNNEL_URL'],
         endpointSource: 'declared',
@@ -101,6 +132,18 @@ function parseTunnelProvider(value) {
     }
     return PROVIDER_ALIASES[value.trim().toLowerCase()];
 }
+/**
+ * The one spelling of a provider that may appear in machine-readable messages.
+ *
+ * Provider implementations and callers historically used their own hyphenated names
+ * (`sakura-frp`), which is how a failure detail ended up carrying a provider id that no
+ * catalog lookup could resolve. Anything that renders a provider into a message resolves it
+ * here first, so the catalog id is the only one that can reach an operator.
+ */
+function canonicalTunnelProviderId(value) {
+    const provider = parseTunnelProvider(value);
+    return provider && provider !== 'none' ? provider : undefined;
+}
 function isTunnelProviderId(value) {
     return parseTunnelProvider(value) !== undefined && parseTunnelProvider(value) !== 'none';
 }

package/dist/tunnel/index.d.ts

@@ -2,5 +2,6 @@ export type { TunnelProvider, TunnelConfig, TunnelSetupOptions, TunnelStatus, }
 export { CloudflareTunnelProvider, type CloudflareTunnelProviderOptions, } from './CloudflareTunnelProvider';
 export { LocalTunnelProvider, type LocalTunnelProviderOptions, } from './LocalTunnelProvider';
 export { NgrokTunnelProvider, type NgrokTunnelProviderOptions, } from './NgrokTunnelProvider';
+export { AutoTunnelProvider, type AutoTunnelCandidate, type AutoTunnelProviderOptions, } from './AutoTunnelProvider';
 export type { ActiveTunnelProvider, TunnelProfile, TunnelProfileProvider, TunnelProfileState, } from './TunnelProfiles';
 export { resolveTunnelProfileState, selectActiveTunnelProfile, } from './TunnelProfiles';

package/dist/tunnel/index.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectActiveTunnelProfile = exports.resolveTunnelProfileState = exports.NgrokTunnelProvider = exports.LocalTunnelProvider = exports.CloudflareTunnelProvider = void 0;
+exports.selectActiveTunnelProfile = exports.resolveTunnelProfileState = exports.AutoTunnelProvider = exports.NgrokTunnelProvider = exports.LocalTunnelProvider = exports.CloudflareTunnelProvider = void 0;
 var CloudflareTunnelProvider_1 = require("./CloudflareTunnelProvider");
 Object.defineProperty(exports, "CloudflareTunnelProvider", { enumerable: true, get: function () { return CloudflareTunnelProvider_1.CloudflareTunnelProvider; } });
 var LocalTunnelProvider_1 = require("./LocalTunnelProvider");
 Object.defineProperty(exports, "LocalTunnelProvider", { enumerable: true, get: function () { return LocalTunnelProvider_1.LocalTunnelProvider; } });
 var NgrokTunnelProvider_1 = require("./NgrokTunnelProvider");
 Object.defineProperty(exports, "NgrokTunnelProvider", { enumerable: true, get: function () { return NgrokTunnelProvider_1.NgrokTunnelProvider; } });
+var AutoTunnelProvider_1 = require("./AutoTunnelProvider");
+Object.defineProperty(exports, "AutoTunnelProvider", { enumerable: true, get: function () { return AutoTunnelProvider_1.AutoTunnelProvider; } });
 var TunnelProfiles_1 = require("./TunnelProfiles");
 Object.defineProperty(exports, "resolveTunnelProfileState", { enumerable: true, get: function () { return TunnelProfiles_1.resolveTunnelProfileState; } });
 Object.defineProperty(exports, "selectActiveTunnelProfile", { enumerable: true, get: function () { return TunnelProfiles_1.selectActiveTunnelProfile; } });

package/node_modules/@undefineds.co/ai-connections/dist/error-wording.js

@@ -134,8 +134,13 @@ function messageForSafeErrorCode(code, provider) {
             return provider
                 ? `${providerLabel(provider)} does not support this operation.`
                 : 'This AI Connection operation is not supported.';
-        case 'service_identity_unavailable':
-            return 'AI Connection service identity is unavailable';
+        case 'service_access_missing':
+        case 'pod_interface_key_missing':
+        case 'pod_interface_key_rejected':
+        case 'caller_dpop_replay_unsupported':
+            // Xpod reaches the Pod with the owner's own interface key, never with a
+            // deployment identity, so the fix is always on the user's side.
+            return 'Xpod 尚未获得这个 Pod 的接口访问密钥。请在「客户端访问」中创建 API Key 并应用到客户端后重试。';
         case 'unauthorized':
             return 'Please sign in again to continue.';
         case 'forbidden':

package/node_modules/@undefineds.co/extensions/dist-cjs/adapters/langchain.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toLangChainDocuments = toLangChainDocuments;
+exports.createLangChainDocumentLoader = createLangChainDocumentLoader;
+exports.createReaderFromLangChainLoader = createReaderFromLangChainLoader;
+const reader_js_1 = require("../reader.js");
+function toLangChainDocuments(result) {
+    return result.documents.map((document) => ({
+        pageContent: document.text,
+        metadata: (0, reader_js_1.mergeDocumentMetadata)(result, document),
+    }));
+}
+function createLangChainDocumentLoader(reader, request, ctx) {
+    return {
+        load: async () => toLangChainDocuments(await reader.read(request, ctx)),
+    };
+}
+function createReaderFromLangChainLoader(options) {
+    return {
+        id: options.id,
+        displayName: options.displayName,
+        outputs: options.outputs,
+        transports: options.transports,
+        supportedSourceSchemes: options.supportedSourceSchemes,
+        supportedMimeTypes: options.supportedMimeTypes,
+        read: async (request, ctx) => {
+            const loader = await options.createLoader(request, ctx);
+            const langChainDocuments = await loader.load();
+            const documents = langChainDocuments.map((document) => langChainDocumentToReaderDocument(document));
+            const result = {
+                reader: options.id,
+                model: request.model,
+                documents,
+                text: documents.map((document) => document.text).filter(Boolean).join('\n\n'),
+            };
+            return {
+                ...result,
+                text: (0, reader_js_1.readResultText)(result),
+            };
+        },
+    };
+}
+function langChainDocumentToReaderDocument(document) {
+    return {
+        id: document.id,
+        text: document.pageContent,
+        metadata: document.metadata ?? {},
+    };
+}

package/node_modules/@undefineds.co/extensions/dist-cjs/adapters/llamaindex.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toLlamaIndexDocuments = toLlamaIndexDocuments;
+exports.createLlamaIndexReader = createLlamaIndexReader;
+exports.createReaderFromLlamaIndexReader = createReaderFromLlamaIndexReader;
+const reader_js_1 = require("../reader.js");
+function toLlamaIndexDocuments(result) {
+    return result.documents.map((document) => ({
+        text: document.text,
+        metadata: (0, reader_js_1.mergeDocumentMetadata)(result, document),
+    }));
+}
+function createLlamaIndexReader(reader, ctx) {
+    return {
+        loadData: async (input) => {
+            const requests = Array.isArray(input) ? input : [input];
+            const results = await Promise.all(requests.map((request) => reader.read(request, ctx)));
+            return results.flatMap((result) => toLlamaIndexDocuments(result));
+        },
+    };
+}
+function createReaderFromLlamaIndexReader(options) {
+    return {
+        id: options.id,
+        displayName: options.displayName,
+        outputs: options.outputs,
+        transports: options.transports,
+        supportedSourceSchemes: options.supportedSourceSchemes,
+        supportedMimeTypes: options.supportedMimeTypes,
+        read: async (request, ctx) => {
+            const llamaReader = await options.createReader(request, ctx);
+            const loadInput = options.createLoadDataInput?.(request, ctx) ?? request;
+            const llamaDocuments = await llamaReader.loadData(loadInput);
+            const documents = llamaDocuments.map((document) => llamaIndexDocumentToReaderDocument(document));
+            const result = {
+                reader: options.id,
+                model: request.model,
+                documents,
+                text: documents.map((document) => document.text).filter(Boolean).join('\n\n'),
+            };
+            return {
+                ...result,
+                text: (0, reader_js_1.readResultText)(result),
+            };
+        },
+    };
+}
+function llamaIndexDocumentToReaderDocument(document) {
+    return {
+        id: document.id_ ?? document.id,
+        text: document.getText?.() ?? document.text ?? document.textResource?.text ?? '',
+        metadata: document.metadata ?? {},
+    };
+}

package/node_modules/@undefineds.co/extensions/dist-cjs/index.js

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./registry.js"), exports);
+__exportStar(require("./reader.js"), exports);
+__exportStar(require("./adapters/langchain.js"), exports);
+__exportStar(require("./adapters/llamaindex.js"), exports);
+__exportStar(require("./paddleocr.js"), exports);

package/node_modules/@undefineds.co/extensions/dist-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/node_modules/@undefineds.co/extensions/dist-cjs/paddleocr.js

@@ -0,0 +1,304 @@
+"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.PADDLEOCR_DEFAULT_ENDPOINT = void 0;
+exports.createPaddleOcrReader = createPaddleOcrReader;
+exports.createPaddleOcrExtension = createPaddleOcrExtension;
+const reader_js_1 = require("./reader.js");
+exports.PADDLEOCR_DEFAULT_ENDPOINT = 'https://paddleocr.aistudio-app.com/api/v2/ocr/jobs';
+function createPaddleOcrReader(options) {
+    const id = options.id ?? 'paddleocr';
+    const model = options.model ?? 'PP-OCRv6';
+    return {
+        id,
+        displayName: options.displayName ?? 'PaddleOCR Reader',
+        outputs: ['markdown', 'text', 'structured'],
+        transports: ['remote-http'],
+        supportedSourceSchemes: ['https', 'http', 'file'],
+        supportedMimeTypes: ['application/pdf', 'image/png', 'image/jpeg', 'image/webp', 'image/tiff'],
+        read: async (request, ctx) => {
+            const fetcher = options.fetch ?? globalThis.fetch;
+            if (!fetcher) {
+                throw new reader_js_1.ReaderError('No fetch implementation is available for PaddleOCR reader.', {
+                    code: 'INVALID_INPUT',
+                    retryable: false,
+                });
+            }
+            const payload = await createPaddlePayload(request, model, options.defaultOptions);
+            const response = await fetcher(resolvePaddleEndpoint(options), {
+                method: 'POST',
+                headers: createHeaders(options.apiKey),
+                body: JSON.stringify(payload),
+                signal: ctx.signal,
+            });
+            const body = await readJsonResponse(response);
+            if (!response.ok) {
+                throw new reader_js_1.ReaderError(`PaddleOCR request failed with HTTP ${response.status}.`, {
+                    code: response.status >= 500 || response.status === 429 ? 'PROVIDER_UNAVAILABLE' : 'PROVIDER_REJECTED',
+                    status: response.status,
+                    retryable: response.status >= 500 || response.status === 429,
+                    cause: body,
+                });
+            }
+            return paddleResponseToReadResult(id, model, request, body);
+        },
+    };
+}
+function createPaddleOcrExtension(options) {
+    return (api) => {
+        const reader = createPaddleOcrReader(options);
+        api.reader.register(reader);
+        api.config.registerSchema({
+            id: reader.id,
+            fields: [
+                { name: 'apiKey', type: 'secret', required: true, description: 'Bearer token for the PaddleOCR provider.' },
+                { name: 'model', type: 'string', required: false, description: 'PaddleOCR model or pipeline name.' },
+            ],
+        });
+        api.runtime.registerCapability({
+            id: `${reader.id}-remote-http`,
+            kind: 'remote-http',
+            readerIds: [reader.id],
+            sourceSchemes: ['https', 'http', 'file'],
+        });
+    };
+}
+function resolvePaddleEndpoint(options) {
+    return options.endpoint?.trim() || exports.PADDLEOCR_DEFAULT_ENDPOINT;
+}
+async function createPaddlePayload(request, model, defaultOptions) {
+    const input = request.input ?? sourceToInput(request.source);
+    const file = await inputToPaddleFile(input);
+    return {
+        ...defaultOptions,
+        ...request.options,
+        file,
+        fileType: inferPaddleFileType(input.mimeType ?? input.filename ?? request.source),
+        fileName: input.filename ?? filenameFromUri(request.source),
+        pageRange: request.pages,
+        model: request.model ?? model,
+    };
+}
+function sourceToInput(source) {
+    if (/^https?:\/\//u.test(source)) {
+        return {
+            kind: 'remote-url',
+            url: source,
+            filename: filenameFromUri(source),
+            mimeType: inferMimeType(source),
+        };
+    }
+    if (source.startsWith('file://')) {
+        return {
+            kind: 'local-path',
+            path: decodeURIComponent(source.slice('file://'.length)),
+            filename: filenameFromUri(source),
+            mimeType: inferMimeType(source),
+        };
+    }
+    throw new reader_js_1.ReaderError(`Unsupported PaddleOCR source URI: ${source}`, {
+        code: 'UNSUPPORTED_SOURCE',
+        retryable: false,
+    });
+}
+async function inputToPaddleFile(input) {
+    switch (input.kind) {
+        case 'remote-url':
+            return input.url;
+        case 'bytes':
+            return bytesToBase64(input.bytes);
+        case 'local-path': {
+            const fs = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
+            return bytesToBase64(await fs.readFile(input.path));
+        }
+        case 'stream':
+            return bytesToBase64(await streamToBytes(input.stream));
+    }
+}
+function createHeaders(apiKey) {
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (apiKey) {
+        headers.Authorization = `Bearer ${apiKey}`;
+    }
+    return headers;
+}
+async function readJsonResponse(response) {
+    const text = await response.text();
+    if (!text) {
+        return {};
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new reader_js_1.ReaderError('PaddleOCR returned a non-JSON response.', {
+            code: 'PARSE_FAILED',
+            status: response.status,
+            retryable: response.status >= 500,
+            cause: error,
+        });
+    }
+}
+function paddleResponseToReadResult(readerId, model, request, body) {
+    const entries = extractPaddleEntries(body);
+    const documents = entries.map((entry, index) => paddleEntryToDocument(entry, index, request, model));
+    const markdown = documents.map((document) => document.text).filter(Boolean).join('\n\n');
+    return {
+        reader: readerId,
+        model: request.model ?? model,
+        documents,
+        markdown,
+        text: markdown,
+        raw: body,
+    };
+}
+function extractPaddleEntries(body) {
+    if (!isRecord(body)) {
+        return [];
+    }
+    const candidates = [
+        body.result,
+        body.data,
+        body,
+    ];
+    for (const candidate of candidates) {
+        if (isRecord(candidate) && Array.isArray(candidate.layoutParsingResults)) {
+            return candidate.layoutParsingResults;
+        }
+        if (isRecord(candidate) && Array.isArray(candidate.results)) {
+            return candidate.results;
+        }
+    }
+    return [body];
+}
+function paddleEntryToDocument(entry, index, request, model) {
+    const record = isRecord(entry) ? entry : {};
+    const markdown = isRecord(record.markdown) ? record.markdown : undefined;
+    const text = firstString([
+        markdown?.text,
+        record.markdown,
+        record.text,
+        record.content,
+    ]);
+    const page = firstNumber([
+        record.page,
+        record.pageId,
+        record.pageIndex,
+        record.page_number,
+    ]);
+    return {
+        id: `${request.source}#paddleocr-${index + 1}`,
+        text,
+        metadata: {
+            sourceUri: request.source,
+            page,
+            model: request.model ?? model,
+        },
+        sourceUri: request.source,
+        raw: entry,
+    };
+}
+function firstString(values) {
+    for (const value of values) {
+        if (typeof value === 'string') {
+            return value;
+        }
+    }
+    return '';
+}
+function firstNumber(values) {
+    for (const value of values) {
+        if (typeof value === 'number') {
+            return value;
+        }
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function inferPaddleFileType(value) {
+    const normalized = value?.toLowerCase() ?? '';
+    if (normalized.includes('pdf') || normalized.endsWith('.pdf')) {
+        return 0;
+    }
+    return 1;
+}
+function inferMimeType(uri) {
+    const clean = uri.split(/[?#]/u)[0]?.toLowerCase() ?? '';
+    if (clean.endsWith('.pdf'))
+        return 'application/pdf';
+    if (clean.endsWith('.png'))
+        return 'image/png';
+    if (clean.endsWith('.jpg') || clean.endsWith('.jpeg'))
+        return 'image/jpeg';
+    if (clean.endsWith('.webp'))
+        return 'image/webp';
+    if (clean.endsWith('.tiff') || clean.endsWith('.tif'))
+        return 'image/tiff';
+    return undefined;
+}
+function filenameFromUri(uri) {
+    const clean = uri.split(/[?#]/u)[0] ?? '';
+    const filename = clean.split('/').filter(Boolean).at(-1);
+    return filename ? decodeURIComponent(filename) : undefined;
+}
+function bytesToBase64(bytes) {
+    return Buffer.from(bytes).toString('base64');
+}
+async function streamToBytes(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    let total = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        if (value) {
+            chunks.push(value);
+            total += value.byteLength;
+        }
+    }
+    const result = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return result;
+}