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.tsxindex 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.tsindex 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.mdindex 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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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: ProviderCredentireturn 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.tsindex 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 | nullif (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.tsindex 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'