@infimind-next/ai-hive-mcp 0.1.0

package/dist/api-client.d.ts

@@ -0,0 +1,32 @@
+type FetchImpl = typeof fetch;
+export declare class AiHiveApiClient {
+    private readonly endpoint;
+    private readonly key;
+    private readonly timeoutMs;
+    private readonly fetchImpl;
+    constructor(input: {
+        endpoint: string;
+        key: string;
+        timeoutMs: number;
+        fetchImpl?: FetchImpl;
+    });
+    private withTimeout;
+    private request;
+    getUserInfo(): Promise<unknown>;
+    listModels(input: Record<string, unknown>): Promise<unknown>;
+    createMediaUpload(input: unknown): Promise<unknown>;
+    completeMediaUpload(mediaId: string): Promise<unknown>;
+    chatText(input: unknown): Promise<unknown>;
+    generateImage(input: unknown): Promise<unknown>;
+    generateVideo(input: unknown): Promise<unknown>;
+    getGenerationTask(input: {
+        taskId: string;
+    }): Promise<unknown>;
+    putUpload(input: {
+        url: string;
+        method: "PUT";
+        headers: Record<string, string>;
+        body: BodyInit;
+    }): Promise<void>;
+}
+export {};

package/dist/api-client.js

@@ -0,0 +1,143 @@
+function formatIssue(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "object" && value !== null) {
+        const issue = value;
+        if (typeof issue.message === "string") {
+            const path = Array.isArray(issue.path)
+                ? issue.path.map(String).join(".")
+                : "";
+            return path ? `${path}: ${issue.message}` : issue.message;
+        }
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+function errorMessage(body) {
+    if (typeof body !== "object" || body === null) {
+        return "请求失败";
+    }
+    const message = body.message;
+    if (typeof message === "string") {
+        return message;
+    }
+    if (Array.isArray(message)) {
+        return message.map(formatIssue).join("; ");
+    }
+    if (typeof message === "object" && message !== null) {
+        return formatIssue(message);
+    }
+    return "请求失败";
+}
+function timeoutError() {
+    return new Error("请求超时，请稍后重试");
+}
+export class AiHiveApiClient {
+    endpoint;
+    key;
+    timeoutMs;
+    fetchImpl;
+    constructor(input) {
+        this.endpoint = input.endpoint.replace(/\/+$/, "");
+        this.key = input.key;
+        this.timeoutMs = input.timeoutMs;
+        this.fetchImpl = input.fetchImpl ?? fetch;
+    }
+    async withTimeout(operation) {
+        const controller = new AbortController();
+        let timeout;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeout = setTimeout(() => {
+                controller.abort();
+                reject(timeoutError());
+            }, this.timeoutMs);
+        });
+        try {
+            return await Promise.race([operation(controller.signal), timeoutPromise]);
+        }
+        catch (error) {
+            if (controller.signal.aborted) {
+                throw timeoutError();
+            }
+            throw error;
+        }
+        finally {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+        }
+    }
+    async request(path, init = {}) {
+        return this.withTimeout(async (signal) => {
+            const response = await this.fetchImpl(`${this.endpoint}${path}`, {
+                ...init,
+                signal,
+                headers: {
+                    Authorization: `Bearer ${this.key}`,
+                    ...(init.body ? { "Content-Type": "application/json" } : {}),
+                    ...init.headers,
+                },
+            });
+            const body = await response.json().catch(() => ({}));
+            if (!response.ok) {
+                throw new Error(errorMessage(body));
+            }
+            return body;
+        });
+    }
+    getUserInfo() {
+        return this.request("/mcp/user-info");
+    }
+    listModels(input) {
+        const query = typeof input.modelType === "string"
+            ? `?modelType=${encodeURIComponent(input.modelType)}`
+            : "";
+        return this.request(`/mcp/models${query}`);
+    }
+    createMediaUpload(input) {
+        return this.request("/mcp/media/upload-token", {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    completeMediaUpload(mediaId) {
+        return this.request(`/mcp/media/${encodeURIComponent(mediaId)}/complete`, {
+            method: "POST",
+        });
+    }
+    chatText(input) {
+        return this.request("/mcp/chat/text", {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    generateImage(input) {
+        return this.request("/mcp/generation/image", {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    generateVideo(input) {
+        return this.request("/mcp/generation/video", {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    getGenerationTask(input) {
+        return this.request(`/mcp/generation/tasks/${encodeURIComponent(input.taskId)}`);
+    }
+    async putUpload(input) {
+        await this.withTimeout(async (signal) => {
+            const response = await this.fetchImpl(input.url, {
+                method: input.method,
+                headers: input.headers,
+                body: input.body,
+                signal,
+            });
+            if (!response.ok) {
+                throw new Error("文件上传失败，请稍后重试");
+            }
+        });
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,10 @@
+export type McpClientConfig = {
+    endpoint: string;
+    key: string | null;
+    timeoutMs: number;
+    verbose: boolean;
+};
+export declare function parseConfig(input: {
+    argv: string[];
+    env: Record<string, string | undefined>;
+}): McpClientConfig;

package/dist/config.js

@@ -0,0 +1,31 @@
+const DEFAULT_ENDPOINT = "https://ai-hive.iclip.cn/api";
+export function parseConfig(input) {
+    const args = input.argv.slice(2);
+    const values = new Map();
+    const flags = new Set();
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg?.startsWith("--")) {
+            continue;
+        }
+        const name = arg.slice(2);
+        if (name === "verbose") {
+            flags.add(name);
+            continue;
+        }
+        const value = args[index + 1];
+        if (value && !value.startsWith("--")) {
+            values.set(name, value);
+            index += 1;
+        }
+    }
+    const timeoutMs = Number.parseInt(values.get("timeout-ms") ?? input.env.AI_HIVE_MCP_TIMEOUT_MS ?? "120000", 10);
+    return {
+        endpoint: values.get("endpoint") ??
+            input.env.AI_HIVE_API_ENDPOINT ??
+            DEFAULT_ENDPOINT,
+        key: values.get("key") ?? input.env.AI_HIVE_MCP_KEY ?? null,
+        timeoutMs: Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 120000,
+        verbose: flags.has("verbose") || input.env.AI_HIVE_MCP_VERBOSE === "true",
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { parseConfig } from "./config.js";
+import { runServer } from "./server.js";
+const config = parseConfig({ argv: process.argv, env: process.env });
+runServer(config).catch((error) => {
+    const message = error instanceof Error ? error.message : "MCP 启动失败";
+    console.error(message);
+    process.exitCode = 1;
+});

package/dist/local-media.d.ts

@@ -0,0 +1,3 @@
+import { type McpUploadMediaFromPathInput } from "./schemas.js";
+import type { AiHiveApiClient } from "./api-client.js";
+export declare function uploadMediaFromPath(api: AiHiveApiClient, rawInput: McpUploadMediaFromPathInput): Promise<unknown>;

package/dist/local-media.js

@@ -0,0 +1,99 @@
+import { openAsBlob } from "node:fs";
+import { open, stat } from "node:fs/promises";
+import { basename } from "node:path";
+import { mcpCreateMediaUploadOutputSchema, mcpUploadMediaFromPathInputSchema, } from "./schemas.js";
+import { fileTypeFromBuffer } from "file-type";
+const FILE_HEAD_BYTES = 4100;
+const SMALL_MEDIA_LIMIT_BYTES = 10 * 1024 * 1024;
+const VIDEO_LIMIT_BYTES = 100 * 1024 * 1024;
+const EXTENSION_MIME = new Map([
+    [".png", "image/png"],
+    [".jpg", "image/jpeg"],
+    [".jpeg", "image/jpeg"],
+    [".webp", "image/webp"],
+    [".mp4", "video/mp4"],
+    [".webm", "video/webm"],
+    [".mov", "video/quicktime"],
+    [".pdf", "application/pdf"],
+    [".txt", "text/plain"],
+    [".md", "text/markdown"],
+    [".csv", "text/csv"],
+    [".json", "application/json"],
+    [
+        ".docx",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ],
+    [
+        ".xlsx",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ],
+]);
+function extensionMime(filename) {
+    const lower = filename.toLowerCase();
+    for (const [extension, contentType] of EXTENSION_MIME) {
+        if (lower.endsWith(extension)) {
+            return contentType;
+        }
+    }
+    return undefined;
+}
+function mediaSizeLimit(contentType) {
+    if (contentType.startsWith("video/")) {
+        return VIDEO_LIMIT_BYTES;
+    }
+    return SMALL_MEDIA_LIMIT_BYTES;
+}
+function assertFileSizeAllowed(sizeBytes, contentType) {
+    const limit = mediaSizeLimit(contentType);
+    if (sizeBytes > limit) {
+        throw new Error(`文件大小超过限制，${contentType.startsWith("video/") ? "视频" : "图片/文档"}最大 ${Math.floor(limit / 1024 / 1024)}MiB`);
+    }
+}
+async function readFileHead(path) {
+    const file = await open(path, "r").catch(() => {
+        throw new Error("文件读取失败，请检查权限");
+    });
+    try {
+        const buffer = Buffer.alloc(FILE_HEAD_BYTES);
+        const { bytesRead } = await file.read(buffer, 0, FILE_HEAD_BYTES, 0);
+        return buffer.subarray(0, bytesRead);
+    }
+    finally {
+        await file.close();
+    }
+}
+export async function uploadMediaFromPath(api, rawInput) {
+    const input = mcpUploadMediaFromPathInputSchema.parse(rawInput);
+    const stats = await stat(input.path).catch(() => {
+        throw new Error("文件不存在，请检查路径");
+    });
+    if (!stats.isFile()) {
+        throw new Error("当前路径不是可上传文件");
+    }
+    const filename = input.filename ?? basename(input.path);
+    const extensionContentType = extensionMime(filename);
+    const preliminaryContentType = input.contentType ?? extensionContentType;
+    if (preliminaryContentType) {
+        assertFileSizeAllowed(stats.size, preliminaryContentType);
+    }
+    const head = await readFileHead(input.path);
+    const detected = await fileTypeFromBuffer(head);
+    const contentType = input.contentType ?? detected?.mime ?? extensionContentType;
+    if (!contentType) {
+        throw new Error("暂不支持该文件类型");
+    }
+    assertFileSizeAllowed(stats.size, contentType);
+    const upload = mcpCreateMediaUploadOutputSchema.parse(await api.createMediaUpload({
+        filename,
+        contentType,
+        sizeBytes: stats.size,
+    }));
+    const body = await openAsBlob(input.path, { type: contentType });
+    await api.putUpload({
+        url: upload.upload.url,
+        method: upload.upload.method,
+        headers: upload.upload.headers,
+        body,
+    });
+    return api.completeMediaUpload(upload.mediaId);
+}

package/dist/schemas.d.ts

@@ -0,0 +1,103 @@
+import { z } from "zod";
+export declare const mcpCreateMediaUploadOutputSchema: z.ZodObject<{
+    mediaId: z.ZodString;
+    mediaType: z.ZodEnum<["IMAGE", "VIDEO", "DOCUMENT"]>;
+    mimeType: z.ZodEffects<z.ZodString, string, string>;
+    sizeBytes: z.ZodNumber;
+    upload: z.ZodObject<{
+        url: z.ZodString;
+        method: z.ZodLiteral<"PUT">;
+        headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        method: "PUT";
+        headers: Record<string, string>;
+        url: string;
+    }, {
+        method: "PUT";
+        headers: Record<string, string>;
+        url: string;
+    }>;
+    expiresAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    mediaId: string;
+    mediaType: "IMAGE" | "VIDEO" | "DOCUMENT";
+    mimeType: string;
+    sizeBytes: number;
+    upload: {
+        method: "PUT";
+        headers: Record<string, string>;
+        url: string;
+    };
+    expiresAt: string;
+}, {
+    mediaId: string;
+    mediaType: "IMAGE" | "VIDEO" | "DOCUMENT";
+    mimeType: string;
+    sizeBytes: number;
+    upload: {
+        method: "PUT";
+        headers: Record<string, string>;
+        url: string;
+    };
+    expiresAt: string;
+}>;
+export declare const mcpUploadMediaFromPathInputSchema: z.ZodObject<{
+    path: z.ZodEffects<z.ZodString, string, string>;
+    filename: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    contentType: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    filename?: string | undefined;
+    contentType?: string | undefined;
+}, {
+    path: string;
+    filename?: string | undefined;
+    contentType?: string | undefined;
+}>;
+export declare const listModelsShape: {
+    modelType: z.ZodOptional<z.ZodEnum<["TEXT", "IMAGE", "VIDEO"]>>;
+};
+export declare const chatTextShape: {
+    publicModelId: z.ZodString;
+    routingMode: z.ZodEnum<["COST_FIRST", "SPEED_FIRST", "SUCCESS_FIRST"]>;
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<["system", "user", "assistant"]>;
+        content: z.ZodEffects<z.ZodString, string, string>;
+        mediaIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        role: "system" | "user" | "assistant";
+        content: string;
+        mediaIds: string[];
+    }, {
+        role: "system" | "user" | "assistant";
+        content: string;
+        mediaIds?: string[] | undefined;
+    }>, "many">;
+    thinkingEnabled: z.ZodOptional<z.ZodBoolean>;
+    attachmentIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    pricingSnapshot: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+};
+export declare const generateImageShape: {
+    publicModelId: z.ZodString;
+    routingMode: z.ZodEnum<["COST_FIRST", "SPEED_FIRST", "SUCCESS_FIRST"]>;
+    prompt: z.ZodEffects<z.ZodString, string, string>;
+    batchSize: z.ZodDefault<z.ZodNumber>;
+    imageMediaIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    pricingSnapshot: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+};
+export declare const generateVideoShape: {
+    publicModelId: z.ZodString;
+    routingMode: z.ZodEnum<["COST_FIRST", "SPEED_FIRST", "SUCCESS_FIRST"]>;
+    prompt: z.ZodEffects<z.ZodString, string, string>;
+    imageMediaIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    videoMediaIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    firstFrameMediaId: z.ZodOptional<z.ZodString>;
+    lastFrameMediaId: z.ZodOptional<z.ZodString>;
+    params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    pricingSnapshot: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+};
+export declare const getGenerationTaskShape: {
+    taskId: z.ZodString;
+};
+export type McpUploadMediaFromPathInput = z.infer<typeof mcpUploadMediaFromPathInputSchema>;

package/dist/schemas.js

@@ -0,0 +1,78 @@
+import { z } from "zod";
+const nonBlankStringSchema = z
+    .string()
+    .refine((value) => value.trim().length > 0, {
+    message: "Expected non-blank string",
+});
+const mediaIdSchema = z.string().min(1);
+const routingModeSchema = z.enum([
+    "COST_FIRST",
+    "SPEED_FIRST",
+    "SUCCESS_FIRST",
+]);
+const pricingSnapshotSchema = z.record(z.unknown());
+const paramsSchema = z.record(z.unknown()).default({});
+export const mcpCreateMediaUploadOutputSchema = z
+    .object({
+    mediaId: mediaIdSchema,
+    mediaType: z.enum(["IMAGE", "VIDEO", "DOCUMENT"]),
+    mimeType: nonBlankStringSchema,
+    sizeBytes: z.number().int().positive(),
+    upload: z
+        .object({
+        url: z.string().url(),
+        method: z.literal("PUT"),
+        headers: z.record(z.string().min(1), z.string().min(1)),
+    })
+        .strict(),
+    expiresAt: z.string().datetime(),
+})
+    .strict();
+export const mcpUploadMediaFromPathInputSchema = z
+    .object({
+    path: nonBlankStringSchema,
+    filename: nonBlankStringSchema.optional(),
+    contentType: nonBlankStringSchema.optional(),
+})
+    .strict();
+const messageSchema = z
+    .object({
+    role: z.enum(["system", "user", "assistant"]),
+    content: nonBlankStringSchema,
+    mediaIds: z.array(mediaIdSchema).default([]),
+})
+    .strict();
+export const listModelsShape = {
+    modelType: z.enum(["TEXT", "IMAGE", "VIDEO"]).optional(),
+};
+export const chatTextShape = {
+    publicModelId: z.string().min(1),
+    routingMode: routingModeSchema,
+    messages: z.array(messageSchema).min(1),
+    thinkingEnabled: z.boolean().optional(),
+    attachmentIds: z.array(z.string().min(1)).default([]),
+    pricingSnapshot: pricingSnapshotSchema,
+};
+export const generateImageShape = {
+    publicModelId: z.string().min(1),
+    routingMode: routingModeSchema,
+    prompt: nonBlankStringSchema,
+    batchSize: z.number().int().min(1).max(10).default(1),
+    imageMediaIds: z.array(mediaIdSchema).default([]),
+    params: paramsSchema,
+    pricingSnapshot: pricingSnapshotSchema,
+};
+export const generateVideoShape = {
+    publicModelId: z.string().min(1),
+    routingMode: routingModeSchema,
+    prompt: nonBlankStringSchema,
+    imageMediaIds: z.array(mediaIdSchema).default([]),
+    videoMediaIds: z.array(mediaIdSchema).default([]),
+    firstFrameMediaId: mediaIdSchema.optional(),
+    lastFrameMediaId: mediaIdSchema.optional(),
+    params: paramsSchema,
+    pricingSnapshot: pricingSnapshotSchema,
+};
+export const getGenerationTaskShape = {
+    taskId: z.string().min(1),
+};

package/dist/server.d.ts

@@ -0,0 +1,27 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { AiHiveApiClient } from "./api-client.js";
+declare function content(value: unknown): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+type ApiClientLike = Pick<AiHiveApiClient, "getUserInfo" | "listModels" | "createMediaUpload" | "completeMediaUpload" | "chatText" | "generateImage" | "generateVideo" | "getGenerationTask" | "putUpload">;
+export type ToolDefinition = {
+    name: string;
+    schema: z.ZodRawShape;
+    handler: (args: Record<string, unknown>) => Promise<ReturnType<typeof content>>;
+};
+export declare function createToolDefinitions(client: () => ApiClientLike): ToolDefinition[];
+export declare function createServer(input: {
+    endpoint: string;
+    key: string | null;
+    timeoutMs: number;
+}): McpServer;
+export declare function runServer(input: {
+    endpoint: string;
+    key: string | null;
+    timeoutMs: number;
+}): Promise<void>;
+export {};

package/dist/server.js

@@ -0,0 +1,78 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { chatTextShape, generateImageShape, generateVideoShape, getGenerationTaskShape, listModelsShape, } from "./schemas.js";
+import { z } from "zod";
+import { AiHiveApiClient } from "./api-client.js";
+import { uploadMediaFromPath } from "./local-media.js";
+function requireKey(key) {
+    if (!key) {
+        throw new Error("MCP API Key 未配置，请在配置中传入 --key 或 AI_HIVE_MCP_KEY");
+    }
+    return key;
+}
+function content(value) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(value) }],
+    };
+}
+export function createToolDefinitions(client) {
+    return [
+        {
+            name: "get_user_info",
+            schema: {},
+            handler: async () => content(await client().getUserInfo()),
+        },
+        {
+            name: "list_models",
+            schema: listModelsShape,
+            handler: async (args) => content(await client().listModels(args)),
+        },
+        {
+            name: "upload_media_from_path",
+            schema: {
+                path: z.string().min(1),
+                filename: z.string().min(1).optional(),
+                contentType: z.string().min(1).optional(),
+            },
+            handler: async (args) => content(await uploadMediaFromPath(client(), args)),
+        },
+        {
+            name: "chat_text",
+            schema: chatTextShape,
+            handler: async (args) => content(await client().chatText(args)),
+        },
+        {
+            name: "generate_image",
+            schema: generateImageShape,
+            handler: async (args) => content(await client().generateImage(args)),
+        },
+        {
+            name: "generate_video",
+            schema: generateVideoShape,
+            handler: async (args) => content(await client().generateVideo(args)),
+        },
+        {
+            name: "get_generation_task",
+            schema: getGenerationTaskShape,
+            handler: async (args) => content(await client().getGenerationTask({
+                taskId: String(args.taskId),
+            })),
+        },
+    ];
+}
+export function createServer(input) {
+    const server = new McpServer({ name: "ai-hive", version: "0.1.0" });
+    const client = () => new AiHiveApiClient({
+        endpoint: input.endpoint,
+        key: requireKey(input.key),
+        timeoutMs: input.timeoutMs,
+    });
+    for (const tool of createToolDefinitions(client)) {
+        server.tool(tool.name, tool.schema, tool.handler);
+    }
+    return server;
+}
+export async function runServer(input) {
+    const server = createServer(input);
+    await server.connect(new StdioServerTransport());
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@infimind-next/ai-hive-mcp",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "ai-hive-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "eslint \"src/**/*.ts\"",
+    "prepack": "pnpm run build",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "file-type": "^22.0.1",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
+  }
+}