Skip to content

7.4 billion tokens per month. 34 free LLM providers. 635 free model endpoints. All behind one /v1 endpoint, plus any custom OpenAI-compatible endpoint. Smart routing, automatic failover, encrypted keys. Personal experimentation only.

TypeScript

feat(providers): Inferbase, SimpleLLM and ElectronHub embeddings (#1455)

Tashfeen3f131f06fc09
diff --git a/client/src/components/keys/shared.tsx b/client/src/components/keys/shared.tsx
index 30117aca..b51ef726 100644
--- a/client/src/components/keys/shared.tsx
+++ b/client/src/components/keys/shared.tsx
@@ -31,6 +31,8 @@ export const PLATFORMS: { value: Platform; label: string; url: string; keyless?:
{ value: 'speka', label: 'Speka ($1 shared monthly credits)', url: 'https://speka.me/dashboard/keys' },
{ value: 'typhoon', label: 'Typhoon (free research API)', url: 'https://playground.opentyphoon.ai' },
{ value: 'plugsky', label: 'Plugsky (free chat aliases)', url: 'https://plugsky.com/dashboard' },
+ { value: 'inferbase', label: 'Inferbase (shared monthly and daily allowance)', url: 'https://inferbase.ai' },
+ { value: 'simplellm', label: 'SimpleLLM (shared hourly and daily free quota)', url: 'https://app.simplellm.eu' },
{ value: 'llmtr', label: 'LLMTR (daily free-model quotas)', url: 'https://llmtr.com' },
{ value: 'gizmo', label: 'Gizmo (monthly free-model requests)', url: 'https://gizmoplatforms.com/developers' },
{ value: 'blockrun', label: 'BlockRun (zero-priced models)', url: 'https://user.blockrun.ai/dashboard/keys' },
diff --git a/client/src/lib/routing.ts b/client/src/lib/routing.ts
index fcc1577e..a1f33be8 100644
--- a/client/src/lib/routing.ts
+++ b/client/src/lib/routing.ts
@@ -407,6 +407,8 @@ export const platformColors: Record<string, string> = {
speka: '#0d9488',
typhoon: '#e11d48',
plugsky: '#0284c7',
+ inferbase: '#2563eb',
+ simplellm: '#0d9488',
llmtr: '#0f766e',
gizmo: '#7c3aed',
blockrun: '#2563eb',
diff --git a/docs/en/providers/04-recurring-credit-gateways.md b/docs/en/providers/04-recurring-credit-gateways.md
index 2f935e22..396fc4f9 100644
--- a/docs/en/providers/04-recurring-credit-gateways.md
+++ b/docs/en/providers/04-recurring-credit-gateways.md
@@ -44,3 +44,34 @@ Sources: [ElectronHub credits](https://docs.electronhub.ai/billing/credits),
[Experiential pricing](https://www.experientiallabs.ai/pricing),
[billing](https://platform.experientiallabs.ai/docs/billing),
[API reference](https://platform.experientiallabs.ai/docs/reference).
+
+## Inferbase and SimpleLLM
+
+Added October 9, 2026. These adapters also receive model rows only through the
+signed catalog; adding a key does not discover or seed the wider paid roster.
+
+| Provider | API base | Read-only key validation | Shared free allowance |
+| --- | --- | --- | --- |
+| `inferbase` | `https://api.inferbase.ai/v1` | `GET https://api.inferbase.ai/api/v1/inference/credits` | 5,000 requests/month, also capped at 100 managed requests and $0.50 model usage/day; no card |
+| `simplellm` | `https://api.simplellm.eu/v1` | `GET /v1/rate-limit` | Free-model hourly/daily requests and tokens, reported by the account API; not a monthly dollar grant |
+
+Import `INFERBASE_API_KEY` or `SIMPLELLM_API_KEY`, or select the corresponding
+provider on the Keys page. A zero purchased balance is valid. Authentication
+failures are distinguished from temporary quota/server failures. Exact model
+identity is checked; SimpleLLM's two tested free aliases may report their known
+underlying names. Neither adapter enables billing, purchases credits or falls
+back to a paid model automatically. Provider-side spending controls still apply.
+
+Inferbase Free managed inference allows 8,192 input and 1,024 output tokens.
+The adapter respects that upstream output ceiling; it does not impose a new
+FreeLLMAPI request quota. SimpleLLM normalizes scalar stop strings to arrays.
+
+ElectronHub embeddings use `/v1/embeddings` with float encoding and share the
+same weekly wallet as chat. Returned model ID, dimensions, finite vector values
+and batch indices are checked before accepting the vectors. No embedding model
+rows are bundled into migrations.
+
+Sources: [Inferbase pricing](https://inferbase.ai/pricing),
+[SimpleLLM API](https://simplellm.eu/docs/),
+[SimpleLLM limits](https://simplellm.eu/docs/reference/getRateLimit.html),
+[ElectronHub embeddings](https://docs.electronhub.ai/api-reference/embeddings).
diff --git a/server/src/__tests__/providers/catalog-gateways.test.ts b/server/src/__tests__/providers/catalog-gateways.test.ts
new file mode 100644
index 00000000..55c6b17f
--- /dev/null
+++ b/server/src/__tests__/providers/catalog-gateways.test.ts
@@ -0,0 +1,137 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { InferbaseProvider, INFERBASE_BASE_URL } from '../../providers/inferbase.js';
+import { SimpleLLMProvider, SIMPLELLM_BASE_URL } from '../../providers/simplellm.js';
+import { getProvider } from '../../providers/index.js';
+import { AUTH_JSON_PROVIDER_MAP, parseKeysFromFile } from '../../lib/key-parser.js';
+import { inferPoolForPlatform } from '../../services/provider-quota.js';
+import { applyCatalog } from '../../services/catalog-sync.js';
+import { isBuiltinDiscoveryEligible } from '../../services/builtin-model-discovery.js';
+import { getDb, initDb } from '../../db/index.js';
+
+const json = (body: unknown, status = 200, headers = {}) => new Response(JSON.stringify(body), { status, headers });
+const configs = [
+ { platform: 'inferbase' as const, provider: InferbaseProvider, base: INFERBASE_BASE_URL, validate: 'https://api.inferbase.ai/api/v1/inference/credits', account: { balance_micros: 0 }, model: 'deepseek-v4-flash', returned: 'deepseek-v4-flash' },
+ { platform: 'simplellm' as const, provider: SimpleLLMProvider, base: SIMPLELLM_BASE_URL, validate: `${SIMPLELLM_BASE_URL}/rate-limit`, account: { limit_rpm: 1000 }, model: 'free-gemma-4-E4B', returned: 'gemma-4-E4B' },
+];
+const completion = (model?: string) => ({ id: 'c', object: 'chat.completion', created: 1, model,
+ choices: [{ index: 0, message: { role: 'assistant', content: 'OK' }, finish_reason: 'stop' }],
+ usage: { prompt_tokens: 3, completion_tokens: 1, total_tokens: 4 } });
+const stream = (model?: string) => new Response([
+ { id: 's', object: 'chat.completion.chunk', created: 1, model, choices: [{ index: 0, delta: { content: 'OK' }, finish_reason: null }] },
+ { id: 's', object: 'chat.completion.chunk', created: 1, model, choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] },
+ { id: 's', object: 'chat.completion.chunk', created: 1, choices: [], usage: { prompt_tokens: 3, completion_tokens: 1, total_tokens: 4 } },
+].map(c => `data: ${JSON.stringify(c)}\n\n`).join('') + 'data: [DONE]\n\n');
+
+describe.each(configs)('$platform catalog-only adapter', config => {
+ beforeEach(() => { process.env.ENCRYPTION_KEY = '0'.repeat(64); initDb(':memory:'); });
+ afterEach(() => { vi.restoreAllMocks(); getDb().close(); });
+
+ it('registers keys, explicit import aliases and one shared quota pool', () => {
+ expect(getProvider(config.platform)).toBeInstanceOf(config.provider);
+ expect(getProvider(config.platform)!.keyless).toBe(false);
+ expect(parseKeysFromFile(`${config.platform.toUpperCase()}_API_KEY=test-key`, 'keys.env').keys[0].platform).toBe(config.platform);
+ expect(AUTH_JSON_PROVIDER_MAP[config.platform]).toBe(config.platform);
+ expect(inferPoolForPlatform(config.platform, 'model-one')).toBe(inferPoolForPlatform(config.platform, 'model-two'));
+ });
+
+ it('authenticates read-only account metadata without requiring purchased credits', async () => {
+ const fetch = vi.spyOn(global, 'fetch').mockResolvedValue(json(config.account));
+ await expect(new config.provider().validateKey('test-key')).resolves.toBe(true);
+ expect(fetch.mock.calls[0][0]).toBe(config.validate);
+ expect(fetch.mock.calls[0][1]?.method).toBe('GET');
+ expect(new Headers(fetch.mock.calls[0][1]?.headers).get('authorization')).toBe('Bearer test-key');
+ expect(fetch).toHaveBeenCalledTimes(1);
+ });
+
+ it.each([401, 403])('rejects authentication failure %s', async status => {
+ vi.spyOn(global, 'fetch').mockResolvedValue(json({ error: { message: 'Invalid key' } }, status));
+ await expect(new config.provider().validateKey('bad-key')).resolves.toMatchObject({ valid: false });
+ });
+
+ it.each([402, 429, 503])('treats validation HTTP %s as inconclusive and preserves retry hints', async status => {
+ vi.spyOn(global, 'fetch').mockResolvedValue(json({}, status, { 'Retry-After': '12' }));
+ await expect(new config.provider().validateKey('test-key')).rejects.toMatchObject({ status, retryAfterMs: 12_000 });
+ });
+
+ it.each(['{}', 'null', '<html>Sign in</html>'])('rejects malformed account responses', async body => {
+ vi.spyOn(global, 'fetch').mockResolvedValue(new Response(body));
+ await expect(new config.provider().validateKey('test-key')).rejects.toMatchObject({ status: 502 });
+ });
+
+ it('preserves exact requests, tool parameters, output and attribution', async () => {
+ const fetch = vi.spyOn(global, 'fetch').mockResolvedValue(json(completion(config.returned)));
+ const tools = [{ type: 'function' as const, function: { name: 'lookup', parameters: { type: 'object' } } }];
+ const result = await new config.provider().chatCompletion('test-key', [{ role: 'user', content: 'Hi' }], config.model,
+ { max_tokens: 512, temperature: 0.2, stop: 'END', tools, tool_choice: 'auto', response_format: { type: 'json_object' } });
+ expect(fetch.mock.calls[0][0]).toBe(`${config.base}/chat/completions`);
+ const body = JSON.parse(String(fetch.mock.calls[0][1]?.body));
+ expect(body).toMatchObject({ model: config.model, max_tokens: 512, tools, response_format: { type: 'json_object' }, stop: config.platform === 'simplellm' ? ['END'] : 'END' });
+ expect(result.choices[0].message.content).toBe('OK');
+ expect(result.usage?.total_tokens).toBe(4);
+ expect(result._routed_via).toEqual({ platform: config.platform, model: config.model });
+ });
+
+ it('streams matching identity and usage-only terminal frames', async () => {
+ const fetch = vi.spyOn(global, 'fetch').mockResolvedValue(stream(config.returned));
+ const chunks = [];
+ for await (const chunk of new config.provider().streamChatCompletion('test-key', [], config.model, { max_tokens: 64, stop: 'END', stream_options: { include_usage: true } })) chunks.push(chunk);
+ expect(chunks.map(c => c.choices[0]?.delta.content ?? '').join('')).toBe('OK');
+ expect(chunks.at(-1)?.usage?.total_tokens).toBe(4);
+ expect(JSON.parse(String(fetch.mock.calls[0][1]?.body))).toMatchObject({ stream: true, stream_options: { include_usage: true } });
+ });
+
+ it.each(['another-model', undefined])('rejects substituted/missing model identity in chat and SSE', async returned => {
+ const fetch = vi.spyOn(global, 'fetch').mockResolvedValueOnce(json(completion(returned))).mockResolvedValueOnce(stream(returned));
+ await expect(new config.provider().chatCompletion('test-key', [], config.model)).rejects.toMatchObject({ status: 502 });
+ const collect = async () => { for await (const _ of new config.provider().streamChatCompletion('test-key', [], config.model)) { /* drain */ } };
+ await expect(collect()).rejects.toMatchObject({ status: 502 });
+ expect(fetch).toHaveBeenCalledTimes(2);
+ });
+
+ it.each([402, 429, 503])('preserves inference error HTTP %s without retrying paid fallback', async status => {
+ const fetch = vi.spyOn(global, 'fetch').mockResolvedValue(json({ error: { message: 'Unavailable' } }, status, { 'Retry-After': '17' }));
+ await expect(new config.provider().chatCompletion('test-key', [], config.model)).rejects.toMatchObject({ status, retryAfterMs: 17_000 });
+ expect(fetch).toHaveBeenCalledTimes(1);
+ });
+
+ it('does not seed or discover models; only ingests tier-selected catalog rows', () => {
+ const db = getDb();
+ expect(db.prepare('SELECT COUNT(*) AS n FROM models WHERE platform=?').get(config.platform)).toEqual({ n: 0 });
+ expect(isBuiltinDiscoveryEligible(db, config.platform)).toBe(false);
+ const result = applyCatalog(db, { version: '2099.01.01', generatedAt: new Date().toISOString(), tier: 'live', quirks: [], models: [{ platform: config.platform, modelId: config.model, displayName: 'Test model', intelligenceRank: 50, speedRank: 50, sizeLabel: '', limits: { rpm: null, rpd: null, tpm: null, tpd: null }, monthlyTokenBudget: 'Shared free allowance', contextWindow: 8192, enabled: true, supportsTools: false, supportsVision: false }] });
+ expect(result.skippedUnknownPlatform).toBe(0);
+ expect(db.prepare('SELECT model_id FROM models WHERE platform=?').all(config.platform)).toEqual([{ model_id: config.model }]);
+ });
+});
+
+describe('Inferbase wire-format guards and documented free output ceiling', () => {
+ beforeEach(() => { process.env.ENCRYPTION_KEY = '0'.repeat(64); initDb(':memory:'); });
+ afterEach(() => { vi.restoreAllMocks(); getDb().close(); });
+ it('filters provider routing/usage receipts while retaining standard completion and usage chunks', async () => {
+ const model = 'deepseek-v4-flash';
+ const body = `data: ${JSON.stringify({ object: 'routing', model })}\n\n` +
+ (await stream(model).text()).replace('data: [DONE]', `data: ${JSON.stringify({ object: 'usage', model, cost_micros: 0 })}\n\ndata: [DONE]`);
+ vi.spyOn(global, 'fetch').mockResolvedValue(new Response(body));
+ const chunks = [];
+ for await (const chunk of new InferbaseProvider().streamChatCompletion('test-key', [], model)) chunks.push(chunk);
+ expect(chunks).toHaveLength(3);
+ expect(chunks.every(c => Array.isArray(c.choices))).toBe(true);
+ expect(chunks.at(-1)?.usage?.total_tokens).toBe(4);
+ });
+ it.each(['routing', 'usage'])('does not silently accept a substituted identity in a %s receipt', async object => {
+ vi.spyOn(global, 'fetch').mockResolvedValue(new Response(`data: ${JSON.stringify({ object, model: 'another-model' })}\n\ndata: [DONE]\n\n`));
+ const collect = async () => { for await (const _ of new InferbaseProvider().streamChatCompletion('test-key', [], 'deepseek-v4-flash')) { /* drain */ } };
+ await expect(collect()).rejects.toMatchObject({ status: 502 });
+ });
+ it.each([{ object: 'error', error: { message: 'Upstream unavailable' } }, { object: 'chat.completion.chunk' }])('rejects malformed and in-band error events after a valid chunk', async event => {
+ const first = { id: 's', object: 'chat.completion.chunk', model: 'deepseek-v4-flash', choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }] };
+ vi.spyOn(global, 'fetch').mockResolvedValue(new Response([first, event].map(c => `data: ${JSON.stringify(c)}\n\n`).join('') + 'data: [DONE]\n\n'));
+ const collect = async () => { for await (const _ of new InferbaseProvider().streamChatCompletion('test-key', [], 'deepseek-v4-flash')) { /* drain */ } };
+ await expect(collect()).rejects.toMatchObject({ status: 502 });
+ });
+ it.each([undefined, 32768, 128])('normalizes max_tokens=%s without requesting paid capacity', async max_tokens => {
+ const fetch = vi.spyOn(global, 'fetch').mockResolvedValue(json(completion('deepseek-v4-flash')));
+ await new InferbaseProvider().chatCompletion('test-key', [], 'deepseek-v4-flash', { max_tokens });
+ expect(JSON.parse(String(fetch.mock.calls[0][1]?.body)).max_tokens).toBe(max_tokens === 128 ? 128 : 1024);
+ });
+});
diff --git a/server/src/__tests__/routes/keys.test.ts b/server/src/__tests__/routes/keys.test.ts
index 0e01a985..ece83c3b 100644
--- a/server/src/__tests__/routes/keys.test.ts
+++ b/server/src/__tests__/routes/keys.test.ts
@@ -217,7 +217,7 @@ describe('Keys API', () => {
expect(status).toBe(400);
});
- it.each(['aclide', 'speka', 'electronhub', 'experiential', 'router9', 'septor', 'clod', 'speechify', 'blaze', 'lucidity', 'airforce', 'dreamprompting', 'waterfall', 'logfare'])('accepts a %s key without seeding gated model rows', async platform => {
+ it.each(['inferbase', 'simplellm', 'aclide', 'speka', 'electronhub', 'experiential', 'router9', 'septor', 'clod', 'speechify', 'blaze', 'lucidity', 'airforce', 'dreamprompting', 'waterfall', 'logfare'])('accepts a %s key without seeding gated model rows', async platform => {
const { status, body } = await request(app, 'POST', '/api/keys', {
platform, key: 'not-a-real-test-key-12345', label: 'Gateway test',
});
diff --git a/server/src/__tests__/services/electronhub-embeddings.test.ts b/server/src/__tests__/services/electronhub-embeddings.test.ts
new file mode 100644
index 00000000..c22b825e
--- /dev/null
+++ b/server/src/__tests__/services/electronhub-embeddings.test.ts
@@ -0,0 +1,60 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { getDb, initDb } from '../../db/index.js';
+import { encrypt } from '../../lib/crypto.js';
+import { EMBEDDING_PLATFORMS, runEmbeddings } from '../../services/embeddings.js';
+import { applyCatalog } from '../../services/catalog-sync.js';
+
+const models = [
+ ['text-embedding-3-small', 1536], ['text-embedding-3-large', 3072],
+ ['codestral-embed', 1536], ['mistral-embed', 1024], ['gemini-embedding-2', 3072],
+] as const;
+const json = (body: unknown) => new Response(JSON.stringify(body));
+function seed(model: string, dimensions: number) {
+ const db = getDb(), secret = encrypt('electronhub-test-key');
+ db.prepare("INSERT INTO api_keys (platform,label,encrypted_key,iv,auth_tag,status,enabled) VALUES ('electronhub','test',?,?,?,'healthy',1)").run(secret.encrypted, secret.iv, secret.authTag);
+ const result = applyCatalog(db, { version: '2099.01.01', generatedAt: new Date().toISOString(), tier: 'live', models: [], quirks: [],
+ embeddings: [{ platform: 'electronhub', modelId: model, family: 'eh-test', displayName: model, dimensions, maxInputTokens: null, priority: 1, enabled: true, quotaLabel: '$0.25/week shared' }] });
+ expect(result.skippedUnknownPlatform).toBe(0);
+}
+
+describe('ElectronHub catalog-managed embeddings', () => {
+ beforeEach(() => { process.env.ENCRYPTION_KEY = '0'.repeat(64); initDb(':memory:'); });
+ afterEach(() => { vi.restoreAllMocks(); getDb().close(); });
+
+ it.each(models)('routes %s with float vectors, sorted input order and usage', async (model, dimensions) => {
+ seed(model, dimensions);
+ const fetch = vi.spyOn(global, 'fetch').mockResolvedValue(json({ model, data: [{ index: 1, embedding: Array(dimensions).fill(0.2) }, { index: 0, embedding: Array(dimensions).fill(0.1) }], usage: { prompt_tokens: 4 } }));
+ const result = await runEmbeddings('eh-test', ['first', 'second']);
+ expect(EMBEDDING_PLATFORMS.has('electronhub')).toBe(true);
+ expect(fetch.mock.calls[0][0]).toBe('https://api.electronhub.ai/v1/embeddings');
+ expect(new Headers(fetch.mock.calls[0][1]?.headers).get('authorization')).toBe('Bearer electronhub-test-key');
+ expect(JSON.parse(String(fetch.mock.calls[0][1]?.body))).toEqual({ model, input: ['first', 'second'], encoding_format: 'float' });
+ expect(result).toMatchObject({ platform: 'electronhub', modelId: model, dimensions, inputTokens: 4 });
+ expect(result.vectors.map(v => v[0])).toEqual([0.1, 0.2]);
+ });
+
+ it('forwards and validates an explicit dimensions override', async () => {
+ seed('text-embedding-3-small', 1536);
+ const fetch = vi.spyOn(global, 'fetch').mockResolvedValue(json({ model: 'text-embedding-3-small', data: [{ index: 0, embedding: [0.1, 0.2] }] }));
+ expect((await runEmbeddings('eh-test', ['hello'], 2)).dimensions).toBe(2);
+ expect(JSON.parse(String(fetch.mock.calls[0][1]?.body)).dimensions).toBe(2);
+ });
+
+ it.each([
+ { model: 'wrong', data: [{ index: 0, embedding: [0.1, 0.2] }] },
+ { data: [{ index: 0, embedding: [0.1, 0.2] }] },
+ { model: 'test', data: [{ index: 0, embedding: [0.1] }] },
+ { model: 'test', data: [{ index: 0, embedding: [0.1, null] }] },
+ { model: 'test', data: [{ index: 1, embedding: [0.1, 0.2] }] },
+ ])('rejects model substitution, invalid dimensions and malformed vectors', async body => {
+ seed('test', 2);
+ vi.spyOn(global, 'fetch').mockResolvedValue(json(body));
+ await expect(runEmbeddings('eh-test', ['hello'])).rejects.toMatchObject({ status: 502 });
+ });
+
+ it('preserves rate-limit retry hints', async () => {
+ seed('test', 2);
+ vi.spyOn(global, 'fetch').mockResolvedValue(new Response('Rate limited', { status: 429, headers: { 'Retry-After': '20' } }));
+ await expect(runEmbeddings('eh-test', ['hello'])).rejects.toMatchObject({ status: 429, retryAfterMs: 20_000 });
+ });
+});
diff --git a/server/src/lib/key-parser.ts b/server/src/lib/key-parser.ts
index 0d326e22..27ec13a9 100644
--- a/server/src/lib/key-parser.ts
+++ b/server/src/lib/key-parser.ts
@@ -48,6 +48,9 @@ export const PREFIX_MAP: Record<string, string> = {
SPEKA_: 'speka',
TYPHOON_: 'typhoon',
PLUGSKY_: 'plugsky',
+ INFERBASE_: 'inferbase',
+ SIMPLELLM_: 'simplellm',
+ SIMPLE_LLM_: 'simplellm',
OPENTYPHOON_: 'typhoon',
OPEN_TYPHOON_: 'typhoon',
LLMTR_: 'llmtr',
@@ -151,6 +154,9 @@ export const AUTH_JSON_PROVIDER_MAP: Record<string, string> = {
speka: 'speka',
typhoon: 'typhoon',
plugsky: 'plugsky',
+ inferbase: 'inferbase',
+ simplellm: 'simplellm',
+ 'simple-llm': 'simplellm',
opentyphoon: 'typhoon',
'open-typhoon': 'typhoon',
llmtr: 'llmtr',
diff --git a/server/src/lib/sampling-params.ts b/server/src/lib/sampling-params.ts
index 4224a583..a68d0f6f 100644
--- a/server/src/lib/sampling-params.ts
+++ b/server/src/lib/sampling-params.ts
@@ -242,6 +242,9 @@ export const GITHUB_MAX_OUTPUT_TOKENS = 400;
// silently no-op'ing the policy; the string-typed accessors below cast at the
// boundary since routes carry platform ids as plain strings.
export const PLATFORM_PARAM_POLICIES: Partial<Record<Platform, PlatformParamPolicy>> = {
+ // Inferbase Free managed inference rejects output budgets above 1,024.
+ // Match the documented upstream ceiling, not a new application quota.
+ inferbase: { defaultMaxTokens: 1024, maxTokensCap: 1024 },
// Gizmo rejects all unlisted fields; reflect its text-only API in discovery
// as well as the adapter. This is the upstream ceiling, not a new quota.
gizmo: { drop: [...EXTENDED_SAMPLING_KEYS], defaultMaxTokens: 1024, maxTokensCap: 32768 },
diff --git a/server/src/providers/index.ts b/server/src/providers/index.ts
index 5d8dfcd2..c72be456 100644
--- a/server/src/providers/index.ts
+++ b/server/src/providers/index.ts
@@ -13,6 +13,8 @@ import { AclideProvider } from './aclide.js';
import { SpekaProvider } from './speka.js';
import { TyphoonProvider } from './typhoon.js';
import { PlugskyProvider } from './plugsky.js';
+import { InferbaseProvider } from './inferbase.js';
+import { SimpleLLMProvider } from './simplellm.js';
import { LlmtrProvider } from './llmtr.js';
import { GizmoProvider } from './gizmo.js';
import { BlockRunProvider } from './blockrun.js';
@@ -66,6 +68,8 @@ register(new AclideProvider());
register(new SpekaProvider());
register(new TyphoonProvider());
register(new PlugskyProvider());
+register(new InferbaseProvider());
+register(new SimpleLLMProvider());
register(new LlmtrProvider());
register(new GizmoProvider());
register(new BlockRunProvider());
diff --git a/server/src/providers/inferbase.ts b/server/src/providers/inferbase.ts
new file mode 100644
index 00000000..1e71e406
--- /dev/null
+++ b/server/src/providers/inferbase.ts
@@ -0,0 +1,73 @@
+import type { ChatCompletionChunk, ChatCompletionResponse, ChatMessage } from '@freellmapi/shared/types.js';
+import { providerHttpError, type CompletionOptions, type KeyValidationResult } from './base.js';
+import type { QuotaObservationContext } from '../services/provider-quota.js';
+import { OpenAICompatProvider } from './openai-compat.js';
+
+export const INFERBASE_BASE_URL = 'https://api.inferbase.ai/v1';
+
+function checkModel(requested: string, returned: string): void {
+ // Pin explicit catalog IDs, including :fp8/:turbo variants. Never silently
+ // accept an auto-routed substitute as the requested model.
+ if (returned !== requested) {
+ throw Object.assign(new Error('Inferbase returned a different or missing model identity'), { status: 502 });
+ }
+}
+
+/** Free managed chat shares monthly request and daily usage allowances.
+ * Model rows remain exclusively in the signed, tier-gated catalog. */
+export class InferbaseProvider extends OpenAICompatProvider {
+ constructor() {
+ super({
+ platform: 'inferbase', name: 'Inferbase', baseUrl: INFERBASE_BASE_URL,
+ // /models is public. Read authenticated credits instead; a $0 balance
+ // is valid on Free and must not disable the key.
+ validateUrl: 'https://api.inferbase.ai/api/v1/inference/credits',
+ });
+ }
+
+ protected override async validationResult(response: Response): Promise<KeyValidationResult> {
+ if ([401, 403].includes(response.status)) return super.validationResult(response);
+ if (!response.ok) throw providerHttpError(response, 'Inferbase key validation is temporarily inconclusive');
+ const body = await response.json().catch(() => null) as { balance_micros?: unknown } | null;
+ if (typeof body?.balance_micros !== 'number' || !Number.isFinite(body.balance_micros)) {
+ throw Object.assign(new Error('Inferbase returned an invalid credits response'), { status: 502 });
+ }
+ return true;
+ }
+
+ override async chatCompletion(apiKey: string, messages: ChatMessage[], modelId: string,
+ options?: CompletionOptions, quotaContext?: QuotaObservationContext): Promise<ChatCompletionResponse> {
+ const response = await super.chatCompletion(apiKey, messages, modelId, options, quotaContext);
+ checkModel(modelId, response.model);
+ return response;
+ }
+
+ override async *streamChatCompletion(apiKey: string, messages: ChatMessage[], modelId: string,
+ options?: CompletionOptions, quotaContext?: QuotaObservationContext): AsyncGenerator<ChatCompletionChunk> {
+ let identified = false;
+ for await (const chunk of super.streamChatCompletion(apiKey, messages, modelId, options, quotaContext)) {
+ // Inference failures may arrive as HTTP 200 SSE error events, including
+ // after a valid role chunk. Never forward these as successful completions.
+ if ('error' in chunk) {
+ throw Object.assign(new Error('Inferbase returned an upstream stream error or malformed event'), { status: 502 });
+ }
+ // Inferbase interleaves routing and billing receipts with OpenAI chunks.
+ // Validate their attribution but keep these provider-only frames out of
+ // the client stream. The standard usage-only chunk is preserved below.
+ if (['routing', 'usage'].includes(chunk.object)) {
+ checkModel(modelId, chunk.model);
+ continue;
+ }
+ if (!Array.isArray(chunk.choices)) {
+ throw Object.assign(new Error('Inferbase returned a malformed stream event'), { status: 502 });
+ }
+ if (chunk.model || chunk.choices?.length) {
+ checkModel(modelId, chunk.model);
+ identified = true;
+ }
+ if (!identified) checkModel(modelId, chunk.model);
+ yield chunk;
+ }
+ if (!identified) checkModel(modelId, '');
+ }
+}
diff --git a/server/src/providers/simplellm.ts b/server/src/providers/simplellm.ts
new file mode 100644
index 00000000..6790198d
--- /dev/null
+++ b/server/src/providers/simplellm.ts
@@ -0,0 +1,59 @@
+import type { ChatCompletionChunk, ChatCompletionResponse, ChatMessage } from '@freellmapi/shared/types.js';
+import { providerHttpError, type CompletionOptions, type KeyValidationResult } from './base.js';
+import type { QuotaObservationContext } from '../services/provider-quota.js';
+import { OpenAICompatProvider } from './openai-compat.js';
+
+export const SIMPLELLM_BASE_URL = 'https://api.simplellm.eu/v1';
+const RETURNED_ALIASES: Readonly<Record<string, string>> = {
+ 'free-gemma-4-E4B': 'gemma-4-E4B',
+ 'free-Llama-3.1-8B-Instruct': 'Llama-3.1-8B',
+};
+
+function checkModel(requested: string, returned: string): void {
+ if (returned !== requested && (!RETURNED_ALIASES[requested] || returned !== RETURNED_ALIASES[requested])) {
+ throw Object.assign(new Error('SimpleLLM returned a different or missing model identity'), { status: 502 });
+ }
+}
+
+function wireOptions(options?: CompletionOptions): CompletionOptions | undefined {
+ // SimpleLLM accepts stop arrays, not a scalar stop string.
+ return typeof options?.stop === 'string' ? { ...options, stop: [options.stop] } : options;
+}
+
+export class SimpleLLMProvider extends OpenAICompatProvider {
+ constructor() {
+ super({ platform: 'simplellm', name: 'SimpleLLM', baseUrl: SIMPLELLM_BASE_URL,
+ validateUrl: `${SIMPLELLM_BASE_URL}/rate-limit` });
+ }
+
+ protected override async validationResult(response: Response): Promise<KeyValidationResult> {
+ if ([401, 403].includes(response.status)) return super.validationResult(response);
+ if (!response.ok) throw providerHttpError(response, 'SimpleLLM key validation is temporarily inconclusive');
+ const body = await response.json().catch(() => null) as { limit_rpm?: unknown } | null;
+ if (typeof body?.limit_rpm !== 'number' || !Number.isFinite(body.limit_rpm)) {
+ throw Object.assign(new Error('SimpleLLM returned an invalid rate-limit response'), { status: 502 });
+ }
+ return true;
+ }
+
+ override async chatCompletion(apiKey: string, messages: ChatMessage[], modelId: string,
+ options?: CompletionOptions, quotaContext?: QuotaObservationContext): Promise<ChatCompletionResponse> {
+ const response = await super.chatCompletion(apiKey, messages, modelId, wireOptions(options), quotaContext);
+ checkModel(modelId, response.model);
+ return response;
+ }
+
+ override async *streamChatCompletion(apiKey: string, messages: ChatMessage[], modelId: string,
+ options?: CompletionOptions, quotaContext?: QuotaObservationContext): AsyncGenerator<ChatCompletionChunk> {
+ let identified = false;
+ for await (const chunk of super.streamChatCompletion(apiKey, messages, modelId, wireOptions(options), quotaContext)) {
+ if (chunk.model || chunk.choices?.length) {
+ checkModel(modelId, chunk.model);
+ identified = true;
+ }
+ if (!identified) checkModel(modelId, chunk.model);
+ yield chunk;
+ }
+ if (!identified) checkModel(modelId, '');
+ }
+}
diff --git a/server/src/routes/keys.ts b/server/src/routes/keys.ts
index b5fcd227..6494f660 100644
--- a/server/src/routes/keys.ts
+++ b/server/src/routes/keys.ts
@@ -46,6 +46,8 @@ const PLATFORMS = [
'speka',
'typhoon',
'plugsky',
+ 'inferbase',
+ 'simplellm',
'llmtr',
'gizmo',
'blockrun',
diff --git a/server/src/services/embeddings.ts b/server/src/services/embeddings.ts
index 1034f6be..96190756 100644
--- a/server/src/services/embeddings.ts
+++ b/server/src/services/embeddings.ts
@@ -18,6 +18,7 @@ import { bearerAuthHeader } from '../lib/credential.js';
import { customEndpointKeyIds } from './custom-endpoint.js';
import type { Db } from '../db/types.js';
import { SPEKA_BASE_URL } from '../providers/speka.js';
+import { ELECTRONHUB_BASE_URL } from '../providers/electronhub.js';
export interface EmbeddingModelRow {
id: number;
@@ -115,6 +116,7 @@ export const EMBEDDING_PLATFORMS = new Set([
'cohere',
'sealion',
'speka',
+ 'electronhub',
]);
interface ProviderCallResult {
@@ -130,6 +132,7 @@ async function openAiStyleEmbed(
inputs: string[],
extra: Record<string, unknown> = {},
dimensions?: number,
+ expectedDimensions?: number,
): Promise<ProviderCallResult> {
const body: Record<string, unknown> = { model: modelId, input: inputs, ...extra };
// Some providers (NVIDIA NeMo NIM, Google Gemini Embedding, OpenAI v3) support
@@ -151,10 +154,21 @@ async function openAiStyleEmbed(
throw await upstreamEmbeddingsError(r);
}
const j = (await r.json()) as {
+ model?: string;
data?: { index?: number; embedding: number[] }[];
usage?: { prompt_tokens?: number; total_tokens?: number };
};
const data = [...(j.data ?? [])].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+ if (platform === 'electronhub' && (
+ j.model !== modelId || data.length !== inputs.length ||
+ data.some((d, i) => d.index !== i || !Array.isArray(d.embedding) ||
+ d.embedding.length !== (dimensions ?? expectedDimensions) ||
+ d.embedding.some(value => typeof value !== 'number' || !Number.isFinite(value)))
+ )) {
+ // A successful HTTP response is not enough: wrong model/dimension or
+ // malformed vectors would corrupt the caller's embedding family.
+ throw new EmbeddingsError('ElectronHub returned mismatched or malformed embeddings', 502);
+ }
return {
vectors: data.map(d => d.embedding),
inputTokens: j.usage?.prompt_tokens ?? j.usage?.total_tokens ?? null,
@@ -267,6 +281,8 @@ async function callProvider(row: EmbeddingModelRow, credential: ProviderCredenti
return openAiStyleEmbed('https://api.sea-lion.ai/v1/embeddings', row.platform, key, row.model_id, inputs, {}, dimensions);
case 'speka':
return openAiStyleEmbed(`${SPEKA_BASE_URL}/embeddings`, row.platform, key, row.model_id, inputs, { encoding_format: 'float' }, dimensions);
+ case 'electronhub':
+ return openAiStyleEmbed(`${ELECTRONHUB_BASE_URL}/embeddings`, row.platform, key, row.model_id, inputs, { encoding_format: 'float' }, dimensions, row.dimensions);
case 'cloudflare': {
// Key is stored as "account_id:token".
const sep = key.indexOf(':');
diff --git a/server/src/services/provider-quota.ts b/server/src/services/provider-quota.ts
index 821a6427..c420d747 100644
--- a/server/src/services/provider-quota.ts
+++ b/server/src/services/provider-quota.ts
@@ -119,6 +119,8 @@ export function inferPoolForPlatform(platform: Platform, modelId?: string | null
if (platform === 'aclide') return 'aclide::monthly-credit';
if (platform === 'speka') return 'speka::monthly-credit';
if (platform === 'plugsky') return 'plugsky::fair-use';
+ if (platform === 'inferbase') return 'inferbase::managed-free';
+ if (platform === 'simplellm') return 'simplellm::free';
if (platform === 'electronhub') return normalizedModelId.endsWith(':free') ? 'electronhub::daily-free' : 'electronhub::weekly-credit';
if (platform === 'experiential') return 'experiential::monthly-credit';
if (platform === 'router9') return 'router9::monthly-credit';
@@ -182,6 +184,7 @@ function isSharedPool(platform: Platform): boolean {
if (platform === 'aclide') return true;
if (platform === 'speka') return true;
if (platform === 'plugsky') return true;
+ if (platform === 'inferbase' || platform === 'simplellm') return true;
if (['electronhub', 'experiential', 'router9', 'septor', 'clod', 'speechify', 'blaze', 'lucidity', 'airforce', 'dreamprompting', 'waterfall', 'logfare'].includes(platform)) return true;
return ['openrouter', 'google', 'groq', 'cerebras', 'sail', 'bai', 'radeon', 'sambanova', 'nvidia', 'mistral', 'github', 'cohere', 'cloudflare', 'zhipu', 'ollama', 'kilo', 'pollinations', 'llm7', 'huggingface', 'opencode', 'routeway', 'bazaarlink', 'ainative', 'aion', 'requesty', 'navy', 'nara', 'sealion', 'orcarouter', 'unorouter', 'xkiro', 'anyapi', 'modelscope', 'aihorde'].includes(platform);
}
diff --git a/shared/types.ts b/shared/types.ts
index ced000e8..24a9eb1f 100644
--- a/shared/types.ts
+++ b/shared/types.ts
@@ -76,6 +76,9 @@ export type Platform =
| 'typhoon'
// Permanent free chat aliases, shared fair-use quota; signed catalog only.
| 'plugsky'
+ // Catalog-only free chat gateways; shared monthly/daily account allowances.
+ | 'inferbase'
+ | 'simplellm'
// Selected zero-priced routes have daily/rolling quotas without a top-up;
// signed catalog only. The public roster also includes paid/promotional IDs.
| 'llmtr'