Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

3.0 KB
Raw Blame
import {
  buildOpenAICodexOAuthFetch,
  createCodexMiddleware,
} from "@mastra/code-sdk/providers/openai-codex";
import type { AuthStorage } from "@mastra/code-sdk/auth/storage";
import { createOpenAI } from "@ai-sdk/openai";
import type { ApiKeyCredential } from "../subscription-auth/types.ts";
import { subscriptionRequestUrl } from "../subscription-auth/runtime.ts";

type OpenAIFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;

const OPENAI_BASE_URL = "https://api.openai.com/v1";

export function buildAkeruOpenAIFetch(
  getCredential: () => ApiKeyCredential | undefined,
  request: OpenAIFetch = globalThis.fetch,
): OpenAIFetch {
  return async (input, init) => {
    const credential = getCredential();

    if (!credential)
      throw new Error("The OpenAI API key is no longer connected. Start a new turn.");
    const headers = new Headers(input instanceof Request ? input.headers : undefined);
    new Headers(init?.headers).forEach((value, key) => headers.set(key, value));
    headers.set("Authorization", `Bearer ${credential.access}`);
    headers.delete("chatgpt-account-id");

    return request(subscriptionRequestUrl(input, OPENAI_BASE_URL, credential.baseUrl), {
      ...init,
      headers,
      redirect: "error",
    });
  };
}

export function akeruOpenAIProvider(
  modelId: string,
  getCredential: () => ApiKeyCredential | undefined,
) {
  return createOpenAI({
    apiKey: "akeru-api-key",
    baseURL: OPENAI_BASE_URL,
    // SAFETY: The SDK accepts this Fetch API implementation; Bun ambient types add preconnect, which the SDK never calls.
    fetch: buildAkeruOpenAIFetch(getCredential) as NonNullable<
      NonNullable<Parameters<typeof createOpenAI>[0]>["fetch"]
    >,
  }).responses(modelId);
}

/** Preserves the SDK's OAuth default while accepting raw native efforts without coercion. */
export function akeruCodexOAuthProvider(modelId: string, authStorage: AuthStorage) {
  const model = createOpenAI({
    apiKey: "oauth-placeholder",
    fetch: buildOpenAICodexOAuthFetch({ authStorage }),
  }).responses(modelId);

  const middleware = createCodexMiddleware();
  const defaultMiddleware = createCodexMiddleware("medium");

  const transform = (params: Parameters<typeof model.doGenerate>[0], type: "generate" | "stream") =>
    (params.providerOptions?.openai?.reasoningEffort === undefined
      ? defaultMiddleware
      : middleware
    ).transformParams?.({ type, params, model });

  return {
    specificationVersion: model.specificationVersion,
    provider: model.provider,
    modelId: model.modelId,
    supportedUrls: model.supportedUrls,
    async doGenerate(params: Parameters<typeof model.doGenerate>[0]) {
      const transformed = await transform(params, "generate");

      return model.doGenerate(transformed ?? params);
    },
    async doStream(params: Parameters<typeof model.doStream>[0]) {
      const transformed = await transform(params, "stream");

      return model.doStream(transformed ?? params);
    },
  };
}