feat(provider): add martian api

src/globals.ts

@@ -74,6 +74,7 @@ export const LEMONFOX_AI: string = 'lemonfox-ai';
 export const UPSTAGE: string = 'upstage';
 export const LAMBDA: string = 'lambda';
 export const DASHSCOPE: string = 'dashscope';
+export const MARTIAN: string = 'martian';
 
 export const VALID_PROVIDERS = [
   ANTHROPIC,
@@ -121,6 +122,7 @@ export const VALID_PROVIDERS = [
   UPSTAGE,
   LAMBDA,
   DASHSCOPE,
+  MARTIAN,
 ];
 
 export const CONTENT_TYPES = {

src/handlers/handlerUtils.ts

@@ -14,6 +14,7 @@ import {
   CONTENT_TYPES,
   HUGGING_FACE,
   STABILITY_AI,
+  MARTIAN,
 } from '../globals';
 import Providers from '../providers';
 import { ProviderAPIConfig, endpointStrings } from '../providers/types';
@@ -1053,6 +1054,10 @@ export function constructConfigFromRequestHeaders(
     openaiProject: requestHeaders[`x-${POWERED_BY}-openai-project`],
   };
 
+  const martianConfig = {
+    openaiOrganization: requestHeaders[`x-${POWERED_BY}-martian-organization`],
+    openaiProject: requestHeaders[`x-${POWERED_BY}-martian-project`],
+  };
   const huggingfaceConfig = {
     huggingfaceBaseUrl: requestHeaders[`x-${POWERED_BY}-huggingface-base-url`],
   };
@@ -1149,6 +1154,12 @@ export function constructConfigFromRequestHeaders(
           ...stabilityAiConfig,
         };
       }
+      if (parsedConfigJson.provider === MARTIAN) {
+        parsedConfigJson = {
+          ...parsedConfigJson,
+          ...openAiConfig,
+        };
+      }
     }
     return convertKeysToCamelCase(parsedConfigJson, [
       'override_params',
@@ -1173,6 +1184,8 @@ export function constructConfigFromRequestHeaders(
     ...(requestHeaders[`x-${POWERED_BY}-provider`] === AZURE_AI_INFERENCE &&
       azureAiInferenceConfig),
     ...(requestHeaders[`x-${POWERED_BY}-provider`] === OPEN_AI && openAiConfig),
+    ...(requestHeaders[`x-${POWERED_BY}-provider`] === MARTIAN &&
+      martianConfig),
     ...(requestHeaders[`x-${POWERED_BY}-provider`] === ANTHROPIC &&
       anthropicConfig),
     ...(requestHeaders[`x-${POWERED_BY}-provider`] === HUGGING_FACE &&

src/providers/index.ts

@@ -47,6 +47,7 @@ import { UpstageConfig } from './upstage';
 import { LAMBDA } from '../globals';
 import { LambdaProviderConfig } from './lambda';
 import { DashScopeConfig } from './dashscope';
+import { MartianConfig } from './martian';
 
 const Providers: { [key: string]: ProviderConfigs } = {
   openai: OpenAIConfig,
@@ -94,6 +95,7 @@ const Providers: { [key: string]: ProviderConfigs } = {
   upstage: UpstageConfig,
   [LAMBDA]: LambdaProviderConfig,
   dashscope: DashScopeConfig,
+  martian: MartianConfig,
 };
 
 export default Providers;

src/providers/martian/api.ts

@@ -0,0 +1,23 @@
+import { ProviderAPIConfig } from '../types';
+
+const MartianAPIConfig: ProviderAPIConfig = {
+  getBaseURL: ({ providerOptions }) => {
+    return (
+      providerOptions.martianBaseUrl || 'https://withmartian.com/api/openai/v1'
+    );
+  },
+  headers: ({ providerOptions }) => ({
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${providerOptions.apiKey}`,
+  }),
+  getEndpoint: ({ fn }) => {
+    switch (fn) {
+      case 'chatComplete':
+        return '/chat/completions';
+      default:
+        return '';
+    }
+  },
+};
+
+export default MartianAPIConfig;

src/providers/martian/chatComplete.ts

@@ -0,0 +1,230 @@
+import { MARTIAN, ANTHROPIC } from '../../globals';
+import {
+  ChatCompletionResponse,
+  ErrorResponse,
+  ProviderConfig,
+} from '../../types';
+import { MartianErrorResponseTransform } from './utils';
+
+export const MartianChatCompleteConfig: ProviderConfig = {
+  model: {
+    param: 'model',
+    required: true,
+    default: 'router',
+  },
+  messages: {
+    param: 'messages',
+    required: true,
+  },
+  max_tokens: {
+    param: 'max_tokens',
+    default: 100,
+    min: 0,
+  },
+  temperature: {
+    param: 'temperature',
+    default: 1,
+    min: 0,
+    max: 2,
+  },
+  top_p: {
+    param: 'top_p',
+    default: 1,
+    min: 0,
+    max: 1,
+  },
+  n: {
+    param: 'n',
+    default: 1,
+  },
+  stream: {
+    param: 'stream',
+    default: false,
+  },
+  stop: {
+    param: 'stop',
+  },
+  max_cost: {
+    param: 'max_cost',
+  },
+  max_cost_per_million_tokens: {
+    param: 'max_cost_per_million_tokens',
+  },
+  models: {
+    param: 'models',
+  },
+  willingness_to_pay: {
+    param: 'willingness_to_pay',
+  },
+  extra: {
+    param: 'extra',
+  },
+};
+
+export interface MartianChatCompleteResponse extends ChatCompletionResponse {
+  system_fingerprint: string;
+}
+
+export const MartianChatCompleteResponseTransform: (
+  response: MartianChatCompleteResponse | ErrorResponse,
+  responseStatus: number
+) => ChatCompletionResponse | ErrorResponse = (response, responseStatus) => {
+  if (responseStatus !== 200 && 'error' in response) {
+    return MartianErrorResponseTransform(response, MARTIAN);
+  }
+
+  return response;
+};
+
+/**
+ * Transforms an Martian-format chat completions JSON response into an array of formatted Martian compatible text/event-stream chunks.
+ *
+ * @param {Object} response - The MartianChatCompleteResponse object.
+ * @param {string} provider - The provider string.
+ * @returns {Array<string>} - An array of formatted stream chunks.
+ */
+export const MartianChatCompleteJSONToStreamResponseTransform: (
+  response: MartianChatCompleteResponse,
+  provider: string
+) => Array<string> = (response, provider) => {
+  const streamChunkArray: Array<string> = [];
+  const { id, model, system_fingerprint, choices } = response;
+
+  const {
+    prompt_tokens,
+    completion_tokens,
+    cache_read_input_tokens,
+    cache_creation_input_tokens,
+  } = response.usage || {};
+
+  let total_tokens;
+  if (prompt_tokens && completion_tokens)
+    total_tokens = prompt_tokens + completion_tokens;
+
+  const shouldSendCacheUsage =
+    provider === ANTHROPIC &&
+    (Number.isInteger(cache_read_input_tokens) ||
+      Number.isInteger(cache_creation_input_tokens));
+
+  const streamChunkTemplate: Record<string, any> = {
+    id,
+    object: 'chat.completion.chunk',
+    created: Date.now(),
+    model: model || '',
+    system_fingerprint: system_fingerprint || null,
+    provider,
+    usage: {
+      ...(completion_tokens && { completion_tokens }),
+      ...(prompt_tokens && { prompt_tokens }),
+      ...(total_tokens && { total_tokens }),
+      ...(shouldSendCacheUsage && {
+        cache_read_input_tokens,
+        cache_creation_input_tokens,
+      }),
+    },
+  };
+
+  for (const [index, choice] of choices.entries()) {
+    if (
+      choice.message &&
+      choice.message.tool_calls &&
+      choice.message.tool_calls.length
+    ) {
+      for (const [
+        toolCallIndex,
+        toolCall,
+      ] of choice.message.tool_calls.entries()) {
+        const toolCallNameChunk = {
+          index: toolCallIndex,
+          id: toolCall.id,
+          type: 'function',
+          function: {
+            name: toolCall.function.name,
+            arguments: '',
+          },
+        };
+
+        const toolCallArgumentChunk = {
+          index: toolCallIndex,
+          function: {
+            arguments: toolCall.function.arguments,
+          },
+        };
+
+        streamChunkArray.push(
+          `data: ${JSON.stringify({
+            ...streamChunkTemplate,
+            choices: [
+              {
+                index: index,
+                delta: {
+                  role: 'assistant',
+                  content: null,
+                  tool_calls: [toolCallNameChunk],
+                },
+              },
+            ],
+          })}\n\n`
+        );
+
+        streamChunkArray.push(
+          `data: ${JSON.stringify({
+            ...streamChunkTemplate,
+            choices: [
+              {
+                index: index,
+                delta: {
+                  role: 'assistant',
+                  tool_calls: [toolCallArgumentChunk],
+                },
+              },
+            ],
+          })}\n\n`
+        );
+      }
+    }
+
+    if (
+      choice.message &&
+      choice.message.content &&
+      typeof choice.message.content === 'string'
+    ) {
+      const inidividualWords: Array<string> = [];
+      for (let i = 0; i < choice.message.content.length; i += 4) {
+        inidividualWords.push(choice.message.content.slice(i, i + 4));
+      }
+      inidividualWords.forEach((word: string) => {
+        streamChunkArray.push(
+          `data: ${JSON.stringify({
+            ...streamChunkTemplate,
+            choices: [
+              {
+                index: index,
+                delta: {
+                  role: 'assistant',
+                  content: word,
+                },
+              },
+            ],
+          })}\n\n`
+        );
+      });
+    }
+
+    streamChunkArray.push(
+      `data: ${JSON.stringify({
+        ...streamChunkTemplate,
+        choices: [
+          {
+            index: index,
+            delta: {},
+            finish_reason: choice.finish_reason,
+          },
+        ],
+      })}\n\n`
+    );
+  }
+
+  streamChunkArray.push(`data: [DONE]\n\n`);
+  return streamChunkArray;
+};

src/providers/martian/index.ts

@@ -0,0 +1,18 @@
+import { ProviderConfigs } from '../types';
+import MartianAPIConfig from './api';
+import {
+  MartianChatCompleteConfig,
+  MartianChatCompleteResponseTransform,
+} from './chatComplete';
+
+const MartianConfig: ProviderConfigs = {
+  api: MartianAPIConfig,
+  chatComplete: MartianChatCompleteConfig,
+  responseTransforms: {
+    chatComplete: MartianChatCompleteResponseTransform,
+  },
+};
+
+// Explicit export for MartianConfig
+export { MartianConfig };
+export default MartianConfig;

src/providers/martian/utils.ts

@@ -0,0 +1,14 @@
+import { ErrorResponse } from '../types';
+import { generateErrorResponse } from '../utils';
+
+export const MartianErrorResponseTransform: (
+  response: ErrorResponse,
+  provider: string
+) => ErrorResponse = (response, provider) => {
+  return generateErrorResponse(
+    {
+      ...response.error,
+    },
+    provider
+  );
+};