romtuck/openclaw
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge 0e2b007f87 into da71eaebd2

Browse Source
This commit is contained in:
SamyMe 2026-01-30 17:05:38 +05:30 committed by GitHub
commit d11c19c805
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
18 changed files with 714 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
docs/docs.json
View File

@ -117,6 +117,14 @@
"source": "/opencode/",
"destination": "/providers/opencode"
},
{
"source": "/edenai",
"destination": "/providers/edenai"
},
{
"source": "/edenai/",
"destination": "/providers/edenai"
},
{
"source": "/mattermost",
"destination": "/channels/mattermost"
@ -1029,6 +1037,7 @@
"providers/minimax",
"providers/vercel-ai-gateway",
"providers/openrouter",
"providers/edenai",
"providers/synthetic",
"providers/opencode",
"providers/glm",

74
docs/providers/edenai.md Normal file
View File

@ -0,0 +1,74 @@
---
summary: "Use Eden AI's unified API to access many models in Clawdbot"
read_when:
- You want a European multi-provider API gateway
- You want a single API key for many LLMs
---
# Eden AI
Eden AI provides a **unified API** that routes requests to many models behind a single
endpoint and API key. It is OpenAI-compatible and based in Europe.
## CLI setup
```bash
clawdbot onboard --auth-choice edenai-api-key
```
Or non-interactive:
```bash
clawdbot onboard --auth-choice apiKey --token-provider edenai --token "$EDENAI_API_KEY"
```
## Config snippet
```json5
{
env: { EDENAI_API_KEY: "..." },
agents: {
defaults: {
model: { primary: "edenai/anthropic/claude-sonnet-4-5" }
}
}
}
```
## Supported providers
Eden AI supports: Anthropic, OpenAI, Mistral, Google, and more.
## Example models
- `edenai/anthropic/claude-sonnet-4-5` - Claude Sonnet 4.5
- `edenai/openai/gpt-4o` - GPT-4o
- `edenai/openai/gpt-4o-mini` - GPT-4o Mini (cheaper)
- `edenai/mistral/mistral-large-latest` - Mistral Large
- `edenai/mistral/mistral-small-latest` - Mistral Small
## Expert models
Beyond LLMs, Eden AI provides access to specialized **expert models** optimized for specific tasks:
- **Video analysis** - person tracking, object tracking, text detection, explicit content detection
- **OCR** - document parsing, invoice extraction, ID recognition
- **Image generation** - text-to-image across multiple providers
- **Video generation** - text-to-video and image-to-video
- **Speech-to-text** - transcription and dictation
- **Text-to-speech** - voice synthesis
- **Content moderation** - explicit content detection, AI-generated content detection
Integration of these expert models into Clawdbot skills is coming soon.
## Notes
- Model refs are `edenai/<provider>/<model>` (e.g., `edenai/openai/gpt-4o`).
- For more model/provider options, see [/concepts/model-providers](/concepts/model-providers).
- Eden AI uses Bearer token authentication.
## Links
- [Eden AI website](https://www.edenai.co/)
- [Eden AI documentation](https://docs.edenai.co/)
- [Supported models](https://app.edenai.run/models)
- [Get your API key](https://app.edenai.run/admin/account/settings)

1
docs/providers/index.md
View File

@ -37,6 +37,7 @@ See [Venice AI](/providers/venice).
- [Anthropic (API + Claude Code CLI)](/providers/anthropic)
- [Qwen (OAuth)](/providers/qwen)
- [OpenRouter](/providers/openrouter)
- [Eden AI](/providers/edenai)
- [Vercel AI Gateway](/providers/vercel-ai-gateway)
- [Moonshot AI (Kimi + Kimi Code)](/providers/moonshot)
- [OpenCode Zen](/providers/opencode)

1
src/agents/model-auth.ts
View File

@ -277,6 +277,7 @@ export function resolveEnvApiKey(provider: string): EnvApiKeyResult | null {
cerebras: "CEREBRAS_API_KEY",
xai: "XAI_API_KEY",
openrouter: "OPENROUTER_API_KEY",
edenai: "EDENAI_API_KEY",
"vercel-ai-gateway": "AI_GATEWAY_API_KEY",
moonshot: "MOONSHOT_API_KEY",
"kimi-code": "KIMICODE_API_KEY",

148
src/agents/model-scan.test.ts
View File

@ -1,6 +1,6 @@
import { describe, expect, it } from "vitest";
import { scanOpenRouterModels } from "./model-scan.js";
import { scanEdenAiModels, scanOpenRouterModels } from "./model-scan.js";
function createFetchFixture(payload: unknown): typeof fetch {
return async () =>
@ -86,3 +86,149 @@ describe("scanOpenRouterModels", () => {
}
});
});
describe("scanEdenAiModels", () => {
it("lists models from {object, data} response format", async () => {
const fetchImpl = createFetchFixture({
object: "list",
data: [
{
id: "anthropic/claude-3-haiku",
model_name: "Claude 3 Haiku",
owned_by: "anthropic",
context_length: 200000,
created: 1700000000,
capabilities: {
supports_function_calling: true,
supports_vision: false,
supports_tool_choice: true,
input_modalities: ["text"],
output_modalities: ["text"],
},
pricing: { input_cost_per_token: 0.00025, output_cost_per_token: 0.00125 },
},
],
});
const results = await scanEdenAiModels({
fetchImpl,
apiKey: "test-key",
probe: false,
});
expect(results).toHaveLength(1);
expect(results[0]?.id).toBe("anthropic/claude-3-haiku");
expect(results[0]?.modelRef).toBe("edenai/anthropic/claude-3-haiku");
expect(results[0]?.provider).toBe("edenai");
expect(results[0]?.name).toBe("Claude 3 Haiku");
expect(results[0]?.supportsToolsMeta).toBe(true);
});
it("requires an API key", async () => {
const fetchImpl = createFetchFixture({ object: "list", data: [] });
const previousKey = process.env.EDENAI_API_KEY;
try {
delete process.env.EDENAI_API_KEY;
await expect(scanEdenAiModels({ fetchImpl, probe: false, apiKey: "" })).rejects.toThrow(
/Missing Eden AI API key/,
);
} finally {
if (previousKey === undefined) {
delete process.env.EDENAI_API_KEY;
} else {
process.env.EDENAI_API_KEY = previousKey;
}
}
});
it("filters by provider", async () => {
const fetchImpl = createFetchFixture({
object: "list",
data: [
{
id: "anthropic/claude-3",
model_name: "Claude",
owned_by: "anthropic",
context_length: 200000,
created: 1700000000,
capabilities: {
supports_function_calling: true,
supports_vision: false,
supports_tool_choice: true,
input_modalities: ["text"],
output_modalities: ["text"],
},
pricing: { input_cost_per_token: 0.001, output_cost_per_token: 0.002 },
},
{
id: "openai/gpt-4",
model_name: "GPT-4",
owned_by: "openai",
context_length: 128000,
created: 1700000000,
capabilities: {
supports_function_calling: true,
supports_vision: true,
supports_tool_choice: true,
input_modalities: ["text", "image"],
output_modalities: ["text"],
},
pricing: { input_cost_per_token: 0.003, output_cost_per_token: 0.006 },
},
],
});
const results = await scanEdenAiModels({
fetchImpl,
apiKey: "test-key",
probe: false,
providerFilter: "anthropic",
});
expect(results).toHaveLength(1);
expect(results[0]?.id).toBe("anthropic/claude-3");
});
it("detects free models", async () => {
const fetchImpl = createFetchFixture({
object: "list",
data: [
{
id: "free/model",
model_name: "Free Model",
owned_by: "free",
context_length: 4096,
created: 1700000000,
capabilities: {
supports_function_calling: false,
supports_vision: false,
supports_tool_choice: false,
input_modalities: ["text"],
output_modalities: ["text"],
},
pricing: { input_cost_per_token: 0, output_cost_per_token: 0 },
},
{
id: "paid/model",
model_name: "Paid Model",
owned_by: "paid",
context_length: 8192,
created: 1700000000,
capabilities: {
supports_function_calling: true,
supports_vision: false,
supports_tool_choice: true,
input_modalities: ["text"],
output_modalities: ["text"],
},
pricing: { input_cost_per_token: 0.001, output_cost_per_token: 0.002 },
},
],
});
const results = await scanEdenAiModels({ fetchImpl, apiKey: "test-key", probe: false });
expect(results.find((r) => r.id === "free/model")?.isFree).toBe(true);
expect(results.find((r) => r.id === "paid/model")?.isFree).toBe(false);
});
});

220
src/agents/model-scan.ts
View File

@ -10,6 +10,7 @@ import {
import { Type } from "@sinclair/typebox";
const OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
const EDENAI_MODELS_URL = "https://api.edenai.run/v3/llm/models";
const DEFAULT_TIMEOUT_MS = 12_000;
const DEFAULT_CONCURRENCY = 3;
@ -463,5 +464,220 @@ export async function scanOpenRouterModels(
);
}
export { OPENROUTER_MODELS_URL };
export type { OpenRouterModelMeta, OpenRouterModelPricing };
// Eden AI model scanning
type EdenAiModelMeta = {
id: string;
model_name: string;
owned_by: string;
context_length: number | null;
created: number;
capabilities: {
supports_function_calling: boolean;
supports_vision: boolean;
supports_tool_choice: boolean;
input_modalities: string[];
output_modalities: string[];
};
pricing: {
input_cost_per_token: number;
output_cost_per_token: number;
};
};
export type EdenAiScanOptions = {
apiKey?: string;
fetchImpl?: typeof fetch;
timeoutMs?: number;
concurrency?: number;
minParamB?: number;
maxAgeDays?: number;
providerFilter?: string;
probe?: boolean;
onProgress?: (update: { phase: "catalog" | "probe"; completed: number; total: number }) => void;
};
function parseEdenAiModality(meta: EdenAiModelMeta): Array<"text" | "image"> {
const modalities = meta.capabilities?.input_modalities ?? [];
const hasImage = modalities.some((m) => m.toLowerCase() === "image");
return hasImage ? ["text", "image"] : ["text"];
}
async function fetchEdenAiModels(
fetchImpl: typeof fetch,
apiKey: string,
): Promise<EdenAiModelMeta[]> {
const res = await fetchImpl(EDENAI_MODELS_URL, {
headers: {
Accept: "application/json",
Authorization: `Bearer ${apiKey}`,
},
});
if (!res.ok) {
throw new Error(`Eden AI /llm/models failed: HTTP ${res.status}`);
}
const payload = (await res.json()) as unknown;
// Eden AI returns {object: "list", data: [...]} format
const entries = Array.isArray(payload)
? payload
: payload &&
typeof payload === "object" &&
"data" in payload &&
Array.isArray((payload as { data: unknown }).data)
? (payload as { data: unknown[] }).data
: [];
return entries
.map((entry) => {
if (!entry || typeof entry !== "object") return null;
const obj = entry as Record<string, unknown>;
const id = typeof obj.id === "string" ? obj.id.trim() : "";
if (!id) return null;
const model_name =
typeof obj.model_name === "string" && obj.model_name.trim() ? obj.model_name.trim() : id;
const owned_by = typeof obj.owned_by === "string" ? obj.owned_by.trim() : "";
const context_length =
typeof obj.context_length === "number" && Number.isFinite(obj.context_length)
? obj.context_length
: null;
const created =
typeof obj.created === "number" && Number.isFinite(obj.created) ? obj.created : 0;
const caps = (obj.capabilities ?? {}) as Record<string, unknown>;
const capabilities = {
supports_function_calling: caps.supports_function_calling === true,
supports_vision: caps.supports_vision === true,
supports_tool_choice: caps.supports_tool_choice === true,
input_modalities: Array.isArray(caps.input_modalities)
? caps.input_modalities.filter((m): m is string => typeof m === "string")
: [],
output_modalities: Array.isArray(caps.output_modalities)
? caps.output_modalities.filter((m): m is string => typeof m === "string")
: [],
};
const pricingRaw = (obj.pricing ?? {}) as Record<string, unknown>;
const pricing = {
input_cost_per_token:
typeof pricingRaw.input_cost_per_token === "number" ? pricingRaw.input_cost_per_token : 0,
output_cost_per_token:
typeof pricingRaw.output_cost_per_token === "number"
? pricingRaw.output_cost_per_token
: 0,
};
return {
id,
model_name,
owned_by,
context_length,
created,
capabilities,
pricing,
} satisfies EdenAiModelMeta;
})
.filter((entry): entry is EdenAiModelMeta => Boolean(entry));
}
function isFreeEdenAiModel(entry: EdenAiModelMeta): boolean {
return entry.pricing.input_cost_per_token === 0 && entry.pricing.output_cost_per_token === 0;
}
export async function scanEdenAiModels(
options: EdenAiScanOptions = {},
): Promise<ModelScanResult[]> {
const fetchImpl = options.fetchImpl ?? fetch;
const probe = options.probe ?? true;
const apiKey = options.apiKey?.trim() || getEnvApiKey("edenai") || "";
if (!apiKey) {
throw new Error("Missing Eden AI API key. Set EDENAI_API_KEY to run models scan.");
}
// timeoutMs reserved for future probing support
const concurrency = Math.max(1, Math.floor(options.concurrency ?? DEFAULT_CONCURRENCY));
const minParamB = Math.max(0, Math.floor(options.minParamB ?? 0));
const maxAgeDays = Math.max(0, Math.floor(options.maxAgeDays ?? 0));
const providerFilter = options.providerFilter?.trim().toLowerCase() ?? "";
const catalog = await fetchEdenAiModels(fetchImpl, apiKey);
const now = Date.now();
const filtered = catalog.filter((entry) => {
if (providerFilter) {
const prefix = entry.id.split("/")[0]?.toLowerCase() ?? "";
if (prefix !== providerFilter) return false;
}
if (minParamB > 0) {
const params = inferParamBFromIdOrName(`${entry.id} ${entry.model_name}`);
if (!params || params < minParamB) return false;
}
if (maxAgeDays > 0 && entry.created > 0) {
const createdMs = entry.created * 1000;
const ageMs = now - createdMs;
const ageDays = ageMs / (24 * 60 * 60 * 1000);
if (ageDays > maxAgeDays) return false;
}
return true;
});
options.onProgress?.({
phase: "probe",
completed: 0,
total: filtered.length,
});
return mapWithConcurrency(
filtered,
concurrency,
async (entry) => {
const isFree = isFreeEdenAiModel(entry);
const inferredParamB = inferParamBFromIdOrName(`${entry.id} ${entry.model_name}`);
const modalities = parseEdenAiModality(entry);
const modalityString = modalities.includes("image") ? "text+image" : "text";
const baseResult = {
id: entry.id,
name: entry.model_name,
provider: "edenai",
modelRef: `edenai/${entry.id}`,
contextLength: entry.context_length,
maxCompletionTokens: null,
supportedParametersCount: 0,
supportsToolsMeta: entry.capabilities.supports_function_calling,
modality: modalityString,
inferredParamB,
createdAtMs: entry.created > 0 ? entry.created * 1000 : null,
pricing: {
prompt: entry.pricing.input_cost_per_token,
completion: entry.pricing.output_cost_per_token,
request: 0,
image: 0,
webSearch: 0,
internalReasoning: 0,
},
isFree,
};
// Eden AI probing is not yet supported - their API structure differs from OpenAI
// Use --no-probe for catalog listing, or implement Eden AI-specific probing later
return {
...baseResult,
tool: { ok: false, latencyMs: null, skipped: !probe },
image: { ok: false, latencyMs: null, skipped: !probe },
} satisfies ModelScanResult;
},
{
onProgress: (completed, total) =>
options.onProgress?.({
phase: "probe",
completed,
total,
}),
},
);
}
export { OPENROUTER_MODELS_URL, EDENAI_MODELS_URL };
export type { OpenRouterModelMeta, OpenRouterModelPricing, EdenAiModelMeta };

3
src/cli/models-cli.ts
View File

@ -246,7 +246,8 @@ export function registerModelsCli(program: Command) {
models
.command("scan")
.description("Scan OpenRouter free models for tools + images")
.description("Scan model registries for tools + images")
.option("--source <registry>", "Model registry (openrouter, edenai)", "openrouter")
.option("--min-params <b>", "Minimum parameter size (billions)")
.option("--max-age-days <days>", "Skip models older than N days")
.option("--provider <name>", "Filter by provider prefix")

4
src/cli/program/register.onboard.ts
View File

@ -52,7 +52,7 @@ export function registerOnboardCommand(program: Command) {
.option("--mode <mode>", "Wizard mode: local|remote")
.option(
"--auth-choice <choice>",
"Auth: setup-token|token|chutes|openai-codex|openai-api-key|openrouter-api-key|ai-gateway-api-key|moonshot-api-key|kimi-code-api-key|synthetic-api-key|venice-api-key|gemini-api-key|zai-api-key|xiaomi-api-key|apiKey|minimax-api|minimax-api-lightning|opencode-zen|skip",
"Auth: setup-token|claude-cli|token|chutes|openai-codex|openai-api-key|openrouter-api-key|edenai-api-key|ai-gateway-api-key|moonshot-api-key|kimi-code-api-key|synthetic-api-key|venice-api-key|codex-cli|gemini-api-key|zai-api-key|xiaomi-api-key|apiKey|minimax-api|minimax-api-lightning|opencode-zen|skip",
)
.option(
"--token-provider <id>",
@ -67,6 +67,7 @@ export function registerOnboardCommand(program: Command) {
.option("--anthropic-api-key <key>", "Anthropic API key")
.option("--openai-api-key <key>", "OpenAI API key")
.option("--openrouter-api-key <key>", "OpenRouter API key")
.option("--edenai-api-key <key>", "Eden AI API key")
.option("--ai-gateway-api-key <key>", "Vercel AI Gateway API key")
.option("--moonshot-api-key <key>", "Moonshot API key")
.option("--kimi-code-api-key <key>", "Kimi Code API key")
@ -118,6 +119,7 @@ export function registerOnboardCommand(program: Command) {
anthropicApiKey: opts.anthropicApiKey as string | undefined,
openaiApiKey: opts.openaiApiKey as string | undefined,
openrouterApiKey: opts.openrouterApiKey as string | undefined,
edenaiApiKey: opts.edenaiApiKey as string | undefined,
aiGatewayApiKey: opts.aiGatewayApiKey as string | undefined,
moonshotApiKey: opts.moonshotApiKey as string | undefined,
kimiCodeApiKey: opts.kimiCodeApiKey as string | undefined,

12
src/commands/auth-choice-options.ts
View File

@ -13,6 +13,7 @@ export type AuthChoiceGroupId =
| "google"
| "copilot"
| "openrouter"
| "edenai"
| "ai-gateway"
| "moonshot"
| "zai"
@ -90,6 +91,12 @@ const AUTH_CHOICE_GROUP_DEFS: {
hint: "API key",
choices: ["openrouter-api-key"],
},
{
value: "edenai",
label: "Eden AI",
hint: "API Key",
choices: ["edenai-api-key"],
},
{
value: "ai-gateway",
label: "Vercel AI Gateway",
@ -142,6 +149,11 @@ export function buildAuthChoiceOptions(params: {
options.push({ value: "chutes", label: "Chutes (OAuth)" });
options.push({ value: "openai-api-key", label: "OpenAI API key" });
options.push({ value: "openrouter-api-key", label: "OpenRouter API key" });
options.push({
value: "edenai-api-key",
label: "Eden AI API key",
hint: "European multi-provider gateway",
});
options.push({
value: "ai-gateway-api-key",
label: "Vercel AI Gateway API key",

94
src/commands/auth-choice.apply.api-providers.ts
View File

@ -13,6 +13,8 @@ import {
} from "./google-gemini-model-default.js";
import {
applyAuthProfileConfig,
applyEdenaiConfig,
applyEdenaiProviderConfig,
applyKimiCodeConfig,
applyKimiCodeProviderConfig,
applyMoonshotConfig,
@ -30,6 +32,7 @@ import {
applyXiaomiConfig,
applyXiaomiProviderConfig,
applyZaiConfig,
EDENAI_DEFAULT_MODEL_REF,
KIMI_CODE_MODEL_REF,
MOONSHOT_DEFAULT_MODEL_REF,
OPENROUTER_DEFAULT_MODEL_REF,
@ -37,6 +40,7 @@ import {
VENICE_DEFAULT_MODEL_REF,
VERCEL_AI_GATEWAY_DEFAULT_MODEL_REF,
XIAOMI_DEFAULT_MODEL_REF,
setEdenaiApiKey,
setGeminiApiKey,
setKimiCodeApiKey,
setMoonshotApiKey,
@ -73,6 +77,8 @@ export async function applyAuthChoiceApiProviders(
) {
if (params.opts.tokenProvider === "openrouter") {
authChoice = "openrouter-api-key";
} else if (params.opts.tokenProvider === "edenai") {
authChoice = "edenai-api-key";
} else if (params.opts.tokenProvider === "vercel-ai-gateway") {
authChoice = "ai-gateway-api-key";
} else if (params.opts.tokenProvider === "moonshot") {
@ -172,6 +178,94 @@ export async function applyAuthChoiceApiProviders(
return { config: nextConfig, agentModelOverride };
}
if (authChoice === "edenai-api-key") {
const store = ensureAuthProfileStore(params.agentDir, {
allowKeychainPrompt: false,
});
const profileOrder = resolveAuthProfileOrder({
cfg: nextConfig,
store,
provider: "edenai",
});
const existingProfileId = profileOrder.find((profileId) => Boolean(store.profiles[profileId]));
const existingCred = existingProfileId ? store.profiles[existingProfileId] : undefined;
let profileId = "edenai:default";
let mode: "api_key" | "oauth" | "token" = "api_key";
let hasCredential = false;
if (existingProfileId && existingCred?.type) {
profileId = existingProfileId;
mode =
existingCred.type === "oauth"
? "oauth"
: existingCred.type === "token"
? "token"
: "api_key";
hasCredential = true;
}
if (!hasCredential && params.opts?.token && params.opts?.tokenProvider === "edenai") {
await setEdenaiApiKey(normalizeApiKeyInput(params.opts.token), params.agentDir);
hasCredential = true;
}
if (!hasCredential) {
await params.prompter.note(
[
"Eden AI provides unified access to multiple LLM providers.",
"Get your API key at: https://app.edenai.run/admin/account/settings",
].join("\n"),
"Eden AI",
);
}
if (!hasCredential) {
const envKey = resolveEnvApiKey("edenai");
if (envKey) {
const useExisting = await params.prompter.confirm({
message: `Use existing EDENAI_API_KEY (${envKey.source}, ${formatApiKeyPreview(envKey.apiKey)})?`,
initialValue: true,
});
if (useExisting) {
await setEdenaiApiKey(envKey.apiKey, params.agentDir);
hasCredential = true;
}
}
}
if (!hasCredential) {
const key = await params.prompter.text({
message: "Enter Eden AI API key",
validate: validateApiKeyInput,
});
await setEdenaiApiKey(normalizeApiKeyInput(String(key)), params.agentDir);
hasCredential = true;
}
if (hasCredential) {
nextConfig = applyAuthProfileConfig(nextConfig, {
profileId,
provider: "edenai",
mode,
});
}
{
const applied = await applyDefaultModelChoice({
config: nextConfig,
setDefaultModel: params.setDefaultModel,
defaultModel: EDENAI_DEFAULT_MODEL_REF,
applyDefaultConfig: applyEdenaiConfig,
applyProviderConfig: applyEdenaiProviderConfig,
noteDefault: EDENAI_DEFAULT_MODEL_REF,
noteAgentModel,
prompter: params.prompter,
});
nextConfig = applied.config;
agentModelOverride = applied.agentModelOverride ?? agentModelOverride;
}
return { config: nextConfig, agentModelOverride };
}
if (authChoice === "ai-gateway-api-key") {
let hasCredential = false;

1
src/commands/auth-choice.preferred-provider.ts
View File

@ -11,6 +11,7 @@ const PREFERRED_PROVIDER_BY_AUTH_CHOICE: Partial<Record<AuthChoice, string>> = {
chutes: "chutes",
"openai-api-key": "openai",
"openrouter-api-key": "openrouter",
"edenai-api-key": "edenai",
"ai-gateway-api-key": "vercel-ai-gateway",
"moonshot-api-key": "moonshot",
"kimi-code-api-key": "kimi-code",

1
src/commands/models/list.status-command.ts
View File

@ -131,6 +131,7 @@ export async function modelsStatusCommand(
"cerebras",
"xai",
"openrouter",
"edenai",
"zai",
"mistral",
"synthetic",

47
src/commands/models/scan.ts
View File

@ -1,6 +1,10 @@
import { cancel, multiselect as clackMultiselect, isCancel } from "@clack/prompts";
import { resolveApiKeyForProvider } from "../../agents/model-auth.js";
import { type ModelScanResult, scanOpenRouterModels } from "../../agents/model-scan.js";
import {
type ModelScanResult,
scanEdenAiModels,
scanOpenRouterModels,
} from "../../agents/model-scan.js";
import { withProgressTotals } from "../../cli/progress.js";
import { loadConfig } from "../../config/config.js";
import { logConfigUpdated } from "../../config/logging.js";
@ -120,6 +124,8 @@ function printScanTable(results: ModelScanResult[], runtime: RuntimeEnv) {
}
}
export type ModelScanSource = "openrouter" | "edenai";
export async function modelsScanCommand(
opts: {
minParams?: string;
@ -134,6 +140,7 @@ export async function modelsScanCommand(
setImage?: boolean;
json?: boolean;
probe?: boolean;
source?: ModelScanSource;
},
runtime: RuntimeEnv,
) {
@ -160,11 +167,15 @@ export async function modelsScanCommand(
const cfg = loadConfig();
const probe = opts.probe ?? true;
const source: ModelScanSource = opts.source ?? "openrouter";
const providerForKey = source === "edenai" ? "edenai" : "openrouter";
const sourceLabel = source === "edenai" ? "Eden AI" : "OpenRouter";
let storedKey: string | undefined;
if (probe) {
if (probe || source === "edenai") {
try {
const resolved = await resolveApiKeyForProvider({
provider: "openrouter",
provider: providerForKey,
cfg,
});
storedKey = resolved.apiKey;
@ -172,14 +183,15 @@ export async function modelsScanCommand(
storedKey = undefined;
}
}
const results = await withProgressTotals(
{
label: "Scanning OpenRouter models...",
label: `Scanning ${sourceLabel} models...`,
indeterminate: false,
enabled: opts.json !== true,
},
async (update) =>
await scanOpenRouterModels({
async (progressUpdate) => {
const scanOpts = {
apiKey: storedKey ?? undefined,
minParamB: minParams,
maxAgeDays,
@ -187,22 +199,35 @@ export async function modelsScanCommand(
timeoutMs: timeout,
concurrency,
probe,
onProgress: ({ phase, completed, total }) => {
onProgress: ({
phase,
completed,
total,
}: {
phase: string;
completed: number;
total: number;
}) => {
if (phase !== "probe") return;
const labelBase = probe ? "Probing models" : "Scanning models";
update({
progressUpdate({
completed,
total,
label: `${labelBase} (${completed}/${total})`,
});
},
}),
};
if (source === "edenai") {
return await scanEdenAiModels(scanOpts);
}
return await scanOpenRouterModels(scanOpts);
},
);
if (!probe) {
if (!opts.json) {
runtime.log(
`Found ${results.length} OpenRouter free models (metadata only; pass --probe to test tools/images).`,
`Found ${results.length} ${sourceLabel} models (metadata only; pass --probe to test tools/images).`,
);
printScanTable(sortScanResults(results), runtime);
} else {
@ -213,7 +238,7 @@ export async function modelsScanCommand(
const toolOk = results.filter((entry) => entry.tool.ok);
if (toolOk.length === 0) {
throw new Error("No tool-capable OpenRouter free models found.");
throw new Error(`No tool-capable ${sourceLabel} models found.`);
}
const sorted = sortScanResults(results);

73
src/commands/onboard-auth.config-core.ts
View File

@ -13,6 +13,7 @@ import {
} from "../agents/venice-models.js";
import type { OpenClawConfig } from "../config/config.js";
import {
EDENAI_DEFAULT_MODEL_REF,
OPENROUTER_DEFAULT_MODEL_REF,
VERCEL_AI_GATEWAY_DEFAULT_MODEL_REF,
XIAOMI_DEFAULT_MODEL_REF,
@ -484,6 +485,78 @@ export function applyVeniceConfig(cfg: OpenClawConfig): OpenClawConfig {
};
}
export const EDENAI_BASE_URL = "https://api.edenai.run/v3/llm";
/**
* Apply Eden AI provider configuration without changing the default model.
* Registers Eden AI models and sets up the provider, but preserves existing model selection.
*/
export function applyEdenaiProviderConfig(cfg: ClawdbotConfig): ClawdbotConfig {
const models = { ...cfg.agents?.defaults?.models };
models[EDENAI_DEFAULT_MODEL_REF] = {
...models[EDENAI_DEFAULT_MODEL_REF],
alias: models[EDENAI_DEFAULT_MODEL_REF]?.alias ?? "Eden AI",
};
const providers = { ...cfg.models?.providers };
const existingProvider = providers.edenai;
const existingModels = Array.isArray(existingProvider?.models) ? existingProvider.models : [];
const { apiKey: existingApiKey, ...existingProviderRest } = (existingProvider ?? {}) as Record<
string,
unknown
> as { apiKey?: string };
const resolvedApiKey = typeof existingApiKey === "string" ? existingApiKey : undefined;
const normalizedApiKey = resolvedApiKey?.trim();
providers.edenai = {
...existingProviderRest,
baseUrl: EDENAI_BASE_URL,
api: "openai-completions",
...(normalizedApiKey ? { apiKey: normalizedApiKey } : {}),
models: existingModels,
};
return {
...cfg,
agents: {
...cfg.agents,
defaults: {
...cfg.agents?.defaults,
models,
},
},
models: {
mode: cfg.models?.mode ?? "merge",
providers,
},
};
}
/**
* Apply Eden AI provider configuration AND set Eden AI as the default model.
* Use this when Eden AI is the primary provider choice during onboarding.
*/
export function applyEdenaiConfig(cfg: ClawdbotConfig): ClawdbotConfig {
const next = applyEdenaiProviderConfig(cfg);
const existingModel = next.agents?.defaults?.model;
return {
...next,
agents: {
...next.agents,
defaults: {
...next.agents?.defaults,
model: {
...(existingModel && "fallbacks" in (existingModel as Record<string, unknown>)
? {
fallbacks: (existingModel as { fallbacks?: string[] }).fallbacks,
}
: undefined),
primary: EDENAI_DEFAULT_MODEL_REF,
},
},
},
};
}
export function applyAuthProfileConfig(
cfg: OpenClawConfig,
params: {

14
src/commands/onboard-auth.credentials.ts
View File

@ -177,3 +177,17 @@ export async function setOpencodeZenApiKey(key: string, agentDir?: string) {
agentDir: resolveAuthAgentDir(agentDir),
});
}
export const EDENAI_DEFAULT_MODEL_REF = "edenai/anthropic/claude-sonnet-4-5";
export async function setEdenaiApiKey(key: string, agentDir?: string) {
upsertAuthProfile({
profileId: "edenai:default",
credential: {
type: "api_key",
provider: "edenai",
key,
},
agentDir: resolveAuthAgentDir(agentDir),
});
}

5
src/commands/onboard-auth.ts
View File

@ -5,6 +5,8 @@ export {
export { VENICE_DEFAULT_MODEL_ID, VENICE_DEFAULT_MODEL_REF } from "../agents/venice-models.js";
export {
applyAuthProfileConfig,
applyEdenaiConfig,
applyEdenaiProviderConfig,
applyKimiCodeConfig,
applyKimiCodeProviderConfig,
applyMoonshotConfig,
@ -20,6 +22,7 @@ export {
applyXiaomiConfig,
applyXiaomiProviderConfig,
applyZaiConfig,
EDENAI_BASE_URL,
} from "./onboard-auth.config-core.js";
export {
applyMinimaxApiConfig,
@ -35,8 +38,10 @@ export {
applyOpencodeZenProviderConfig,
} from "./onboard-auth.config-opencode.js";
export {
EDENAI_DEFAULT_MODEL_REF,
OPENROUTER_DEFAULT_MODEL_REF,
setAnthropicApiKey,
setEdenaiApiKey,
setGeminiApiKey,
setKimiCodeApiKey,
setMinimaxApiKey,

21
src/commands/onboard-non-interactive/local/auth-choice.ts
View File

@ -8,6 +8,7 @@ import { buildTokenProfileId, validateAnthropicSetupToken } from "../../auth-tok
import { applyGoogleGeminiModelDefault } from "../../google-gemini-model-default.js";
import {
applyAuthProfileConfig,
applyEdenaiConfig,
applyKimiCodeConfig,
applyMinimaxApiConfig,
applyMinimaxConfig,
@ -20,6 +21,7 @@ import {
applyXiaomiConfig,
applyZaiConfig,
setAnthropicApiKey,
setEdenaiApiKey,
setGeminiApiKey,
setKimiCodeApiKey,
setMinimaxApiKey,
@ -235,6 +237,25 @@ export async function applyNonInteractiveAuthChoice(params: {
return applyOpenrouterConfig(nextConfig);
}
if (authChoice === "edenai-api-key") {
const resolved = await resolveNonInteractiveApiKey({
provider: "edenai",
cfg: baseConfig,
flagValue: opts.edenaiApiKey,
flagName: "--edenai-api-key",
envVar: "EDENAI_API_KEY",
runtime,
});
if (!resolved) return null;
if (resolved.source !== "profile") await setEdenaiApiKey(resolved.key);
nextConfig = applyAuthProfileConfig(nextConfig, {
profileId: "edenai:default",
provider: "edenai",
mode: "api_key",
});
return applyEdenaiConfig(nextConfig);
}
if (authChoice === "ai-gateway-api-key") {
const resolved = await resolveNonInteractiveApiKey({
provider: "vercel-ai-gateway",

2
src/commands/onboard-types.ts
View File

@ -12,6 +12,7 @@ export type AuthChoice =
| "openai-codex"
| "openai-api-key"
| "openrouter-api-key"
| "edenai-api-key"
| "ai-gateway-api-key"
| "moonshot-api-key"
| "kimi-code-api-key"
@ -63,6 +64,7 @@ export type OnboardOptions = {
anthropicApiKey?: string;
openaiApiKey?: string;
openrouterApiKey?: string;
edenaiApiKey?: string;
aiGatewayApiKey?: string;
moonshotApiKey?: string;
kimiCodeApiKey?: string;