@infimind-next/ai-hive-mcp 0.3.3 → 0.4.0

package/dist/managed-config.d.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+export declare const mcpManagedConfigSchema: z.ZodEffects<z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    apiBaseUrl: z.ZodEffects<z.ZodString, string, string>;
+    activationId: z.ZodString;
+    userId: z.ZodString;
+    credentialHelper: z.ZodObject<{
+        command: z.ZodEffects<z.ZodString, string, string>;
+        args: z.ZodArray<z.ZodString, "many">;
+    }, "strict", z.ZodTypeAny, {
+        command: string;
+        args: string[];
+    }, {
+        command: string;
+        args: string[];
+    }>;
+    projectRoot: z.ZodEffects<z.ZodString, string, string>;
+    extraImagePaths: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+    outputDirectory: z.ZodEffects<z.ZodString, string, string>;
+    stateDirectory: z.ZodEffects<z.ZodString, string, string>;
+}, "strict", z.ZodTypeAny, {
+    version: 1;
+    apiBaseUrl: string;
+    activationId: string;
+    userId: string;
+    credentialHelper: {
+        command: string;
+        args: string[];
+    };
+    projectRoot: string;
+    extraImagePaths: string[];
+    outputDirectory: string;
+    stateDirectory: string;
+}, {
+    version: 1;
+    apiBaseUrl: string;
+    activationId: string;
+    userId: string;
+    credentialHelper: {
+        command: string;
+        args: string[];
+    };
+    projectRoot: string;
+    extraImagePaths: string[];
+    outputDirectory: string;
+    stateDirectory: string;
+}>, {
+    version: 1;
+    apiBaseUrl: string;
+    activationId: string;
+    userId: string;
+    credentialHelper: {
+        command: string;
+        args: string[];
+    };
+    projectRoot: string;
+    extraImagePaths: string[];
+    outputDirectory: string;
+    stateDirectory: string;
+}, {
+    version: 1;
+    apiBaseUrl: string;
+    activationId: string;
+    userId: string;
+    credentialHelper: {
+        command: string;
+        args: string[];
+    };
+    projectRoot: string;
+    extraImagePaths: string[];
+    outputDirectory: string;
+    stateDirectory: string;
+}>;
+export type McpManagedConfig = z.infer<typeof mcpManagedConfigSchema>;
+export declare function loadManagedConfig(path: string): Promise<McpManagedConfig>;

package/dist/managed-config.js

@@ -0,0 +1,71 @@
+import { readFile } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+import { z } from "zod";
+// npm 包独立发布; 此契约由 parity 测试与 contracts/mcp-managed 保持一致.
+const absolutePath = z
+    .string()
+    .min(1)
+    .refine((value) => value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value), "需要绝对路径");
+const normalizedPath = (value) => value.replace(/\\/g, "/").replace(/\/+$/, "");
+export const mcpManagedConfigSchema = z
+    .object({
+    version: z.literal(1),
+    apiBaseUrl: z
+        .string()
+        .url()
+        .refine((value) => {
+        const url = new URL(value);
+        return (url.protocol === "https:" &&
+            !url.username &&
+            !url.password &&
+            !url.search &&
+            !url.hash);
+    }),
+    activationId: z.string().min(1).max(200),
+    userId: z.string().min(1).max(200),
+    credentialHelper: z
+        .object({ command: absolutePath, args: z.array(z.string()) })
+        .strict(),
+    projectRoot: absolutePath,
+    extraImagePaths: z.array(absolutePath).max(100),
+    outputDirectory: absolutePath,
+    stateDirectory: absolutePath,
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (normalizedPath(value.outputDirectory) !==
+        `${normalizedPath(value.projectRoot)}/ai-hive-images`) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["outputDirectory"],
+            message: "结果目录必须位于项目的 ai-hive-images 文件夹",
+        });
+    }
+    const args = value.credentialHelper.args;
+    const prefixAllowed = args.length === 4 ||
+        (args.length === 5 && absolutePath.safeParse(args[0]).success);
+    if (!prefixAllowed ||
+        JSON.stringify(args.slice(-4)) !==
+            JSON.stringify([
+                "--credential-helper",
+                "mcp",
+                "--activation-id",
+                value.activationId,
+            ])) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["credentialHelper", "args"],
+            message: "凭据助手需要绑定当前连接",
+        });
+    }
+});
+export async function loadManagedConfig(path) {
+    try {
+        if (!isAbsolute(path))
+            throw new Error();
+        return mcpManagedConfigSchema.parse(JSON.parse(await readFile(path, "utf8")));
+    }
+    catch {
+        throw new Error("图片工具配置无效，请回到 AI-HIVE 启动器重新打开项目");
+    }
+}

package/dist/managed-download.d.ts

@@ -0,0 +1,13 @@
+type Address = {
+    address: string;
+    family: number;
+};
+type Resolver = (hostname: string) => Promise<Address[]>;
+export declare function resolvePublicHttpsTarget(rawUrl: string, resolver?: Resolver): Promise<{
+    url: URL;
+    hostname: string;
+    address: string;
+    family: number;
+}>;
+export declare function downloadGeneratedImage(rawUrl: string, timeoutMs?: number): Promise<Uint8Array>;
+export {};

package/dist/managed-download.js

@@ -0,0 +1,138 @@
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
+import { request } from "node:https";
+import { MAX_MANAGED_IMAGE_BYTES } from "./managed-files.js";
+const DOWNLOAD_ERROR = "生成已完成，图片暂时无法保存，请稍后查询原任务再试";
+function isPublicAddress(address) {
+    if (isIP(address) === 4) {
+        const [a = 0, b = 0, c = 0] = address.split(".").map(Number);
+        return !(a === 0 ||
+            a === 10 ||
+            a === 127 ||
+            a >= 224 ||
+            (a === 169 && b === 254) ||
+            (a === 172 && b >= 16 && b <= 31) ||
+            (a === 192 && (b === 168 || b === 0 || b === 2)) ||
+            (a === 100 && b >= 64 && b <= 127) ||
+            (a === 198 && (b === 18 || b === 19 || (b === 51 && c === 100))) ||
+            (a === 203 && b === 0 && c === 113));
+    }
+    // 仅接受原生全球单播; 排除 mapped IPv4、NAT64、ULA、link-local 等转译范围.
+    if (isIP(address) !== 6)
+        return false;
+    const [first = 0, second = 0] = address
+        .split(":")
+        .slice(0, 2)
+        .map((part) => Number.parseInt(part || "0", 16));
+    return (first >= 0x2000 &&
+        first <= 0x3ffd &&
+        first !== 0x2002 &&
+        !(first === 0x2001 && (second <= 0x1ff || second === 0xdb8)));
+}
+export async function resolvePublicHttpsTarget(rawUrl, resolver = (hostname) => lookup(hostname, { all: true, verbatim: true })) {
+    let url;
+    try {
+        url = new URL(rawUrl);
+    }
+    catch {
+        throw new Error(DOWNLOAD_ERROR);
+    }
+    const hostname = url.hostname.replace(/^\[|\]$/g, "");
+    if (url.protocol !== "https:" ||
+        url.username ||
+        url.password ||
+        url.hash ||
+        (url.port && url.port !== "443") ||
+        hostname === "localhost" ||
+        hostname.endsWith(".localhost") ||
+        hostname.endsWith(".local"))
+        throw new Error(DOWNLOAD_ERROR);
+    const addresses = isIP(hostname)
+        ? [{ address: hostname, family: isIP(hostname) }]
+        : await resolver(hostname).catch(() => {
+            throw new Error(DOWNLOAD_ERROR);
+        });
+    if (!addresses.length ||
+        addresses.some(({ address }) => !isPublicAddress(address)))
+        throw new Error(DOWNLOAD_ERROR);
+    const selected = addresses[0];
+    return { url, hostname, address: selected.address, family: selected.family };
+}
+export async function downloadGeneratedImage(rawUrl, timeoutMs = 60_000) {
+    const deadline = Date.now() + timeoutMs;
+    let currentUrl = rawUrl;
+    for (let redirects = 0; redirects <= 3; redirects += 1) {
+        let dnsTimeout;
+        const target = await Promise.race([
+            resolvePublicHttpsTarget(currentUrl),
+            new Promise((_resolve, reject) => {
+                dnsTimeout = setTimeout(() => reject(new Error(DOWNLOAD_ERROR)), Math.max(1, deadline - Date.now()));
+            }),
+        ]).finally(() => clearTimeout(dnsTimeout));
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            throw new Error(DOWNLOAD_ERROR);
+        const response = await new Promise((resolve, reject) => {
+            const fail = () => reject(new Error(DOWNLOAD_ERROR));
+            const req = request(target.url, {
+                method: "GET",
+                agent: false,
+                family: target.family,
+                headers: { Accept: "image/*" },
+                // 已校验地址用于实际连接, TLS 仍验证原始域名; 每次 redirect 都重新校验.
+                lookup: (_hostname, _options, callback) => callback(null, target.address, target.family),
+            }, (res) => {
+                if ([301, 302, 303, 307, 308].includes(res.statusCode ?? 0) &&
+                    res.headers.location) {
+                    res.destroy();
+                    try {
+                        resolve({
+                            redirect: new URL(res.headers.location, target.url).href,
+                        });
+                    }
+                    catch {
+                        fail();
+                    }
+                    return;
+                }
+                if (res.statusCode !== 200 ||
+                    Number(res.headers["content-length"] ?? 0) >
+                        MAX_MANAGED_IMAGE_BYTES ||
+                    !String(res.headers["content-type"] ?? "")
+                        .toLowerCase()
+                        .startsWith("image/")) {
+                    res.destroy();
+                    fail();
+                    return;
+                }
+                const chunks = [];
+                let size = 0;
+                res.on("data", (chunk) => {
+                    size += chunk.length;
+                    if (size > MAX_MANAGED_IMAGE_BYTES) {
+                        res.destroy();
+                        fail();
+                        return;
+                    }
+                    chunks.push(chunk);
+                });
+                res.on("end", () => resolve({ body: Buffer.concat(chunks) }));
+                res.on("error", fail);
+                res.on("aborted", fail);
+            });
+            const timer = setTimeout(() => {
+                req.destroy();
+                fail();
+            }, remaining);
+            req.on("close", () => clearTimeout(timer));
+            req.on("error", fail);
+            req.end();
+        });
+        if (response.body)
+            return response.body;
+        if (!response.redirect || redirects === 3)
+            throw new Error(DOWNLOAD_ERROR);
+        currentUrl = response.redirect;
+    }
+    throw new Error(DOWNLOAD_ERROR);
+}

package/dist/managed-files.d.ts

@@ -0,0 +1,35 @@
+export declare const MAX_MANAGED_IMAGE_BYTES: number;
+export declare function safeFilename(value: string): string;
+export declare function inspectImage(bytes: Uint8Array): Promise<import("file-type").FileTypeResult>;
+export declare class ManagedDirectory {
+    readonly path: string;
+    private readonly identity;
+    private constructor();
+    static create(path: string): Promise<ManagedDirectory>;
+    assertUnchanged(): Promise<void>;
+    writeAtomic(filename: string, bytes: Uint8Array, overwrite?: boolean): Promise<string>;
+    read(filename: string): Promise<NonSharedBuffer>;
+}
+export declare class ManagedFiles {
+    private readonly projectRoot;
+    private readonly projectIdentity;
+    private readonly extra;
+    private readonly output;
+    private constructor();
+    static create(input: {
+        projectRoot: string;
+        extraImagePaths: string[];
+        outputDirectory: string;
+    }): Promise<ManagedFiles>;
+    readImage(path: string): Promise<{
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        body: Blob;
+    }>;
+    saveImage(bytes: Uint8Array, relativePath?: string): Promise<{
+        path: string;
+        contentType: string;
+        sizeBytes: number;
+    }>;
+}

package/dist/managed-files.js

@@ -0,0 +1,240 @@
+import { spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { lstat, mkdir, open, realpath, stat } from "node:fs/promises";
+import { basename, isAbsolute, join, relative, sep } from "node:path";
+import { fileTypeFromBuffer } from "file-type";
+export const MAX_MANAGED_IMAGE_BYTES = 30 * 1024 * 1024;
+const IMAGE_TYPES = new Set([
+    "image/png",
+    "image/jpeg",
+    "image/webp",
+    "image/gif",
+    "image/bmp",
+    "image/tiff",
+    "image/heic",
+    "image/heif",
+    "image/avif",
+]);
+const PATH_ERROR = "图片不在已授权范围，请从 AI-HIVE 启动器选择图片";
+const OUTPUT_ERROR = "结果目录已变化，请从 AI-HIVE 启动器重新打开项目";
+export function safeFilename(value) {
+    if (!value ||
+        value.length > 200 ||
+        value === "." ||
+        value === ".." ||
+        /[\\/:\x00-\x1f\x7f]/.test(value) ||
+        /[. ]$/.test(value) ||
+        /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\.|$)/i.test(value)) {
+        throw new Error("请使用结果文件名，图片将保存在项目的 ai-hive-images 文件夹");
+    }
+    return value;
+}
+export async function inspectImage(bytes) {
+    if (!bytes.byteLength || bytes.byteLength > MAX_MANAGED_IMAGE_BYTES) {
+        throw new Error("图片大小超过限制，最大 30MiB");
+    }
+    const detected = await fileTypeFromBuffer(bytes).catch(() => undefined);
+    if (!detected || !IMAGE_TYPES.has(detected.mime)) {
+        throw new Error("暂不支持这张图片，请选择有效的图片文件");
+    }
+    return detected;
+}
+// 子进程的 cwd 由操作系统固定到目录 inode; 文件写入使用相对路径,
+// 防止校验后父目录被替换导致写入目录外. 不把任何账户密钥传给写入进程.
+const ATOMIC_WRITE_SCRIPT = `
+const fs=require('node:fs');const crypto=require('node:crypto');
+const [name,dev,ino,overwrite]=process.argv.slice(1);
+const current=fs.statSync('.');
+if(String(current.dev)!==dev||String(current.ino)!==ino){process.stdout.write('DIRECTORY_CHANGED');process.exit(1)}
+let temp='.hive-'+crypto.randomUUID()+'.tmp';let chunks=[];let total=0;
+process.stdin.on('data',chunk=>{total+=chunk.length;if(total>31457280){process.exit(1)}chunks.push(chunk)});
+process.stdin.on('end',()=>{try{
+const fd=fs.openSync(temp,'wx',0o600);try{fs.writeFileSync(fd,Buffer.concat(chunks));fs.fsyncSync(fd)}finally{fs.closeSync(fd)}
+if(overwrite==='true'){try{if(fs.lstatSync(name).isSymbolicLink())throw Error('SYMLINK')}catch(error){if(error.code!=='ENOENT')throw error}fs.renameSync(temp,name)}
+else{fs.linkSync(temp,name);fs.unlinkSync(temp)}
+process.stdout.write('OK');
+}catch(error){try{fs.unlinkSync(temp)}catch{}process.stdout.write(error.code==='EEXIST'?'EXISTS':'FAILED');process.exitCode=1}});
+`;
+export class ManagedDirectory {
+    path;
+    identity;
+    constructor(path, identity) {
+        this.path = path;
+        this.identity = identity;
+    }
+    static async create(path) {
+        if (!isAbsolute(path))
+            throw new Error(OUTPUT_ERROR);
+        await mkdir(path, { recursive: true, mode: 0o700 });
+        const information = await lstat(path);
+        if (!information.isDirectory() || information.isSymbolicLink())
+            throw new Error(OUTPUT_ERROR);
+        const canonical = await realpath(path);
+        return new ManagedDirectory(canonical, {
+            dev: information.dev,
+            ino: information.ino,
+        });
+    }
+    async assertUnchanged() {
+        const information = await lstat(this.path).catch(() => {
+            throw new Error(OUTPUT_ERROR);
+        });
+        if (!information.isDirectory() ||
+            information.isSymbolicLink() ||
+            information.dev !== this.identity.dev ||
+            information.ino !== this.identity.ino ||
+            (await realpath(this.path)) !== this.path) {
+            throw new Error(OUTPUT_ERROR);
+        }
+    }
+    async writeAtomic(filename, bytes, overwrite = false) {
+        safeFilename(filename);
+        await this.assertUnchanged();
+        if (bytes.byteLength > MAX_MANAGED_IMAGE_BYTES)
+            throw new Error("文件过大，请缩小后再试");
+        await new Promise((resolve, reject) => {
+            const child = spawn(process.execPath, [
+                "-e",
+                ATOMIC_WRITE_SCRIPT,
+                "--",
+                filename,
+                String(this.identity.dev),
+                String(this.identity.ino),
+                String(overwrite),
+            ], {
+                cwd: this.path,
+                windowsHide: true,
+                stdio: ["pipe", "pipe", "ignore"],
+                env: Object.fromEntries(Object.entries(process.env).filter(([name]) => !/KEY|TOKEN|SECRET|^(ELECTRON_RUN_AS_NODE|NODE_OPTIONS|NODE_PATH)$/i.test(name))),
+            });
+            let output = "";
+            child.stdout.on("data", (chunk) => {
+                output += chunk.toString();
+            });
+            child.stdin.on("error", () => { });
+            child.on("error", () => reject(new Error(OUTPUT_ERROR)));
+            child.on("close", (code) => code === 0 && output === "OK"
+                ? resolve()
+                : reject(new Error(output === "EXISTS"
+                    ? "文件已存在，请换一个文件名"
+                    : OUTPUT_ERROR)));
+            child.stdin.end(bytes);
+        });
+        await this.assertUnchanged();
+        return join(this.path, filename);
+    }
+    async read(filename) {
+        safeFilename(filename);
+        await this.assertUnchanged();
+        const file = await open(join(this.path, filename), constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        try {
+            const information = await file.stat();
+            if (!information.isFile() || information.size > MAX_MANAGED_IMAGE_BYTES)
+                throw new Error(OUTPUT_ERROR);
+            const result = await file.readFile();
+            await this.assertUnchanged();
+            return result;
+        }
+        finally {
+            await file.close();
+        }
+    }
+}
+export class ManagedFiles {
+    projectRoot;
+    projectIdentity;
+    extra;
+    output;
+    constructor(projectRoot, projectIdentity, extra, output) {
+        this.projectRoot = projectRoot;
+        this.projectIdentity = projectIdentity;
+        this.extra = extra;
+        this.output = output;
+    }
+    static async create(input) {
+        const projectRoot = await realpath(input.projectRoot);
+        const information = await stat(projectRoot);
+        if (!information.isDirectory())
+            throw new Error(PATH_ERROR);
+        const expectedOutput = join(projectRoot, "ai-hive-images");
+        const output = await ManagedDirectory.create(input.outputDirectory);
+        if (output.path !== expectedOutput)
+            throw new Error(OUTPUT_ERROR);
+        const extra = new Set();
+        for (const path of input.extraImagePaths) {
+            const canonical = await realpath(path);
+            if (!(await stat(canonical)).isFile())
+                throw new Error(PATH_ERROR);
+            extra.add(canonical);
+        }
+        return new ManagedFiles(projectRoot, { dev: information.dev, ino: information.ino }, extra, output);
+    }
+    async readImage(path) {
+        if (!isAbsolute(path))
+            throw new Error(PATH_ERROR);
+        const project = await stat(this.projectRoot);
+        if (project.dev !== this.projectIdentity.dev ||
+            project.ino !== this.projectIdentity.ino)
+            throw new Error(PATH_ERROR);
+        const canonical = await realpath(path).catch(() => {
+            throw new Error(PATH_ERROR);
+        });
+        const fromRoot = relative(this.projectRoot, canonical);
+        if (!(fromRoot &&
+            fromRoot !== ".." &&
+            !fromRoot.startsWith(`..${sep}`) &&
+            !isAbsolute(fromRoot)) &&
+            !this.extra.has(canonical))
+            throw new Error(PATH_ERROR);
+        const before = await lstat(path);
+        if (before.isSymbolicLink() || !before.isFile())
+            throw new Error(PATH_ERROR);
+        const file = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        try {
+            const information = await file.stat();
+            if (!information.isFile() ||
+                before.dev !== information.dev ||
+                before.ino !== information.ino ||
+                (await realpath(path)) !== canonical)
+                throw new Error(PATH_ERROR);
+            if (information.size > MAX_MANAGED_IMAGE_BYTES)
+                throw new Error("图片大小超过限制，最大 30MiB");
+            const bytes = Buffer.alloc(information.size);
+            let offset = 0;
+            while (offset < bytes.length) {
+                const read = await file.read(bytes, offset, bytes.length - offset, offset);
+                if (!read.bytesRead)
+                    throw new Error("图片已变化，请重新选择图片");
+                offset += read.bytesRead;
+            }
+            const after = await file.stat();
+            if (after.size !== information.size ||
+                after.mtimeMs !== information.mtimeMs ||
+                after.ctimeMs !== information.ctimeMs)
+                throw new Error("图片已变化，请重新选择图片");
+            const detected = await inspectImage(bytes);
+            return {
+                filename: basename(path),
+                contentType: detected.mime,
+                sizeBytes: bytes.length,
+                body: new Blob([bytes], { type: detected.mime }),
+            };
+        }
+        finally {
+            await file.close();
+        }
+    }
+    async saveImage(bytes, relativePath) {
+        const detected = await inspectImage(bytes);
+        const filename = safeFilename(relativePath ?? `image-${crypto.randomUUID()}.${detected.ext}`);
+        const extension = filename
+            .slice(filename.lastIndexOf(".") + 1)
+            .toLowerCase();
+        if (!(extension === detected.ext ||
+            (detected.ext === "jpg" && extension === "jpeg") ||
+            (detected.ext === "tif" && extension === "tiff")))
+            throw new Error("文件名的扩展名需要与图片格式一致");
+        const path = await this.output.writeAtomic(filename, bytes);
+        return { path, contentType: detected.mime, sizeBytes: bytes.length };
+    }
+}

package/dist/managed-images.d.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { AiHiveApiClient } from "./api-client.js";
+import type { BearerTokenProvider } from "./auth-token-provider.js";
+import type { McpManagedConfig } from "./managed-config.js";
+export declare const managedPrepareShape: {
+    publicModelId: z.ZodString;
+    routingMode: z.ZodEnum<["COST_FIRST", "SPEED_FIRST", "SUCCESS_FIRST"]>;
+    prompt: z.ZodEffects<z.ZodString, string, string>;
+    batchSize: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodNull]>, number, number | null>>;
+    imageMediaIds: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodNull]>, string[], string[] | null>>;
+    params: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodNull]>, Record<string, unknown>, Record<string, unknown> | null>>;
+};
+type ImageClient = Pick<AiHiveApiClient, "getUserInfo" | "listModels" | "getModel" | "generateImage" | "getGenerationTask" | "createMediaUpload" | "putUpload" | "completeMediaUpload">;
+export declare class ManagedImages {
+    private readonly config;
+    private readonly client;
+    private readonly tokenProvider;
+    private readonly files;
+    private readonly state;
+    private readonly download;
+    private constructor();
+    static create(input: {
+        config: McpManagedConfig;
+        client: ImageClient;
+        tokenProvider: BearerTokenProvider;
+        download?: (url: string) => Promise<Uint8Array>;
+    }): Promise<ManagedImages>;
+    getUserInfo(): Promise<Record<string, unknown>>;
+    listModels(input: {
+        detail?: "lite" | "full";
+    }): Promise<any[]>;
+    getModel(publicModelId: string, routingMode?: string): Promise<Record<string, unknown>>;
+    upload(path: string): Promise<unknown>;
+    prepare(input: unknown): Promise<{
+        operationId: `${string}-${string}-${string}-${string}-${string}`;
+        clientRequestId: `${string}-${string}-${string}-${string}-${string}`;
+    }>;
+    generate(operationId: string): Promise<{
+        operationId: string;
+    }>;
+    recover(operationId: string): Promise<{
+        operationId: string;
+    }>;
+    getTask(taskId: string): Promise<Record<string, unknown>>;
+    list(): Promise<{
+        operationId: string;
+        phase: "UNKNOWN" | "PREPARED" | "SUBMITTING" | "SUBMITTED" | "FAILED";
+        taskId: string | undefined;
+        prompt: string;
+        publicModelId: string;
+        createdAt: string;
+        estimatedReservationMicros: unknown;
+        savedResults: {
+            path: string;
+            itemId: string;
+        }[];
+    }[]>;
+    save(input: unknown): Promise<{
+        path: string;
+        contentType: string;
+        sizeBytes: number;
+        taskId: string;
+        itemId: string;
+    }>;
+    private recordSavedResult;
+    private readOperation;
+    private writeOperation;
+    private withOperationLock;
+}
+export {};