@best-agent/cli 0.0.2-beta.8 → 0.0.3-beta.1

package/dist/provider-config-env.d.ts

@@ -1,7 +0,0 @@
-import type { ProviderCompatibilityMode, ProviderConfig, ProviderDecisionTransportMode, ProviderKind } from "@best-agent/protocol";
-export declare function getProviderConfigFromEnv(env?: NodeJS.ProcessEnv): ProviderConfig | undefined;
-export declare function enrichProviderConfig(config: ProviderConfig): ProviderConfig;
-export declare function parseProviderKind(raw: string | undefined): ProviderKind | undefined;
-export declare function parseProviderCompatibilityMode(raw: string | undefined): ProviderCompatibilityMode | undefined;
-export declare function parseProviderDecisionTransportMode(raw: string | undefined): ProviderDecisionTransportMode | undefined;
-//# sourceMappingURL=provider-config-env.d.ts.map

package/dist/provider-config-env.js

@@ -1,286 +0,0 @@
-import { inferProviderModelLimit } from "./provider-model-limits.js";
-const COMPATIBLE_CHAT_COMPLETION_MAX_TOKENS = 32_000;
-const PROVIDER_KIND_BY_VALUE = {
-    aihubmix: "aihubmix",
-    "aihubmix-responses": "aihubmix-responses",
-    anthropic: "anthropic",
-    customProvider: "customProvider",
-    deepseek: "deepseek",
-    google: "google",
-    moonshotai: "moonshotai",
-    openai: "openai",
-    "openai-responses": "openai-responses",
-    xai: "xai",
-    "xai-responses": "xai-responses",
-    zenmux: "zenmux",
-};
-const PROVIDER_COMPATIBILITY_BY_VALUE = {
-    auto: "auto",
-    compatible: "compatible",
-    native: "native",
-};
-const PROVIDER_DECISION_TRANSPORT_BY_VALUE = {
-    auto: "auto",
-    native_tools: "native_tools",
-};
-export function getProviderConfigFromEnv(env = process.env) {
-    const kind = parseProviderKindFromEnv(env.BEST_AGENT_PROVIDER_KIND);
-    const explicitCompatibilityMode = parseProviderCompatibilityModeFromEnv(env.BEST_AGENT_PROVIDER_COMPATIBILITY_MODE, "BEST_AGENT_PROVIDER_COMPATIBILITY_MODE");
-    const explicitDecisionTransport = parseProviderDecisionTransportMode(env.BEST_AGENT_PROVIDER_DECISION_TRANSPORT);
-    const timeoutMs = resolveProviderTimeoutMs(env);
-    const model = env.BEST_AGENT_PROVIDER_MODEL;
-    if (kind && model) {
-        return enrichProviderConfig({
-            kind,
-            model,
-            apiKey: resolveProviderApiKey(env, kind),
-            baseURL: resolveProviderBaseUrl(env, kind),
-            compatibilityMode: resolveProviderCompatibilityMode(env, kind, explicitCompatibilityMode),
-            decisionTransport: explicitDecisionTransport,
-            systemPrompt: env.BEST_AGENT_PROVIDER_SYSTEM_PROMPT,
-            timeoutMs,
-        });
-    }
-    const inferredProviders = [
-        "openai",
-        "xai",
-        "deepseek",
-        "moonshotai",
-        "aihubmix",
-        "zenmux",
-        "customProvider",
-    ];
-    for (const inferredKind of inferredProviders) {
-        const inferredModel = resolveDefaultProviderModel(env, inferredKind);
-        if (!inferredModel) {
-            continue;
-        }
-        return enrichProviderConfig({
-            kind: inferredKind,
-            model: inferredModel,
-            apiKey: resolveProviderApiKey(env, inferredKind),
-            baseURL: resolveProviderBaseUrl(env, inferredKind),
-            compatibilityMode: resolveProviderCompatibilityMode(env, inferredKind, explicitCompatibilityMode),
-            decisionTransport: explicitDecisionTransport,
-            systemPrompt: env.BEST_AGENT_PROVIDER_SYSTEM_PROMPT,
-            timeoutMs,
-        });
-    }
-    return undefined;
-}
-export function enrichProviderConfig(config) {
-    const inferredContextWindow = resolveProviderContextWindow(config);
-    const inferredMaxOutputTokens = resolveProviderMaxOutputTokens(config);
-    return {
-        ...config,
-        ...(typeof inferredContextWindow === "number" ? { maxInputTokens: inferredContextWindow } : {}),
-        ...(typeof inferredMaxOutputTokens === "number"
-            ? { maxOutputTokens: inferredMaxOutputTokens }
-            : {}),
-    };
-}
-function resolveProviderApiKey(env, kind) {
-    const explicit = env.BEST_AGENT_PROVIDER_API_KEY;
-    if (explicit) {
-        return explicit;
-    }
-    switch (kind) {
-        case "openai":
-        case "openai-responses":
-            return env.OPENAI_API_KEY;
-        case "anthropic":
-            return env.ANTHROPIC_API_KEY;
-        case "google":
-            return env.GOOGLE_GENERATIVE_AI_API_KEY;
-        case "xai":
-        case "xai-responses":
-            return env.XAI_API_KEY;
-        case "deepseek":
-            return env.DEEPSEEK_API_KEY;
-        case "moonshotai":
-            return env.MOONSHOTAI_API_KEY;
-        case "aihubmix":
-        case "aihubmix-responses":
-            return env.AIHUBMIX_API_KEY;
-        case "zenmux":
-            return env.ZENMUX_API_KEY;
-        case "customProvider":
-            return env.CUSTOM_PROVIDER_API_KEY;
-    }
-}
-function resolveProviderBaseUrl(env, kind) {
-    const explicit = env.BEST_AGENT_PROVIDER_BASE_URL;
-    if (explicit) {
-        return explicit;
-    }
-    switch (kind) {
-        case "openai":
-        case "openai-responses":
-            return env.OPENAI_BASE_URL;
-        case "xai":
-        case "xai-responses":
-            return env.XAI_BASE_URL;
-        case "deepseek":
-            return env.DEEPSEEK_BASE_URL;
-        case "moonshotai":
-            return env.MOONSHOTAI_BASE_URL;
-        case "aihubmix":
-        case "aihubmix-responses":
-            return env.AIHUBMIX_BASE_URL;
-        case "zenmux":
-            return env.ZENMUX_BASE_URL;
-        case "customProvider":
-            return env.CUSTOM_PROVIDER_BASE_URL;
-    }
-}
-function resolveProviderCompatibilityMode(env, kind, explicit) {
-    if (explicit) {
-        return explicit;
-    }
-    switch (kind) {
-        case "openai":
-        case "openai-responses":
-            return parseProviderCompatibilityModeFromEnv(env.OPENAI_COMPATIBILITY_MODE, "OPENAI_COMPATIBILITY_MODE");
-        default:
-            return undefined;
-    }
-}
-export function parseProviderKind(raw) {
-    return raw ? PROVIDER_KIND_BY_VALUE[raw] : undefined;
-}
-function parseProviderKindFromEnv(raw) {
-    if (!raw) {
-        return undefined;
-    }
-    const parsed = parseProviderKind(raw);
-    if (parsed) {
-        return parsed;
-    }
-    throw new Error(`Unsupported BEST_AGENT_PROVIDER_KIND=${raw}.`);
-}
-export function parseProviderCompatibilityMode(raw) {
-    return raw ? PROVIDER_COMPATIBILITY_BY_VALUE[raw] : undefined;
-}
-function parseProviderCompatibilityModeFromEnv(raw, envName) {
-    if (!raw) {
-        return undefined;
-    }
-    const parsed = parseProviderCompatibilityMode(raw);
-    if (parsed) {
-        return parsed;
-    }
-    throw new Error(`Unsupported ${envName}=${raw}. Use auto, compatible, or native.`);
-}
-export function parseProviderDecisionTransportMode(raw) {
-    if (!raw) {
-        return undefined;
-    }
-    const parsed = PROVIDER_DECISION_TRANSPORT_BY_VALUE[raw];
-    if (parsed) {
-        return parsed;
-    }
-    throw new Error(`Unsupported provider decision transport ${raw}. Use native_tools or auto.`);
-}
-function resolveProviderTimeoutMs(env) {
-    const value = env.BEST_AGENT_PROVIDER_TIMEOUT_MS;
-    if (!value) {
-        return undefined;
-    }
-    const parsed = Number(value);
-    if (Number.isFinite(parsed) && parsed > 0) {
-        return parsed;
-    }
-    throw new Error(`Unsupported BEST_AGENT_PROVIDER_TIMEOUT_MS=${value}. Use a positive number.`);
-}
-function resolveDefaultProviderModel(env, kind) {
-    switch (kind) {
-        case "openai":
-            return env.OPENAI_MODEL;
-        case "xai":
-            return env.XAI_MODEL;
-        case "deepseek":
-            return env.DEEPSEEK_MODEL;
-        case "moonshotai":
-            return env.MOONSHOTAI_MODEL;
-        case "aihubmix":
-            return env.AIHUBMIX_MODEL;
-        case "zenmux":
-            return env.ZENMUX_MODEL;
-        case "customProvider":
-            return env.CUSTOM_PROVIDER_MODEL;
-        default:
-            return undefined;
-    }
-}
-function resolveProviderContextWindow(config) {
-    if (typeof config.maxInputTokens === "number" &&
-        Number.isFinite(config.maxInputTokens) &&
-        config.maxInputTokens > 0) {
-        return Math.floor(config.maxInputTokens);
-    }
-    if (!isOpenAiCompatibleProviderKind(config.kind)) {
-        return undefined;
-    }
-    const adapter = resolveProviderAdapter(config.kind);
-    return inferProviderModelLimit(config.model, adapter, "lowest")?.context;
-}
-function resolveProviderMaxOutputTokens(config) {
-    if (typeof config.maxOutputTokens === "number" &&
-        Number.isFinite(config.maxOutputTokens) &&
-        config.maxOutputTokens > 0) {
-        return Math.floor(config.maxOutputTokens);
-    }
-    return isCompatibleChatCompletionsProvider(config)
-        ? COMPATIBLE_CHAT_COMPLETION_MAX_TOKENS
-        : undefined;
-}
-function resolveProviderAdapter(kind) {
-    switch (kind) {
-        case "google":
-            return "gemini";
-        case "anthropic":
-            return "anthropic";
-        case "openai-responses":
-        case "xai-responses":
-        case "aihubmix-responses":
-            return "openai-responses";
-        default:
-            return "openai";
-    }
-}
-function isCompatibleChatCompletionsProvider(config) {
-    if (!isOpenAiCompatibleProviderKind(config.kind)) {
-        return false;
-    }
-    return resolveProviderCompatibilityModeForConfig(config) === "compatible";
-}
-function isOpenAiCompatibleProviderKind(kind) {
-    return (kind === "openai" ||
-        kind === "openai-responses" ||
-        kind === "xai" ||
-        kind === "xai-responses" ||
-        kind === "deepseek" ||
-        kind === "moonshotai" ||
-        kind === "aihubmix" ||
-        kind === "aihubmix-responses" ||
-        kind === "zenmux" ||
-        kind === "customProvider");
-}
-function resolveProviderCompatibilityModeForConfig(config) {
-    if (config.compatibilityMode === "compatible") {
-        return "compatible";
-    }
-    if (config.compatibilityMode === "native") {
-        return "native";
-    }
-    if (!config.baseURL) {
-        return "native";
-    }
-    try {
-        return new URL(config.baseURL).hostname !== "api.openai.com" ? "compatible" : "native";
-    }
-    catch {
-        return "native";
-    }
-}
-//# sourceMappingURL=provider-config-env.js.map

package/dist/provider-model-limit-index.generated.d.ts

@@ -1,3 +0,0 @@
-export type IndexedProviderAdapter = "openai" | "openai-responses" | "anthropic" | "gemini";
-export declare const MODEL_LIMIT_INDEX: Readonly<Record<IndexedProviderAdapter, Readonly<Record<string, readonly [number, number, number, number]>>>>;
-//# sourceMappingURL=provider-model-limit-index.generated.d.ts.map