init

workers/site/sdk/models/cerebras.ts

@@ -0,0 +1,106 @@
+import { OpenAI } from "openai";
+import {
+  _NotCustomized,
+  ISimpleType,
+  ModelPropertiesDeclarationToProperties,
+  ModelSnapshotType2,
+  UnionStringArray,
+} from "mobx-state-tree";
+import ChatSdk from "../chat-sdk";
+
+export class CerebrasSdk {
+  static async handleCerebrasStream(
+    param: {
+      openai: OpenAI;
+      systemPrompt: any;
+      disableWebhookGeneration: boolean;
+      preprocessedContext: ModelSnapshotType2<
+        ModelPropertiesDeclarationToProperties<{
+          role: ISimpleType<UnionStringArray<string[]>>;
+          content: ISimpleType<unknown>;
+        }>,
+        _NotCustomized
+      >;
+      attachments: any;
+      maxTokens: unknown | number | undefined;
+      messages: any;
+      model: string;
+      env: Env;
+      tools: any;
+    },
+    dataCallback: (data) => void,
+  ) {
+    const {
+      preprocessedContext,
+      messages,
+      env,
+      maxTokens,
+      tools,
+      systemPrompt,
+      model,
+      attachments,
+    } = param;
+
+    const assistantPrompt = ChatSdk.buildAssistantPrompt({
+      maxTokens: maxTokens,
+      tools: tools,
+    });
+
+    const safeMessages = ChatSdk.buildMessageChain(messages, {
+      systemPrompt: systemPrompt,
+      model,
+      assistantPrompt,
+      toolResults: preprocessedContext,
+      attachments: attachments,
+    });
+
+    const openai = new OpenAI({
+      baseURL: "https://api.cerebras.ai/v1",
+      apiKey: param.env.CEREBRAS_API_KEY,
+    });
+
+    return CerebrasSdk.streamCerebrasResponse(
+      safeMessages,
+      {
+        model: param.model,
+        maxTokens: param.maxTokens,
+        openai: openai,
+      },
+      dataCallback,
+    );
+  }
+  private static async streamCerebrasResponse(
+    messages: any[],
+    opts: {
+      model: string;
+      maxTokens: number | unknown | undefined;
+      openai: OpenAI;
+    },
+    dataCallback: (data: any) => void,
+  ) {
+    const tuningParams: Record<string, any> = {};
+
+    const llamaTuningParams = {
+      temperature: 0.86,
+      top_p: 0.98,
+      presence_penalty: 0.1,
+      frequency_penalty: 0.3,
+      max_tokens: opts.maxTokens,
+    };
+
+    const getLlamaTuningParams = () => {
+      return llamaTuningParams;
+    };
+
+    const groqStream = await opts.openai.chat.completions.create({
+      model: opts.model,
+      messages: messages,
+
+      stream: true,
+    });
+
+    for await (const chunk of groqStream) {
+      dataCallback({ type: "chat", data: chunk });
+    }
+  }
+}

workers/site/sdk/models/claude.ts

@@ -0,0 +1,107 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { OpenAI } from "openai";
+import {
+  _NotCustomized,
+  ISimpleType,
+  ModelPropertiesDeclarationToProperties,
+  ModelSnapshotType2,
+  UnionStringArray,
+} from "mobx-state-tree";
+import ChatSdk from "../chat-sdk";
+
+export class ClaudeChatSdk {
+  private static async streamClaudeResponse(
+    messages: any[],
+    param: {
+      model: string;
+      maxTokens: number | unknown | undefined;
+      anthropic: Anthropic;
+    },
+    dataCallback: (data: any) => void,
+  ) {
+    const claudeStream = await param.anthropic.messages.create({
+      stream: true,
+      model: param.model,
+      max_tokens: param.maxTokens,
+      messages: messages,
+    });
+
+    for await (const chunk of claudeStream) {
+      if (chunk.type === "message_stop") {
+        dataCallback({
+          type: "chat",
+          data: {
+            choices: [
+              {
+                delta: { content: "" },
+                logprobs: null,
+                finish_reason: "stop",
+              },
+            ],
+          },
+        });
+        break;
+      }
+      dataCallback({ type: "chat", data: chunk });
+    }
+  }
+  static async handleClaudeStream(
+    param: {
+      openai: OpenAI;
+      systemPrompt: any;
+      disableWebhookGeneration: boolean;
+      preprocessedContext: ModelSnapshotType2<
+        ModelPropertiesDeclarationToProperties<{
+          role: ISimpleType<UnionStringArray<string[]>>;
+          content: ISimpleType<unknown>;
+        }>,
+        _NotCustomized
+      >;
+      attachments: any;
+      maxTokens: unknown | number | undefined;
+      messages: any;
+      model: string;
+      env: Env;
+      tools: any;
+    },
+    dataCallback: (data) => void,
+  ) {
+    const {
+      preprocessedContext,
+      messages,
+      env,
+      maxTokens,
+      tools,
+      systemPrompt,
+      model,
+      attachments,
+    } = param;
+
+    const assistantPrompt = ChatSdk.buildAssistantPrompt({
+      maxTokens: maxTokens,
+      tools: tools,
+    });
+
+    const safeMessages = ChatSdk.buildMessageChain(messages, {
+      systemPrompt: systemPrompt,
+      model,
+      assistantPrompt,
+      toolResults: preprocessedContext,
+      attachments: attachments,
+    });
+
+    const anthropic = new Anthropic({
+      apiKey: env.ANTHROPIC_API_KEY,
+    });
+
+    return ClaudeChatSdk.streamClaudeResponse(
+      safeMessages,
+      {
+        model: param.model,
+        maxTokens: param.maxTokens,
+        anthropic: anthropic,
+      },
+      dataCallback,
+    );
+  }
+}

workers/site/sdk/models/cloudflareAi.ts

@@ -0,0 +1,181 @@
+import { OpenAI } from "openai";
+import {
+  _NotCustomized,
+  ISimpleType,
+  ModelPropertiesDeclarationToProperties,
+  ModelSnapshotType2,
+  UnionStringArray,
+} from "mobx-state-tree";
+import ChatSdk from "../chat-sdk";
+
+export class CloudflareAISdk {
+  static async handleCloudflareAIStream(
+    param: {
+      openai: OpenAI;
+      systemPrompt: any;
+      disableWebhookGeneration: boolean;
+      preprocessedContext: ModelSnapshotType2<
+        ModelPropertiesDeclarationToProperties<{
+          role: ISimpleType<UnionStringArray<string[]>>;
+          content: ISimpleType<unknown>;
+        }>,
+        _NotCustomized
+      >;
+      attachments: any;
+      maxTokens: unknown | number | undefined;
+      messages: any;
+      model: string;
+      env: Env;
+      tools: any;
+    },
+    dataCallback: (data) => void,
+  ) {
+    const {
+      preprocessedContext,
+      messages,
+      env,
+      maxTokens,
+      tools,
+      systemPrompt,
+      model,
+      attachments,
+    } = param;
+
+    const assistantPrompt = ChatSdk.buildAssistantPrompt({
+      maxTokens: maxTokens,
+      tools: tools,
+    });
+    const safeMessages = ChatSdk.buildMessageChain(messages, {
+      systemPrompt: systemPrompt,
+      model,
+      assistantPrompt,
+      toolResults: preprocessedContext,
+      attachments: attachments,
+    });
+
+    const cfAiURL = `https://api.cloudflare.com/client/v4/accounts/${env.CLOUDFLARE_ACCOUNT_ID}/ai/v1`;
+
+    console.log({ cfAiURL });
+    const openai = new OpenAI({
+      apiKey: env.CLOUDFLARE_API_KEY,
+      baseURL: cfAiURL,
+    });
+
+    return CloudflareAISdk.streamCloudflareAIResponse(
+      safeMessages,
+      {
+        model: param.model,
+        maxTokens: param.maxTokens,
+        openai: openai,
+      },
+      dataCallback,
+    );
+  }
+  private static async streamCloudflareAIResponse(
+    messages: any[],
+    opts: {
+      model: string;
+      maxTokens: number | unknown | undefined;
+      openai: OpenAI;
+    },
+    dataCallback: (data: any) => void,
+  ) {
+    const tuningParams: Record<string, any> = {};
+
+    const llamaTuningParams = {
+      temperature: 0.86,
+      top_p: 0.98,
+      presence_penalty: 0.1,
+      frequency_penalty: 0.3,
+      max_tokens: opts.maxTokens,
+    };
+
+    const getLlamaTuningParams = () => {
+      return llamaTuningParams;
+    };
+
+    let modelPrefix = `@cf/meta`;
+
+    if (opts.model.toLowerCase().includes("llama")) {
+      modelPrefix = `@cf/meta`;
+    }
+
+    if (opts.model.toLowerCase().includes("hermes-2-pro-mistral-7b")) {
+      modelPrefix = `@hf/nousresearch`;
+    }
+
+    if (opts.model.toLowerCase().includes("mistral-7b-instruct")) {
+      modelPrefix = `@hf/mistral`;
+    }
+
+    if (opts.model.toLowerCase().includes("gemma")) {
+      modelPrefix = `@cf/google`;
+    }
+
+    if (opts.model.toLowerCase().includes("deepseek")) {
+      modelPrefix = `@cf/deepseek-ai`;
+    }
+
+    if (opts.model.toLowerCase().includes("openchat-3.5-0106")) {
+      modelPrefix = `@cf/openchat`;
+    }
+
+    const isNueralChat = opts.model
+      .toLowerCase()
+      .includes("neural-chat-7b-v3-1-awq");
+    if (
+      isNueralChat ||
+      opts.model.toLowerCase().includes("openhermes-2.5-mistral-7b-awq") ||
+      opts.model.toLowerCase().includes("zephyr-7b-beta-awq") ||
+      opts.model.toLowerCase().includes("deepseek-coder-6.7b-instruct-awq")
+    ) {
+      modelPrefix = `@hf/thebloke`;
+    }
+
+    const generationParams: Record<string, any> = {
+      model: `${modelPrefix}/${opts.model}`,
+      messages: messages,
+      stream: true,
+    };
+
+    if (modelPrefix === "@cf/meta") {
+      generationParams["max_tokens"] = 4096;
+    }
+
+    if (modelPrefix === "@hf/mistral") {
+      generationParams["max_tokens"] = 4096;
+    }
+
+    if (opts.model.toLowerCase().includes("hermes-2-pro-mistral-7b")) {
+      generationParams["max_tokens"] = 1000;
+    }
+
+    if (opts.model.toLowerCase().includes("openhermes-2.5-mistral-7b-awq")) {
+      generationParams["max_tokens"] = 1000;
+    }
+
+    if (opts.model.toLowerCase().includes("deepseek-coder-6.7b-instruct-awq")) {
+      generationParams["max_tokens"] = 590;
+    }
+
+    if (opts.model.toLowerCase().includes("deepseek-math-7b-instruct")) {
+      generationParams["max_tokens"] = 512;
+    }
+
+    if (opts.model.toLowerCase().includes("neural-chat-7b-v3-1-awq")) {
+      generationParams["max_tokens"] = 590;
+    }
+
+    if (opts.model.toLowerCase().includes("openchat-3.5-0106")) {
+      generationParams["max_tokens"] = 2000;
+    }
+
+    const cloudflareAiStream = await opts.openai.chat.completions.create({
+      ...generationParams,
+    });
+
+    for await (const chunk of cloudflareAiStream) {
+      dataCallback({ type: "chat", data: chunk });
+    }
+  }
+}

workers/site/sdk/models/fireworks.ts

@@ -0,0 +1,100 @@
+import { OpenAI } from "openai";
+import {
+  _NotCustomized,
+  castToSnapshot,
+  getSnapshot,
+  ISimpleType,
+  ModelPropertiesDeclarationToProperties,
+  ModelSnapshotType2,
+  UnionStringArray,
+} from "mobx-state-tree";
+import Message from "../../models/Message";
+import { MarkdownSdk } from "../markdown-sdk";
+import ChatSdk from "../chat-sdk";
+
+export class FireworksAiChatSdk {
+  private static async streamFireworksResponse(
+    messages: any[],
+    opts: {
+      model: string;
+      maxTokens: number | unknown | undefined;
+      openai: OpenAI;
+    },
+    dataCallback: (data: any) => void,
+  ) {
+    let modelPrefix = "accounts/fireworks/models/";
+    if (opts.model.toLowerCase().includes("yi-")) {
+      modelPrefix = "accounts/yi-01-ai/models/";
+    }
+
+    const fireworksStream = await opts.openai.chat.completions.create({
+      model: `${modelPrefix}${opts.model}`,
+      messages: messages,
+      stream: true,
+    });
+
+    for await (const chunk of fireworksStream) {
+      dataCallback({ type: "chat", data: chunk });
+    }
+  }
+
+  static async handleFireworksStream(
+    param: {
+      openai: OpenAI;
+      systemPrompt: any;
+      disableWebhookGeneration: boolean;
+      preprocessedContext: ModelSnapshotType2<
+        ModelPropertiesDeclarationToProperties<{
+          role: ISimpleType<UnionStringArray<string[]>>;
+          content: ISimpleType<unknown>;
+        }>,
+        _NotCustomized
+      >;
+      attachments: any;
+      maxTokens: number;
+      messages: any;
+      model: any;
+      env: Env;
+      tools: any;
+    },
+    dataCallback: (data) => void,
+  ) {
+    const {
+      preprocessedContext,
+      messages,
+      env,
+      maxTokens,
+      tools,
+      systemPrompt,
+      model,
+      attachments,
+    } = param;
+
+    const assistantPrompt = ChatSdk.buildAssistantPrompt({
+      maxTokens: maxTokens,
+      tools: tools,
+    });
+
+    const safeMessages = ChatSdk.buildMessageChain(messages, {
+      systemPrompt: systemPrompt,
+      model,
+      assistantPrompt,
+      toolResults: preprocessedContext,
+      attachments: attachments,
+    });
+
+    const fireworksOpenAIClient = new OpenAI({
+      apiKey: param.env.FIREWORKS_API_KEY,
+      baseURL: "https://api.fireworks.ai/inference/v1",
+    });
+    return FireworksAiChatSdk.streamFireworksResponse(
+      safeMessages,
+      {
+        model: param.model,
+        maxTokens: param.maxTokens,
+        openai: fireworksOpenAIClient,
+      },
+      dataCallback,
+    );
+  }
+}

workers/site/sdk/models/google.ts

@@ -0,0 +1,101 @@
+import { OpenAI } from "openai";
+import ChatSdk from "../chat-sdk";
+import { StreamParams } from "../../services/ChatService";
+
+export class GoogleChatSdk {
+  static async handleGoogleStream(
+    param: StreamParams,
+    dataCallback: (data) => void,
+  ) {
+    const {
+      preprocessedContext,
+      messages,
+      env,
+      maxTokens,
+      tools,
+      systemPrompt,
+      model,
+      attachments,
+    } = param;
+
+    const assistantPrompt = ChatSdk.buildAssistantPrompt({
+      maxTokens: maxTokens,
+      tools: tools,
+    });
+
+    const safeMessages = ChatSdk.buildMessageChain(messages, {
+      systemPrompt: systemPrompt,
+      model,
+      assistantPrompt,
+      toolResults: preprocessedContext,
+      attachments: attachments,
+    });
+
+    const openai = new OpenAI({
+      baseURL: "https://generativelanguage.googleapis.com/v1beta/openai",
+      apiKey: param.env.GEMINI_API_KEY,
+    });
+
+    return GoogleChatSdk.streamGoogleResponse(
+      safeMessages,
+      {
+        model: param.model,
+        maxTokens: param.maxTokens,
+        openai: openai,
+      },
+      dataCallback,
+    );
+  }
+  private static async streamGoogleResponse(
+    messages: any[],
+    opts: {
+      model: string;
+      maxTokens: number | unknown | undefined;
+      openai: OpenAI;
+    },
+    dataCallback: (data: any) => void,
+  ) {
+    const chatReq = JSON.stringify({
+      model: opts.model,
+      messages: messages,
+      stream: true,
+    });
+
+    const googleStream = await opts.openai.chat.completions.create(
+      JSON.parse(chatReq),
+    );
+
+    for await (const chunk of googleStream) {
+      console.log(JSON.stringify(chunk));
+
+      if (chunk.choices?.[0]?.finishReason === "stop") {
+        dataCallback({
+          type: "chat",
+          data: {
+            choices: [
+              {
+                delta: { content: chunk.choices[0].delta.content || "" },
+                finish_reason: "stop",
+                index: chunk.choices[0].index,
+              },
+            ],
+          },
+        });
+        break;
+      } else {
+        dataCallback({
+          type: "chat",
+          data: {
+            choices: [
+              {
+                delta: { content: chunk.choices?.[0]?.delta?.content || "" },
+                finish_reason: null,
+                index: chunk.choices?.[0]?.index || 0,
+              },
+            ],
+          },
+        });
+      }
+    }
+  }
+}

workers/site/sdk/models/groq.ts

@@ -0,0 +1,106 @@
+import { OpenAI } from "openai";
+import {
+  _NotCustomized,
+  ISimpleType,
+  ModelPropertiesDeclarationToProperties,
+  ModelSnapshotType2,
+  UnionStringArray,
+} from "mobx-state-tree";
+import ChatSdk from "../chat-sdk";
+
+export class GroqChatSdk {
+  static async handleGroqStream(
+    param: {
+      openai: OpenAI;
+      systemPrompt: any;
+      disableWebhookGeneration: boolean;
+      preprocessedContext: ModelSnapshotType2<
+        ModelPropertiesDeclarationToProperties<{
+          role: ISimpleType<UnionStringArray<string[]>>;
+          content: ISimpleType<unknown>;
+        }>,
+        _NotCustomized
+      >;
+      attachments: any;
+      maxTokens: unknown | number | undefined;
+      messages: any;
+      model: string;
+      env: Env;
+      tools: any;
+    },
+    dataCallback: (data) => void,
+  ) {
+    const {
+      preprocessedContext,
+      messages,
+      env,
+      maxTokens,
+      tools,
+      systemPrompt,
+      model,
+      attachments,
+    } = param;
+
+    const assistantPrompt = ChatSdk.buildAssistantPrompt({
+      maxTokens: maxTokens,
+      tools: tools,
+    });
+    const safeMessages = ChatSdk.buildMessageChain(messages, {
+      systemPrompt: systemPrompt,
+      model,
+      assistantPrompt,
+      toolResults: preprocessedContext,
+      attachments: attachments,
+    });
+
+    const openai = new OpenAI({
+      baseURL: "https://api.groq.com/openai/v1",
+      apiKey: param.env.GROQ_API_KEY,
+    });
+
+    return GroqChatSdk.streamGroqResponse(
+      safeMessages,
+      {
+        model: param.model,
+        maxTokens: param.maxTokens,
+        openai: openai,
+      },
+      dataCallback,
+    );
+  }
+  private static async streamGroqResponse(
+    messages: any[],
+    opts: {
+      model: string;
+      maxTokens: number | unknown | undefined;
+      openai: OpenAI;
+    },
+    dataCallback: (data: any) => void,
+  ) {
+    const tuningParams: Record<string, any> = {};
+
+    const llamaTuningParams = {
+      temperature: 0.86,
+      top_p: 0.98,
+      presence_penalty: 0.1,
+      frequency_penalty: 0.3,
+      max_tokens: opts.maxTokens,
+    };
+
+    const getLlamaTuningParams = () => {
+      return llamaTuningParams;
+    };
+
+    const groqStream = await opts.openai.chat.completions.create({
+      model: opts.model,
+      messages: messages,
+      frequency_penalty: 2,
+      stream: true,
+      temperature: 0.78,
+    });
+
+    for await (const chunk of groqStream) {
+      dataCallback({ type: "chat", data: chunk });
+    }
+  }
+}

workers/site/sdk/models/openai.ts

@@ -0,0 +1,102 @@
+import { OpenAI } from "openai";
+import ChatSdk from "../chat-sdk";
+
+export class OpenAiChatSdk {
+  static async handleOpenAiStream(
+    ctx: {
+      openai: OpenAI;
+      systemPrompt: any;
+      preprocessedContext: any;
+      attachments: any;
+      maxTokens: unknown | number | undefined;
+      messages: any;
+      disableWebhookGeneration: boolean;
+      model: any;
+      tools: any;
+    },
+    dataCallback: (data: any) => any,
+  ) {
+    const {
+      openai,
+      systemPrompt,
+      maxTokens,
+      tools,
+      messages,
+      attachments,
+      model,
+      preprocessedContext,
+    } = ctx;
+
+    if (!messages?.length) {
+      return new Response("No messages provided", { status: 400 });
+    }
+
+    const assistantPrompt = ChatSdk.buildAssistantPrompt({
+      maxTokens: maxTokens,
+      tools: tools,
+    });
+    const safeMessages = ChatSdk.buildMessageChain(messages, {
+      systemPrompt: systemPrompt,
+      model,
+      assistantPrompt,
+      toolResults: preprocessedContext,
+      attachments: attachments,
+    });
+
+    return OpenAiChatSdk.streamOpenAiResponse(
+      safeMessages,
+      {
+        model,
+        maxTokens: maxTokens as number,
+        openai: openai,
+      },
+      dataCallback,
+    );
+  }
+
+  private static async streamOpenAiResponse(
+    messages: any[],
+    opts: {
+      model: string;
+      maxTokens: number | undefined;
+      openai: OpenAI;
+    },
+    dataCallback: (data: any) => any,
+  ) {
+    const isO1 = () => {
+      if (opts.model === "o1-preview" || opts.model === "o1-mini") {
+        return true;
+      }
+    };
+
+    const tuningParams: Record<string, any> = {};
+
+    const gpt4oTuningParams = {
+      temperature: 0.86,
+      top_p: 0.98,
+      presence_penalty: 0.1,
+      frequency_penalty: 0.3,
+      max_tokens: opts.maxTokens,
+    };
+
+    const getTuningParams = () => {
+      if (isO1()) {
+        tuningParams["temperature"] = 1;
+        tuningParams["max_completion_tokens"] = opts.maxTokens + 10000;
+        return tuningParams;
+      }
+      return gpt4oTuningParams;
+    };
+
+    const openAIStream = await opts.openai.chat.completions.create({
+      model: opts.model,
+      messages: messages,
+      stream: true,
+      ...getTuningParams(),
+    });
+
+    for await (const chunk of openAIStream) {
+      dataCallback({ type: "chat", data: chunk });
+    }
+  }
+}

workers/site/sdk/models/xai.ts

@@ -0,0 +1,120 @@
+import { OpenAI } from "openai";
+import ChatSdk from "../chat-sdk";
+
+export class XaiChatSdk {
+  static async handleXaiStream(
+    ctx: {
+      openai: OpenAI;
+      systemPrompt: any;
+      preprocessedContext: any;
+      attachments: any;
+      maxTokens: unknown | number | undefined;
+      messages: any;
+      disableWebhookGeneration: boolean;
+      model: any;
+      env: Env;
+      tools: any;
+    },
+    dataCallback: (data: any) => any,
+  ) {
+    const {
+      openai,
+      systemPrompt,
+      maxTokens,
+      tools,
+      messages,
+      attachments,
+      env,
+      model,
+      preprocessedContext,
+    } = ctx;
+
+    if (!messages?.length) {
+      return new Response("No messages provided", { status: 400 });
+    }
+
+    const getMaxTokens = async (mt) => {
+      if (mt) {
+        return await ChatSdk.calculateMaxTokens(
+          JSON.parse(JSON.stringify(messages)),
+          {
+            env,
+            maxTokens: mt,
+          },
+        );
+      } else {
+        return undefined;
+      }
+    };
+
+    const assistantPrompt = ChatSdk.buildAssistantPrompt({
+      maxTokens: maxTokens,
+      tools: tools,
+    });
+
+    const safeMessages = ChatSdk.buildMessageChain(messages, {
+      systemPrompt: systemPrompt,
+      model,
+      assistantPrompt,
+      toolResults: preprocessedContext,
+      attachments: attachments,
+    });
+
+    const xAiClient = new OpenAI({
+      baseURL: "https://api.x.ai/v1",
+      apiKey: env.XAI_API_KEY,
+    });
+
+    return XaiChatSdk.streamOpenAiResponse(
+      safeMessages,
+      {
+        model,
+        maxTokens: maxTokens as number,
+        openai: xAiClient,
+      },
+      dataCallback,
+    );
+  }
+
+  private static async streamOpenAiResponse(
+    messages: any[],
+    opts: {
+      model: string;
+      maxTokens: number | undefined;
+      openai: OpenAI;
+    },
+    dataCallback: (data: any) => any,
+  ) {
+    const isO1 = () => {
+      if (opts.model === "o1-preview" || opts.model === "o1-mini") {
+        return true;
+      }
+    };
+
+    const tuningParams: Record<string, any> = {};
+
+    const gpt4oTuningParams = {
+      temperature: 0.75,
+    };
+
+    const getTuningParams = () => {
+      if (isO1()) {
+        tuningParams["temperature"] = 1;
+        tuningParams["max_completion_tokens"] = opts.maxTokens + 10000;
+        return tuningParams;
+      }
+      return gpt4oTuningParams;
+    };
+
+    const xAIStream = await opts.openai.chat.completions.create({
+      model: opts.model,
+      messages: messages,
+      stream: true,
+      ...getTuningParams(),
+    });
+
+    for await (const chunk of xAIStream) {
+      dataCallback({ type: "chat", data: chunk });
+    }
+  }
+}