@aigne/aigne-hub 0.4.8 → 0.5.0

package/lib/esm/util/credential.js

@@ -0,0 +1,211 @@
+import { logger } from "@aigne/core/utils/logger.js";
+import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
+import inquirer from "inquirer";
+import open from "open";
+import pWaitFor from "p-wait-for";
+import { joinURL, withQuery } from "ufo";
+import { parse, stringify } from "yaml";
+import { ACCESS_KEY_SESSION_API, AGENT_HUB_PROVIDER, AIGNE_ENV_FILE, AIGNE_HUB_DID, AIGNE_HUB_URL as DEFAULT_AIGNE_HUB_URL, isTest, WELLKNOWN_SERVICE_PATH_PREFIX, } from "./constants.js";
+import { decrypt, encodeEncryptionKey } from "./crypto.js";
+const request = async (config) => {
+    const headers = {};
+    if (config.requestCount !== undefined) {
+        headers["X-Request-Count"] = config.requestCount.toString();
+    }
+    const response = await fetch(config.url, { method: config.method || "GET", headers });
+    if (!response.ok)
+        throw new Error(`HTTP error! status: ${response.status}`);
+    const data = await response.json();
+    return { data };
+};
+export const fetchConfigs = async ({ connectUrl, sessionId, fetchInterval, fetchTimeout, }) => {
+    const sessionURL = withQuery(joinURL(connectUrl, ACCESS_KEY_SESSION_API), { sid: sessionId });
+    let requestCount = 0;
+    const condition = async () => {
+        const { data: session } = await request({ url: sessionURL, requestCount });
+        requestCount++;
+        return Boolean(session.accessKeyId && session.accessKeySecret);
+    };
+    await pWaitFor(condition, { interval: fetchInterval, timeout: fetchTimeout });
+    const { data: session } = await request({ url: sessionURL, requestCount });
+    await request({ url: sessionURL, method: "DELETE" });
+    return {
+        ...session,
+        accessKeyId: session.accessKeyId,
+        accessKeySecret: decrypt(session.accessKeySecret, session.accessKeyId, session.challenge),
+    };
+};
+function baseWrapSpinner(_, waiting) {
+    return Promise.resolve(waiting());
+}
+export async function createConnect({ connectUrl, openPage, fetchInterval = 3 * 1000, retry = 1500, source = "Blocklet CLI", connectAction = "connect-cli", wrapSpinner = baseWrapSpinner, closeOnSuccess, intervalFetchConfig, appName = "AIGNE CLI", appLogo = "https://www.aigne.io/favicon.ico?imageFilter=resize&w=32", }) {
+    const startSessionURL = joinURL(connectUrl, ACCESS_KEY_SESSION_API);
+    const { data: session } = await request({ url: startSessionURL, method: "POST" });
+    const token = session.id;
+    const pageUrl = withQuery(joinURL(connectUrl, connectAction), {
+        __token__: encodeEncryptionKey(token),
+        source,
+        closeOnSuccess,
+        cli: true,
+        appName: ` ${appName}`,
+        appLogo,
+    });
+    openPage?.(pageUrl);
+    return await wrapSpinner(`Waiting for connection: ${connectUrl}`, async () => {
+        const checkAuthorizeStatus = intervalFetchConfig ?? fetchConfigs;
+        const authorizeStatus = await checkAuthorizeStatus({
+            connectUrl,
+            sessionId: token,
+            fetchTimeout: retry * fetchInterval,
+            fetchInterval: retry,
+        });
+        return authorizeStatus;
+    });
+}
+export async function getAIGNEHubMountPoint(url) {
+    const { origin } = new URL(url);
+    const BLOCKLET_JSON_PATH = "__blocklet__.js?type=json";
+    const blockletInfo = await fetch(joinURL(origin, BLOCKLET_JSON_PATH));
+    const blocklet = await blockletInfo.json();
+    const aigneHubMount = (blocklet?.componentMountPoints || []).find((m) => m.did === AIGNE_HUB_DID);
+    return joinURL(origin, aigneHubMount?.mountPoint || "");
+}
+export async function connectToAIGNEHub(url) {
+    const { origin, host } = new URL(url);
+    const connectUrl = joinURL(origin, WELLKNOWN_SERVICE_PATH_PREFIX);
+    const urlWithAIGNEHubMountPoint = await getAIGNEHubMountPoint(url);
+    try {
+        const openFn = isTest ? () => { } : open;
+        const result = await createConnect({
+            connectUrl: connectUrl,
+            connectAction: "gen-simple-access-key",
+            source: `@aigne/cli connect to AIGNE hub`,
+            closeOnSuccess: true,
+            openPage: (pageUrl) => openFn(pageUrl),
+        });
+        const accessKeyOptions = {
+            apiKey: result.accessKeySecret,
+            url: urlWithAIGNEHubMountPoint,
+        };
+        // After redirection, write the AIGNE Hub access token
+        const aigneDir = nodejs.path.join(nodejs.os.homedir(), ".aigne");
+        if (!nodejs.fsSync.existsSync(aigneDir)) {
+            nodejs.fsSync.mkdirSync(aigneDir, { recursive: true });
+        }
+        const envs = parse(await nodejs.fs.readFile(AIGNE_ENV_FILE, "utf8").catch(() => stringify({})));
+        await nodejs.fs.writeFile(AIGNE_ENV_FILE, stringify({
+            ...envs,
+            [host]: {
+                AIGNE_HUB_API_KEY: accessKeyOptions.apiKey,
+                AIGNE_HUB_API_URL: accessKeyOptions.url,
+            },
+            default: {
+                AIGNE_HUB_API_URL: accessKeyOptions.url,
+            },
+        }));
+        return accessKeyOptions;
+    }
+    catch (error) {
+        logger.error("Failed to connect to AIGNE Hub", error.message);
+        return { apiKey: undefined, url: undefined };
+    }
+}
+export const checkConnectionStatus = async (host) => {
+    // aigne-hub access token
+    if (!nodejs.fsSync.existsSync(AIGNE_ENV_FILE)) {
+        throw new Error("AIGNE_HUB_API_KEY file not found, need to login first");
+    }
+    const data = await nodejs.fs.readFile(AIGNE_ENV_FILE, "utf8");
+    if (!data.includes("AIGNE_HUB_API_KEY")) {
+        throw new Error("AIGNE_HUB_API_KEY key not found, need to login first");
+    }
+    const envs = parse(data);
+    if (!envs[host]) {
+        throw new Error("AIGNE_HUB_API_KEY host not found, need to login first");
+    }
+    const env = envs[host];
+    if (!env.AIGNE_HUB_API_KEY) {
+        throw new Error("AIGNE_HUB_API_KEY key not found, need to login first");
+    }
+    return {
+        apiKey: env.AIGNE_HUB_API_KEY,
+        url: joinURL(env.AIGNE_HUB_API_URL),
+    };
+};
+export async function loadCredential(options) {
+    const isBlocklet = process.env.BLOCKLET_AIGNE_API_URL && process.env.BLOCKLET_AIGNE_API_PROVIDER;
+    if (isBlocklet)
+        return undefined;
+    const aigneDir = nodejs.path.join(nodejs.os.homedir(), ".aigne");
+    if (!nodejs.fsSync.existsSync(aigneDir)) {
+        nodejs.fsSync.mkdirSync(aigneDir, { recursive: true });
+    }
+    const envs = parse(await nodejs.fs.readFile(AIGNE_ENV_FILE, "utf8").catch(() => stringify({})));
+    const inquirerPrompt = (options?.inquirerPromptFn ?? inquirer.prompt);
+    const configUrl = options?.aigneHubUrl || process.env.AIGNE_HUB_API_URL;
+    const AIGNE_HUB_URL = configUrl || envs?.default?.AIGNE_HUB_API_URL || DEFAULT_AIGNE_HUB_URL;
+    const connectUrl = joinURL(new URL(AIGNE_HUB_URL).origin, WELLKNOWN_SERVICE_PATH_PREFIX);
+    const { host } = new URL(AIGNE_HUB_URL);
+    const modelName = options?.model || "";
+    const isAIGNEHubModel = (modelName.toLocaleLowerCase() || "").includes(AGENT_HUB_PROVIDER);
+    let credential = {};
+    if (isAIGNEHubModel) {
+        try {
+            credential = await checkConnectionStatus(host);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes("login first")) {
+                let aigneHubUrl = connectUrl;
+                if (!configUrl) {
+                    const { subscribe } = await inquirerPrompt({
+                        type: "list",
+                        name: "subscribe",
+                        message: "No LLM API Keys or AIGNE Hub connections found. How would you like to proceed?",
+                        choices: [
+                            {
+                                name: "Connect to the Arcblock official AIGNE Hub (recommended, free credits for new users)",
+                                value: "official",
+                            },
+                            connectUrl.includes(DEFAULT_AIGNE_HUB_URL)
+                                ? {
+                                    name: "Connect to your own AIGNE Hub instance (self-hosted)",
+                                    value: "custom",
+                                }
+                                : null,
+                            {
+                                name: "Exit and configure my own LLM API Keys",
+                                value: "manual",
+                            },
+                        ].filter(Boolean),
+                        default: "official",
+                    });
+                    if (subscribe === "custom") {
+                        const { customUrl } = await inquirerPrompt({
+                            type: "input",
+                            name: "customUrl",
+                            message: "Enter the URL of your AIGNE Hub:",
+                            validate(input) {
+                                try {
+                                    const url = new URL(input);
+                                    return url.protocol.startsWith("http")
+                                        ? true
+                                        : "Must be a valid URL with http or https";
+                                }
+                                catch {
+                                    return "Invalid URL";
+                                }
+                            },
+                        });
+                        aigneHubUrl = customUrl;
+                    }
+                    else if (subscribe === "manual") {
+                        console.log("You chose to configure your own LLM API Keys. Exiting...");
+                        process.exit(0);
+                    }
+                }
+                credential = await connectToAIGNEHub(aigneHubUrl);
+            }
+        }
+    }
+    return credential;
+}

package/lib/esm/util/crypto.d.ts

@@ -0,0 +1,4 @@
+export declare const decrypt: (m: string, s: string, i: string) => string;
+export declare const encrypt: (m: string, s: string, i: string) => string;
+export declare const encodeEncryptionKey: (key: string) => string;
+export declare const decodeEncryptionKey: (str: string) => Uint8Array<ArrayBuffer>;

package/lib/esm/util/crypto.js

@@ -0,0 +1,9 @@
+import crypto from "node:crypto";
+import { AesCrypter } from "@ocap/mcrypto/lib/crypter/aes-legacy.js";
+const aes = new AesCrypter();
+export const decrypt = (m, s, i) => aes.decrypt(m, crypto.pbkdf2Sync(i, s, 256, 32, "sha512").toString("hex"));
+export const encrypt = (m, s, i) => aes.encrypt(m, crypto.pbkdf2Sync(i, s, 256, 32, "sha512").toString("hex"));
+const escapeFn = (str) => str.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+const unescapeFn = (str) => (str + "===".slice((str.length + 3) % 4)).replace(/-/g, "+").replace(/_/g, "/");
+export const encodeEncryptionKey = (key) => escapeFn(Buffer.from(key).toString("base64"));
+export const decodeEncryptionKey = (str) => new Uint8Array(Buffer.from(unescapeFn(str), "base64"));

package/lib/esm/util/model.d.ts

@@ -0,0 +1,12 @@
+import type { ChatModel, ChatModelOptions } from "@aigne/core/agents/chat-model.js";
+import type inquirer from "inquirer";
+import type { LoadableModel, LoadCredentialOptions, Model } from "./type.js";
+export declare function availableModels(): LoadableModel[];
+export declare function findModel(models: LoadableModel[], provider: string): LoadableModel | undefined;
+export declare const parseModelOption: (model?: string) => {
+    provider: string | undefined;
+    name: string | undefined;
+};
+export declare const formatModelName: (model: string, inquirerPrompt: typeof inquirer.prompt) => Promise<string>;
+export declare function maskApiKey(apiKey?: string): string | undefined;
+export declare function loadModel(model?: Model, modelOptions?: ChatModelOptions, options?: LoadCredentialOptions): Promise<ChatModel | undefined>;

package/lib/esm/util/model.js

@@ -0,0 +1,189 @@
+import { AnthropicChatModel } from "@aigne/anthropic";
+import { BedrockChatModel } from "@aigne/bedrock";
+import { DeepSeekChatModel } from "@aigne/deepseek";
+import { GeminiChatModel } from "@aigne/gemini";
+import { OllamaChatModel } from "@aigne/ollama";
+import { OpenRouterChatModel } from "@aigne/open-router";
+import { OpenAIChatModel } from "@aigne/openai";
+import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
+import { XAIChatModel } from "@aigne/xai";
+import { NodeHttpHandler, streamCollector } from "@smithy/node-http-handler";
+import boxen from "boxen";
+import chalk from "chalk";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { AIGNEHubChatModel } from "../index.js";
+import { AGENT_HUB_PROVIDER, DEFAULT_AIGNE_HUB_PROVIDER_MODEL, DEFAULT_MODEL_PROVIDER, } from "./constants.js";
+import { loadCredential } from "./credential.js";
+const { MODEL_PROVIDER, MODEL_NAME } = nodejs.env;
+export function availableModels() {
+    const proxy = ["HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy", "ALL_PROXY", "all_proxy"]
+        .map((i) => process.env[i])
+        .filter(Boolean)[0];
+    const httpAgent = proxy ? new HttpsProxyAgent(proxy) : undefined;
+    const clientOptions = {
+        fetchOptions: {
+            // @ts-ignore
+            agent: httpAgent,
+        },
+    };
+    return [
+        {
+            name: OpenAIChatModel.name,
+            apiKeyEnvName: "OPENAI_API_KEY",
+            create: (params) => new OpenAIChatModel({ ...params, clientOptions }),
+        },
+        {
+            name: AnthropicChatModel.name,
+            apiKeyEnvName: "ANTHROPIC_API_KEY",
+            create: (params) => new AnthropicChatModel({ ...params, clientOptions }),
+        },
+        {
+            name: BedrockChatModel.name,
+            apiKeyEnvName: "AWS_ACCESS_KEY_ID",
+            create: (params) => new BedrockChatModel({
+                ...params,
+                clientOptions: {
+                    requestHandler: NodeHttpHandler.create({ httpAgent, httpsAgent: httpAgent }),
+                    streamCollector,
+                },
+            }),
+        },
+        {
+            name: DeepSeekChatModel.name,
+            apiKeyEnvName: "DEEPSEEK_API_KEY",
+            create: (params) => new DeepSeekChatModel({ ...params, clientOptions }),
+        },
+        {
+            name: [GeminiChatModel.name, "google"],
+            apiKeyEnvName: ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
+            create: (params) => new GeminiChatModel({ ...params, clientOptions }),
+        },
+        {
+            name: OllamaChatModel.name,
+            apiKeyEnvName: "OLLAMA_API_KEY",
+            create: (params) => new OllamaChatModel({ ...params, clientOptions }),
+        },
+        {
+            name: OpenRouterChatModel.name,
+            apiKeyEnvName: "OPEN_ROUTER_API_KEY",
+            create: (params) => new OpenRouterChatModel({ ...params, clientOptions }),
+        },
+        {
+            name: XAIChatModel.name,
+            apiKeyEnvName: "XAI_API_KEY",
+            create: (params) => new XAIChatModel({ ...params, clientOptions }),
+        },
+        {
+            name: AIGNEHubChatModel.name,
+            apiKeyEnvName: "AIGNE_HUB_API_KEY",
+            create: (params) => new AIGNEHubChatModel({ ...params, clientOptions }),
+        },
+    ];
+}
+export function findModel(models, provider) {
+    return models.find((m) => {
+        if (typeof m.name === "string") {
+            return m.name.toLowerCase().includes(provider.toLowerCase());
+        }
+        return m.name.some((n) => n.toLowerCase().includes(provider.toLowerCase()));
+    });
+}
+export const parseModelOption = (model) => {
+    const { provider, name } = (model || process.env.MODEL)?.match(/(?<provider>[^:]*)(:(?<name>(\S+)))?/)?.groups ?? {};
+    return { provider, name };
+};
+export const formatModelName = async (model, inquirerPrompt) => {
+    const models = availableModels();
+    if (!model)
+        return DEFAULT_AIGNE_HUB_PROVIDER_MODEL;
+    const { provider, name } = parseModelOption(model);
+    if (!provider) {
+        return DEFAULT_AIGNE_HUB_PROVIDER_MODEL;
+    }
+    const providerName = provider.replace(/-/g, "");
+    if (providerName.includes(AGENT_HUB_PROVIDER)) {
+        return model;
+    }
+    const m = findModel(models, providerName);
+    if (!m)
+        throw new Error(`Unsupported model: ${provider} ${name}`);
+    const apiKeyEnvName = Array.isArray(m.apiKeyEnvName) ? m.apiKeyEnvName : [m.apiKeyEnvName];
+    if (apiKeyEnvName.some((name) => name && process.env[name])) {
+        return model;
+    }
+    const result = await inquirerPrompt({
+        type: "list",
+        name: "useAigneHub",
+        message: `Seems no API Key configured for ${provider}/${name}, select your preferred way to continue:`,
+        choices: [
+            {
+                name: `Connect to AIGNE Hub to use ${name} (Recommended since free credits available)`,
+                value: true,
+            },
+            {
+                name: `Exit and bring my owner API Key by set ${apiKeyEnvName.join(", ")}`,
+                value: false,
+            },
+        ],
+        default: true,
+    });
+    if (!result.useAigneHub) {
+        console.log(chalk.yellow(`You can use command "export ${apiKeyEnvName[0]}=xxx" to set API Key in your shell. Or you can set environment variables in .env file.`));
+        process.exit(0);
+    }
+    return `${AGENT_HUB_PROVIDER}:${provider}/${name}`;
+};
+export function maskApiKey(apiKey) {
+    if (!apiKey || apiKey.length <= 8)
+        return apiKey;
+    const start = apiKey.slice(0, 4);
+    const end = apiKey.slice(-4);
+    return `${start}${"*".repeat(8)}${end}`;
+}
+let printed = false;
+function printChatModelInfoBox({ provider, model, credential, m, }) {
+    if (printed)
+        return;
+    printed = true;
+    const lines = [
+        `${chalk.cyan("Provider")}: ${chalk.green(provider)}`,
+        `${chalk.cyan("Model")}: ${chalk.green(model)}`,
+    ];
+    if (provider.includes(AGENT_HUB_PROVIDER)) {
+        lines.push(`${chalk.cyan("API URL")}: ${chalk.green(credential?.url || "N/A")}`, `${chalk.cyan("API Key")}: ${chalk.green(maskApiKey(credential?.apiKey))}`);
+    }
+    else {
+        const apiKeyEnvName = Array.isArray(m.apiKeyEnvName) ? m.apiKeyEnvName : [m.apiKeyEnvName];
+        const envKeyName = apiKeyEnvName.find((name) => name && process.env[name]);
+        if (envKeyName) {
+            lines.push(`${chalk.cyan("API Key")}: ${chalk.green(maskApiKey(process.env[envKeyName]))}`);
+        }
+        else {
+            lines.push(`${chalk.cyan("API Key")}: ${chalk.yellow("Not found")}`);
+        }
+    }
+    console.log("\n");
+    console.log(boxen(lines.join("\n"), { padding: 1, borderStyle: "classic", borderColor: "cyan" }));
+    console.log("\n");
+}
+export async function loadModel(model, modelOptions, options) {
+    const params = {
+        model: MODEL_NAME ?? model?.name ?? undefined,
+        temperature: model?.temperature ?? undefined,
+        topP: model?.topP ?? undefined,
+        frequencyPenalty: model?.frequencyPenalty ?? undefined,
+        presencePenalty: model?.presencePenalty ?? undefined,
+    };
+    const provider = (MODEL_PROVIDER ?? model?.provider ?? DEFAULT_MODEL_PROVIDER).replace(/-/g, "");
+    const models = availableModels();
+    const m = findModel(models, provider);
+    if (!m)
+        throw new Error(`Unsupported model: ${model?.provider} ${model?.name}`);
+    const credential = await loadCredential({ ...options, model: `${provider}:${params.model}` });
+    printChatModelInfoBox({ provider, model: params.model || "", credential, m });
+    return m.create({
+        ...(credential || {}),
+        model: params.model,
+        modelOptions: { ...params, ...modelOptions },
+    });
+}

package/lib/esm/util/type.d.ts

@@ -0,0 +1,58 @@
+import type { ChatModel, ChatModelOptions } from "@aigne/core/agents/chat-model.js";
+export type Model = {
+    provider?: string | null;
+    name?: string | null;
+    temperature?: number | null;
+    topP?: number | null;
+    frequencyPenalty?: number | null;
+    presencePenalty?: number | null;
+} | undefined;
+type InquirerPromptFn = (prompt: {
+    type: string;
+    name: string;
+    message: string;
+    choices: {
+        name: string;
+        value: any;
+    }[];
+    default: any;
+}) => Promise<any>;
+export type LoadCredentialOptions = {
+    model?: string;
+    aigneHubUrl?: string;
+    inquirerPromptFn?: InquirerPromptFn;
+};
+export interface LoadableModel {
+    name: string | string[];
+    apiKeyEnvName?: string | string[];
+    create: (options: {
+        model?: string;
+        modelOptions?: ChatModelOptions;
+        apiKey?: string;
+        url?: string;
+    }) => ChatModel;
+}
+export type FetchResult = {
+    accessKeyId: string;
+    accessKeySecret: string;
+};
+export type BaseWrapSpinner = (_: string, waiting: () => Promise<FetchResult>) => Promise<FetchResult>;
+export interface CreateConnectOptions {
+    connectUrl: string;
+    openPage?: (url: string) => void;
+    fetchInterval?: number;
+    retry?: number;
+    source?: string;
+    connectAction?: string;
+    appName?: string;
+    appLogo?: string;
+    wrapSpinner?: BaseWrapSpinner;
+    prettyUrl?: (url: string) => string;
+    closeOnSuccess?: boolean;
+    intervalFetchConfig?: (options: {
+        sessionId: string;
+        fetchInterval: number;
+        fetchTimeout: number;
+    }) => Promise<FetchResult>;
+}
+export {};

package/lib/esm/util/type.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/aigne-hub",
-  "version": "0.4.8",
+  "version": "0.5.0",
   "description": "AIGNE Hub SDK for integrating with Hub AI models",
   "publishConfig": {
     "access": "public"
@@ -40,23 +40,30 @@
     }
   },
   "dependencies": {
+    "@ocap/mcrypto": "^1.21.0",
     "@smithy/node-http-handler": "^4.1.0",
+    "boxen": "^8.0.1",
+    "chalk": "^5.4.1",
     "https-proxy-agent": "^7.0.6",
+    "inquirer": "^12.7.0",
+    "open": "^10.2.0",
     "openai": "^5.8.3",
+    "p-wait-for": "^5.0.2",
     "ufo": "^1.6.1",
+    "yaml": "^2.8.0",
     "zod": "^3.25.67",
-    "@aigne/anthropic": "^0.10.13",
-    "@aigne/bedrock": "^0.8.17",
-    "@aigne/core": "^1.48.0",
-    "@aigne/deepseek": "^0.7.17",
-    "@aigne/default-memory": "^1.0.17",
-    "@aigne/ollama": "^0.7.17",
-    "@aigne/open-router": "^0.7.17",
-    "@aigne/gemini": "^0.8.17",
-    "@aigne/openai": "^0.10.17",
-    "@aigne/xai": "^0.7.17",
-    "@aigne/transport": "^0.12.5",
-    "@aigne/platform-helpers": "^0.6.0"
+    "@aigne/anthropic": "^0.11.1",
+    "@aigne/bedrock": "^0.9.1",
+    "@aigne/core": "^1.49.1",
+    "@aigne/deepseek": "^0.7.19",
+    "@aigne/default-memory": "^1.1.1",
+    "@aigne/gemini": "^0.9.1",
+    "@aigne/open-router": "^0.7.19",
+    "@aigne/ollama": "^0.7.19",
+    "@aigne/openai": "^0.11.1",
+    "@aigne/platform-helpers": "^0.6.1",
+    "@aigne/xai": "^0.7.19",
+    "@aigne/transport": "^0.13.1"
   },
   "devDependencies": {
     "@types/bun": "^1.2.18",
@@ -65,8 +72,8 @@
     "npm-run-all": "^4.1.5",
     "rimraf": "^6.0.1",
     "typescript": "^5.8.3",
-    "@aigne/openai": "^0.10.17",
-    "@aigne/test-utils": "^0.5.25"
+    "@aigne/openai": "^0.11.1",
+    "@aigne/test-utils": "^0.5.27"
   },
   "scripts": {
     "lint": "tsc --noEmit",

package/lib/cjs/constants.d.ts

@@ -1,28 +0,0 @@
-import type { ChatModel, ChatModelOptions } from "@aigne/core/agents/chat-model.js";
-export declare const AIGNE_HUB_URL = "https://hub.aigne.io/";
-export declare function availableModels(): LoadableModel[];
-export interface LoadableModel {
-    name: string | string[];
-    apiKeyEnvName?: string | string[];
-    create: (options: {
-        model?: string;
-        modelOptions?: ChatModelOptions;
-        apiKey?: string;
-        url?: string;
-    }) => ChatModel;
-}
-export declare function findModel(models: LoadableModel[], provider: string): LoadableModel | undefined;
-type Model = {
-    provider?: string | null;
-    name?: string | null;
-    temperature?: number | null;
-    topP?: number | null;
-    frequencyPenalty?: number | null;
-    presencePenalty?: number | null;
-} | undefined;
-export declare function loadModel(model?: Model, modelOptions?: ChatModelOptions, credential?: {
-    apiKey?: string;
-    url?: string;
-}): Promise<ChatModel | undefined>;
-export declare function getAIGNEHubMountPoint(url: string): Promise<string>;
-export {};