@nuwa-ai/cap-kit
Version:
345 lines (341 loc) • 11.9 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var index_exports = {};
__export(index_exports, {
CapCoreSchema: () => CapCoreSchema,
CapIDSchema: () => CapIDSchema,
CapKit: () => CapKit,
CapMcpServerConfigSchema: () => CapMcpServerConfigSchema,
CapMetadataSchema: () => CapMetadataSchema,
CapModelSchema: () => CapModelSchema,
CapPromptSchema: () => CapPromptSchema,
CapSchema: () => CapSchema,
CapThumbnailSchema: () => CapThumbnailSchema,
ResultCapMetadataSchema: () => ResultCapMetadataSchema
});
module.exports = __toCommonJS(index_exports);
var import_rooch_sdk = require("@roochnetwork/rooch-sdk");
var import_identity_kit2 = require("@nuwa-ai/identity-kit");
var yaml = __toESM(require("js-yaml"), 1);
// src/client.ts
var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp");
var import_identity_kit = require("@nuwa-ai/identity-kit");
var import_ai = require("ai");
var buildClient = async (mcpUrl, signer) => {
const keyId = (await signer.listKeyIds())[0];
const payload = {
operation: "mcp-json-rpc",
params: { body: {} }
};
const signedObject = await import_identity_kit.DIDAuth.v1.createSignature(payload, signer, keyId);
const authHeader = import_identity_kit.DIDAuth.v1.toAuthorizationHeader(signedObject);
const transport = new import_streamableHttp.StreamableHTTPClientTransport(
new URL(mcpUrl),
{
requestInit: {
headers: {
Authorization: authHeader
}
}
}
);
return await (0, import_ai.experimental_createMCPClient)({ transport });
};
// src/type.ts
var import_zod = require("zod");
var CapMcpServerConfigSchema = import_zod.z.object({
url: import_zod.z.string(),
transport: import_zod.z.enum(["httpStream", "sse"])
});
var CapModelSchema = import_zod.z.object({
id: import_zod.z.string(),
name: import_zod.z.string(),
slug: import_zod.z.string(),
providerName: import_zod.z.string(),
providerSlug: import_zod.z.string(),
description: import_zod.z.string(),
contextLength: import_zod.z.number(),
pricing: import_zod.z.object({
input_per_million_tokens: import_zod.z.number(),
output_per_million_tokens: import_zod.z.number(),
request_per_k_requests: import_zod.z.number(),
image_per_k_images: import_zod.z.number(),
web_search_per_k_searches: import_zod.z.number()
}),
supported_inputs: import_zod.z.array(import_zod.z.string()),
supported_parameters: import_zod.z.array(import_zod.z.string())
});
var CapPromptSchema = import_zod.z.object({
value: import_zod.z.string(),
suggestions: import_zod.z.array(import_zod.z.string()).optional()
});
var CapIDSchema = import_zod.z.object({
id: import_zod.z.string(),
authorDID: import_zod.z.string(),
idName: import_zod.z.string()
});
var CapCoreSchema = import_zod.z.object({
prompt: CapPromptSchema,
model: CapModelSchema,
mcpServers: import_zod.z.record(import_zod.z.string(), CapMcpServerConfigSchema)
});
var CapThumbnailSchema = import_zod.z.object({
type: import_zod.z.enum(["file", "url"]),
file: import_zod.z.string().optional(),
url: import_zod.z.string().optional()
}).nullable();
var CapMetadataSchema = import_zod.z.object({
displayName: import_zod.z.string(),
description: import_zod.z.string(),
tags: import_zod.z.array(import_zod.z.string()),
submittedAt: import_zod.z.number(),
homepage: import_zod.z.string().optional(),
repository: import_zod.z.string().optional(),
thumbnail: CapThumbnailSchema
});
var CapSchema = CapIDSchema.extend({
core: CapCoreSchema,
metadata: CapMetadataSchema
});
var ResultCapMetadataSchema = import_zod.z.object({
id: import_zod.z.string(),
cid: import_zod.z.string(),
name: import_zod.z.string(),
version: import_zod.z.string(),
displayName: import_zod.z.string(),
description: import_zod.z.string(),
tags: import_zod.z.array(import_zod.z.string()),
submittedAt: import_zod.z.number(),
homepage: import_zod.z.string().optional(),
repository: import_zod.z.string().optional(),
thumbnail: CapThumbnailSchema
});
// src/index.ts
var CapKit = class {
constructor(option) {
this.roochClient = new import_rooch_sdk.RoochClient({ url: option.roochUrl });
this.contractAddress = option.contractAddress;
this.mcpUrl = option.mcpUrl;
this.signer = option.signer;
}
async queryCapWithID(id, cid) {
const client = await buildClient(this.mcpUrl, this.signer);
try {
const tools = await client.tools();
const queryWithCID = tools.queryWithID;
if (!queryWithCID) {
throw new Error("Query with id tool not available on MCP server");
}
const result = await queryWithCID.execute({ id, cid }, {
toolCallId: "queryWithID",
messages: []
});
if (result.isError) {
throw new Error(result.content?.[0]?.text || "Unknown error");
}
const queryResult = JSON.parse(result.content[0].text);
if (queryResult.code !== 200 && queryResult.code !== 404) {
throw new Error(`Query with id failed: ${queryResult.error || "Unknown error"}`);
}
return queryResult;
} finally {
await client.close();
}
}
async queryWithName(name, tags, page, size) {
const client = await buildClient(this.mcpUrl, this.signer);
try {
const tools = await client.tools();
const queryWithName = tools.queryWithName;
if (!queryWithName) {
throw new Error("query tool not available on MCP server");
}
const result = await queryWithName.execute({
name,
tags,
page,
pageSize: size
}, {
toolCallId: "query-cap",
messages: []
});
if (result.isError) {
throw new Error(result.content?.[0]?.text || "Unknown error");
}
const queryResult = JSON.parse(result.content[0].text);
if (queryResult.code === 404) {
return {
code: 200,
data: {
totalItems: 0,
page: page || 0,
pageSize: size || 50,
items: []
}
};
}
if (queryResult.code !== 200) {
throw new Error(`query failed: ${queryResult.error || "Unknown error"}`);
}
const transformedItems = queryResult.data.items.map((item) => {
const thumbnailType = JSON.parse(item.thumbnail);
return {
id: item.id,
cid: item.cid,
name: item.name,
version: item.version,
displayName: item.display_name,
description: item.description,
tags: item.tags,
submittedAt: item.submitted_at,
homepage: item.homepage,
repository: item.repository,
thumbnail: thumbnailType
};
});
return {
code: queryResult.code,
data: {
totalItems: queryResult.data.totalItems,
page: queryResult.data.page,
pageSize: queryResult.data.pageSize,
items: transformedItems
}
};
} finally {
await client.close();
}
}
async downloadCapWithID(id, format) {
const result = await this.queryCapWithID(id);
if (result.code === 200) {
return this.downloadCapWithCID(result.data.cid, format);
} else {
throw new Error("Invalid Cap ID");
}
}
async downloadCapWithCID(cid, format) {
const client = await buildClient(this.mcpUrl, this.signer);
try {
const tools = await client.tools();
const downloadFile = tools.downloadFile;
if (!downloadFile) {
throw new Error("downloadFile tool not available on MCP server");
}
const result = await downloadFile.execute({
cid,
dataFormat: format
}, {
toolCallId: "download-cap",
messages: []
});
if (result.isError) {
throw new Error(result.content?.[0]?.text || "Unknown error");
}
const downloadResult = JSON.parse(result.content[0].text);
if (downloadResult.code !== 200) {
throw new Error(`Download failed: ${downloadResult.error || "Unknown error"}`);
}
return yaml.load(downloadResult.data.fileData);
} finally {
await client.close();
}
}
async registerCap(cap) {
if (!/^[a-zA-Z0-9_]{6,20}$/.test(cap.idName)) {
throw new Error("Name must be between 6 and 20 characters and only contain a-z, A-Z, 0-9, _");
}
const acpContent = yaml.dump(cap);
const cid = await this.uploadToIPFS(cap.id, acpContent, this.signer);
const result = await this.registerOnChain(cap.idName, cid, this.signer);
if (result.execution_info.status.type !== "executed") {
throw new Error("unknown error");
}
return cid;
}
async uploadToIPFS(name, content, signer) {
const client = await buildClient(this.mcpUrl, signer);
try {
const tools = await client.tools();
const uploadTool = tools.uploadFile;
if (!uploadTool) {
throw new Error("uploadFile tool not available on MCP server");
}
const fileData = Buffer.from(content, "utf8").toString("base64");
const fileName = `${name}.cap.yaml`;
const result = await uploadTool.execute({
fileName,
fileData
}, {
toolCallId: "upload-cap",
messages: []
});
if (result.isError) {
throw new Error(result.content?.[0]?.text || "Unknown error");
}
const uploadResult = JSON.parse(result.content[0].text);
const uploadData = uploadResult.data;
if (uploadResult.code !== 200 || !uploadData.ipfsCid) {
throw new Error(`Upload failed: ${uploadResult.error || "Unknown error"}`);
}
return uploadData.ipfsCid;
} finally {
await client.close();
}
}
async registerOnChain(name, cid, signer) {
const chainSigner = await import_identity_kit2.DidAccountSigner.create(signer);
const transaction = new import_rooch_sdk.Transaction();
transaction.callFunction({
target: `${this.contractAddress}::acp_registry::register`,
typeArgs: [],
args: [import_rooch_sdk.Args.string(name), import_rooch_sdk.Args.string(cid)],
maxGas: 5e8
});
return await this.roochClient.signAndExecuteTransaction({
transaction,
signer: chainSigner
});
}
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
CapCoreSchema,
CapIDSchema,
CapKit,
CapMcpServerConfigSchema,
CapMetadataSchema,
CapModelSchema,
CapPromptSchema,
CapSchema,
CapThumbnailSchema,
ResultCapMetadataSchema
});
//# sourceMappingURL=index.cjs.map