Integration request from AIML API

apps/daemon/src/connectionTest.ts

@@ -60,6 +60,7 @@ import {
   isUnsupportedMaxTokensError,
 } from './integrations/openai-chat-token-params.js';
 import { aihubmixHeaders } from './integrations/aihubmix.js';
+import { aimlapiHeaders } from './integrations/aimlapi.js';
 import type { AgentCliEnvPrefs } from './app-config.js';
 import type { RuntimeAgentDef } from './runtimes/types.js';
 import { preparePromptFileForAgent, type PreparedPromptFile } from './runtimes/prompt-file.js';
@@ -945,7 +946,13 @@ function inspectProviderCompletion(
   const obj = data && typeof data === 'object' ? data as Record<string, unknown> : null;
   if (!obj) return { valid: false };
 
-  if (protocol === 'openai' || protocol === 'azure' || protocol === 'senseaudio' || protocol === 'aihubmix') {
+  if (
+    protocol === 'openai' ||
+    protocol === 'azure' ||
+    protocol === 'senseaudio' ||
+    protocol === 'aihubmix' ||
+    protocol === 'aimlapi'
+  ) {
     const responseModel = typeof obj.model === 'string' ? obj.model : '';
     if (
       // AIHubMix is omitted from the strict response-model check (like Azure):
@@ -1421,6 +1428,24 @@ function buildProviderCall(input: ProviderTestRequest): ProviderCallShape {
           return '';
         },
       };
+    case 'aimlapi':
+      // aimlapi.com is wire-compatible with OpenAI but carries the attribution
+      // pair on every request (see aimlapiHeaders) — the smoke test included,
+      // so a key check is attributed like any other call.
+      return {
+        url: appendVersionedApiPath(baseUrl, '/chat/completions'),
+        headers: {
+          'content-type': 'application/json',
+          ...aimlapiHeaders(apiKey),
+        },
+        body: {
+          model,
+          ...buildOpenAIChatTokenParam(model, PROVIDER_MAX_TOKENS),
+          messages: [{ role: 'user', content: SMOKE_PROMPT }],
+          stream: false,
+        },
+        extractText: extractOpenAIMessageText,
+      };
     case 'aihubmix':
       // AIHubMix is wire-compatible with OpenAI but carries the fixed APP-Code
       // attribution header on every request (see aihubmixHeaders). Same body /

apps/daemon/src/integrations/aimlapi.ts

@@ -0,0 +1,83 @@
+// aimlapi.com BYOK provider — shared identity + outbound header helper.
+//
+// aimlapi.com (https://aimlapi.com) is an OpenAI-wire-compatible aggregator:
+// a single API key fronts ~900 models from many creators, routed by model name
+// on the upstream side. Because the wire shape is identical to OpenAI's, the
+// chat proxy, connection test and model discovery all reuse the OpenAI call
+// shape — the ONLY thing that differs is the outbound headers, which is why
+// every outbound call point funnels through `aimlapiHeaders()` rather than
+// hand-building `Authorization` inline.
+//
+// The distinctive aimlapi.com detail is the attribution pair: aimlapi.com
+// expects `X-AIMLAPI-Source` and `X-AIMLAPI-Partner-ID` on EVERY request it
+// serves — inference, catalog and key checks alike, not just sign-up. Injecting
+// them in one helper keeps the invariant "every aimlapi.com request carries our
+// attribution" enforceable in one place instead of being re-derived at each
+// call site; the aggregator's rebate accounting keys off exactly this, and a
+// missing header means the request serves fine but is silently untagged.
+
+/**
+ * Provisioned partner for this integration. Valid on both aimlapi.com's staging
+ * and production backends, so it ships compiled in and one build works against
+ * either — only the base URL differs. Overridable via `AIMLAPI_PARTNER_ID` for
+ * a staging-only test id.
+ */
+export const AIMLAPI_PARTNER_ID = 'part_9TWZWFsyMyNrBDEENq5JaU0r';
+
+/**
+ * `<channel>/<client>` — the channel is a small closed set (agent|mcp|web) and
+ * the client is this integration's registry slug.
+ */
+export const AIMLAPI_SOURCE = 'agent/open-design';
+
+/**
+ * Default base URL the daemon assumes when the BYOK form leaves the field
+ * blank. Kept here as the single source of truth so the chat proxy, model
+ * discovery and connection test all default to the same origin.
+ *
+ * Note the `/v1`: aimlapi.com's OpenAI-compatible surface lives there, while
+ * `/v2` on the same host is billing/usage only and 404s for chat completions.
+ */
+export const AIMLAPI_DEFAULT_BASE_URL = 'https://api.aimlapi.com/v1';
+
+function partnerId(): string {
+  return (process.env.AIMLAPI_PARTNER_ID || '').trim() || AIMLAPI_PARTNER_ID;
+}
+
+/**
+ * The attribution pair on its own (no auth). For any route that carries its own
+ * auth header — spread this alongside it so every aimlapi.com request, whatever
+ * the wire protocol, still carries attribution.
+ */
+export function aimlapiAttributionHeaders(): Record<string, string> {
+  return {
+    'X-AIMLAPI-Source': AIMLAPI_SOURCE,
+    'X-AIMLAPI-Partner-ID': partnerId(),
+  };
+}
+
+/**
+ * Build the outbound header set for an aimlapi.com request: Bearer auth plus
+ * the attribution pair. Callers spread the result into their `fetch` headers
+ * and may add `content-type` etc. on top.
+ */
+export function aimlapiHeaders(apiKey: string): Record<string, string> {
+  return {
+    authorization: `Bearer ${apiKey}`,
+    ...aimlapiAttributionHeaders(),
+  };
+}
+
+/**
+ * Origin of a configured base URL, for callers that need to reach a sibling
+ * path on the same host. Falls back to the default origin when the configured
+ * value is unusable, so a malformed setting degrades instead of throwing.
+ */
+export function aimlapiOriginFromBase(baseUrl: string | undefined | null): string {
+  const candidate = (baseUrl || '').trim() || AIMLAPI_DEFAULT_BASE_URL;
+  try {
+    return new URL(candidate).origin;
+  } catch {
+    return new URL(AIMLAPI_DEFAULT_BASE_URL).origin;
+  }
+}

apps/daemon/src/integrations/provider-models.ts

@@ -12,6 +12,7 @@ import { isLoopbackApiHost } from '@open-design/contracts/api/connectionTest';
 import { redactSecrets, validateUserProviderBaseUrl } from '../connectionTest.js';
 import { googleProviderModelsUrl, normalizeGoogleModelId } from './google-models.js';
 import { aihubmixHeaders, aihubmixCatalogUrl, parseAIHubMixCatalog } from './aihubmix.js';
+import { aimlapiHeaders } from './aimlapi.js';
 
 type ProviderModelsInput = ProviderModelsRequest & {
   signal?: AbortSignal;
@@ -241,7 +242,7 @@ function providerModelsUrl(protocol: ConnectionTestProtocol, baseUrl: string, ap
     // (GET /api/v1/models?type=llm), not the OpenAI /v1/models route.
     return aihubmixCatalogUrl(baseUrl, 'llm');
   }
-  if (protocol === 'openai' || protocol === 'senseaudio') {
+  if (protocol === 'openai' || protocol === 'senseaudio' || protocol === 'aimlapi') {
     return appendVersionedApiPath(baseUrl, '/models');
   }
   if (protocol === 'anthropic') {
@@ -262,6 +263,12 @@ function providerModelsHeaders(
   if (protocol === 'openai' || protocol === 'senseaudio') {
     return { authorization: `Bearer ${apiKey}` };
   }
+  if (protocol === 'aimlapi') {
+    // Carries the X-AIMLAPI-Source/Partner-ID attribution pair alongside Bearer
+    // auth — see aimlapiHeaders() for why every aimlapi.com call funnels through
+    // this helper instead of hand-building the Authorization header.
+    return aimlapiHeaders(apiKey);
+  }
   if (protocol === 'aihubmix') {
     // The catalogue is public — only attach Bearer auth (+ APP-Code) when the
     // user actually supplied a key. An empty `Bearer ` would be rejected by
@@ -285,7 +292,9 @@ function extractModels(protocol: ConnectionTestProtocol, data: unknown): Provide
   // (e.g. gpt-image-2 → "image_generation,llm") would otherwise leak in. Those
   // belong to the dedicated image/video/audio pickers.
   if (protocol === 'aihubmix') return parseAIHubMixCatalog(data, { chatOnly: true });
-  if (protocol === 'openai' || protocol === 'senseaudio') return extractOpenAiModels(data);
+  if (protocol === 'openai' || protocol === 'senseaudio' || protocol === 'aimlapi') {
+    return extractOpenAiModels(data);
+  }
   if (protocol === 'anthropic') return extractAnthropicModels(data);
   if (protocol === 'google') return extractGoogleModels(data);
   return [];

apps/daemon/src/routes/chat.ts

@@ -31,6 +31,7 @@ import {
   aihubmixOriginFromBase,
   classifyAIHubMixModel,
 } from '../integrations/aihubmix.js';
+import { aimlapiHeaders, AIMLAPI_DEFAULT_BASE_URL } from '../integrations/aimlapi.js';
 import { isSafeId as isSafeProjectId } from '../projects.js';
 import { projectKindToTracking } from '@open-design/contracts/analytics';
 import { proxyDispatcherRequestInit, validateUserProviderBaseUrl } from '../connectionTest.js';
@@ -208,13 +209,13 @@ export function registerChatRoutes(app: Express, ctx: RegisterChatRoutesDeps) {
     const protocol = body.protocol;
     if (
       typeof protocol !== 'string' ||
-      !['anthropic', 'openai', 'azure', 'google', 'ollama', 'senseaudio', 'aihubmix', 'bedrock'].includes(protocol)
+      !['aimlapi', 'anthropic', 'openai', 'azure', 'google', 'ollama', 'senseaudio', 'aihubmix', 'bedrock'].includes(protocol)
     ) {
       return sendApiError(
         res,
         400,
         'BAD_REQUEST',
-        'protocol must be one of anthropic|openai|azure|google|ollama|senseaudio|aihubmix|bedrock',
+        'protocol must be one of aimlapi|anthropic|openai|azure|google|ollama|senseaudio|aihubmix|bedrock',
       );
     }
     // AIHubMix's catalogue (GET /api/v1/models?type=llm) is public, so its
@@ -286,13 +287,13 @@ export function registerChatRoutes(app: Express, ctx: RegisterChatRoutesDeps) {
         const protocol = body.protocol;
         if (
           typeof protocol !== 'string' ||
-          !['anthropic', 'openai', 'azure', 'google', 'ollama', 'senseaudio', 'aihubmix', 'bedrock'].includes(protocol)
+          !['aimlapi', 'anthropic', 'openai', 'azure', 'google', 'ollama', 'senseaudio', 'aihubmix', 'bedrock'].includes(protocol)
         ) {
           return sendApiError(
             res,
             400,
             'BAD_REQUEST',
-            'protocol must be one of anthropic|openai|azure|google|ollama|senseaudio|aihubmix|bedrock',
+            'protocol must be one of aimlapi|anthropic|openai|azure|google|ollama|senseaudio|aihubmix|bedrock',
           );
         }
         const apiKeyRequired = protocol !== 'bedrock';
@@ -1179,6 +1180,165 @@ export function registerChatRoutes(app: Express, ctx: RegisterChatRoutesDeps) {
     }
   });
 
+  // aimlapi.com: OpenAI-wire-compatible aggregator (~900 models behind one
+  // key). Wire-identical to the generic OpenAI route, so this is that route
+  // with one difference — every request carries the aimlapi.com attribution
+  // pair via aimlapiHeaders(). A dedicated route rather than a hostname branch
+  // in the OpenAI one keeps "picker tab -> daemon log line -> upstream call"
+  // readable end to end, the same reasoning the AIHubMix client documents.
+  app.post('/api/proxy/aimlapi/stream', async (req, res) => {
+    /** @type {Partial<ProxyStreamRequest>} */
+    const proxyBody = req.body || {};
+    if (rejectProxyPluginContext(proxyBody, res)) return;
+    const { baseUrl, apiKey, model, systemPrompt, messages, maxTokens } =
+      proxyBody;
+    if (!baseUrl || !apiKey || !model) {
+      return sendApiError(
+        res,
+        400,
+        'BAD_REQUEST',
+        'baseUrl, apiKey, and model are required',
+      );
+    }
+
+    const validated = await validateExternalApiBaseUrl(baseUrl);
+    if (validated.error) {
+      return sendApiError(
+        res,
+        validated.forbidden ? 403 : 400,
+        validated.forbidden ? 'FORBIDDEN' : 'BAD_REQUEST',
+        validated.error,
+      );
+    }
+    const reasoningDenial = authorizeReasoningEgress({
+      policy: proxyBody.reasoningExecution,
+      routeKind: 'proxy',
+      provider: 'aimlapi',
+      resolvedBaseUrl: baseUrl,
+      model,
+    });
+    if (reasoningDenial) return sendReasoningEgressDenial(res, reasoningDenial);
+
+    const url = appendVersionedApiPath(baseUrl, '/chat/completions');
+    console.log(
+      `[proxy:aimlapi] ${req.method} ${validated.parsed!.hostname} model=${model}`,
+    );
+
+    const payloadMessages = Array.isArray(messages) ? [...messages] : [];
+    if (typeof systemPrompt === 'string' && systemPrompt) {
+      payloadMessages.unshift({ role: 'system', content: systemPrompt });
+    }
+
+    const effectiveMaxTokens =
+      typeof maxTokens === 'number' && maxTokens > 0 ? maxTokens : 8192;
+    const payload: any = {
+      model,
+      messages: payloadMessages,
+      ...buildOpenAIChatTokenParam(model, effectiveMaxTokens),
+      stream: true,
+    };
+    const retryPayload = {
+      model,
+      messages: payloadMessages,
+      ...buildMaxCompletionTokensParam(effectiveMaxTokens),
+      stream: true,
+    };
+    const canRetryUnsupportedMaxTokens = isAzureOpenAIHostname(
+      validated.parsed!.hostname,
+    );
+
+    const sse = createSseResponse(res);
+    let proxyDispatcher: ReturnType<typeof proxyDispatcherRequestInit> | null = null;
+    try {
+      proxyDispatcher = proxyDispatcherRequestInit();
+      const signal = clientDisconnectSignal(res);
+      sse.send('start', { model });
+      const requestInit = {
+        ...proxyDispatcher.requestInit,
+        signal,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          // aimlapiHeaders carries Bearer auth AND the attribution pair
+          // aimlapi.com expects on every request. Building the header set in
+          // one helper is what keeps that true when this route changes.
+          ...aimlapiHeaders(apiKey),
+          'HTTP-Referer': 'https://opendesign.dev',
+          'X-Title': 'OpenDesign',
+        },
+        redirect: 'error' as const,
+      };
+      let response = await fetch(url, {
+        ...requestInit,
+        body: JSON.stringify(payload),
+      });
+
+      if (!response.ok) {
+        let errorText = await response.text();
+        if (
+          canRetryUnsupportedMaxTokens &&
+          response.status === 400 &&
+          isUnsupportedMaxTokensError(errorText)
+        ) {
+          console.warn(
+            `[proxy:aimlapi] retrying Azure-hosted request with max_completion_tokens model=${model}`,
+          );
+          response = await fetch(url, {
+            ...requestInit,
+            body: JSON.stringify(retryPayload),
+          });
+          errorText = response.ok ? '' : await response.text();
+        }
+        if (!response.ok) {
+          console.error(
+            `[proxy:aimlapi] upstream error: ${response.status} ${redactAuthTokens(errorText)}`,
+          );
+          sendProxyError(sse, `Upstream error: ${response.status}`, {
+            code: proxyErrorCode(response.status),
+            details: errorText,
+            retryable: response.status === 429 || response.status >= 500,
+          });
+          return sse.end();
+        }
+      }
+
+      let ended = false;
+      const guard = createDeltaGuard(sse);
+      await streamUpstreamSse(response, ({ payload, data }: any) => {
+        if (payload === '[DONE]') {
+          sse.send('end', {});
+          ended = true;
+          return true;
+        }
+        if (!data) return false;
+        const streamError = extractStreamErrorMessage(data);
+        if (streamError) {
+          sendProxyError(sse, `Provider error: ${streamError}`, { details: data });
+          ended = true;
+          return true;
+        }
+        const delta = extractOpenAIText(data);
+        if (delta) { 
+          guard.sendDelta(delta); 
+          if (guard.contaminated) { 
+            sse.send('end', {}); 
+            ended = true; 
+            return true; 
+          } 
+        }
+        return false;
+      });
+      if (!ended) sse.send('end', {});
+      sse.end();
+    } catch (err: any) {
+      console.error(`[proxy:aimlapi] internal error: ${err.message}`);
+      sendProxyError(sse, err.message, { code: 'INTERNAL_ERROR' });
+      sse.end();
+    } finally {
+      await proxyDispatcher?.close();
+    }
+  });
+
   app.post('/api/proxy/azure/stream', async (req, res) => {
     /** @type {Partial<ProxyStreamRequest>} */
     const proxyBody = req.body || {};