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.

6.2 KB
Raw Blame
import {
  defaultInstanceIdForDriver,
  type ProviderInstanceEnvironment,
  ProviderDriverKind,
  SUBSCRIPTION_CONNECTION_ENV_KEYS,
  type ServerSettings,
  type ServerSettingsPatch,
  type SubscriptionProviderStatus,
} from "@akeru/contracts";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";

import { mergeProviderInstanceEnvironment } from "../provider/ProviderInstanceEnvironment.ts";
import {
  anthropicApiBaseUrl,
  SubscriptionAuthService,
  type SubscriptionProviderId,
} from "./service.ts";
import type { ApiKeyCredential } from "./types.ts";

export { instanceUsesSavedCredential } from "@akeru/contracts";

const explicitEnvironmentKeys = Symbol("subscriptionInstanceEnvironmentKeys");

type SubscriptionEnvironment = NodeJS.ProcessEnv & {
  readonly [explicitEnvironmentKeys]?: ReadonlySet<string>;
};

const subscriptionProviderDrivers = [
  ["codex", "openai-codex"],
  ["claudeAgent", "anthropic"],
  ["grok", "xai"],
  ["kimi", "kimi-for-coding"],
  ["opencodeGo", "opencode-go"],
] as const;

/**
 * Subscription connections own the enabled state of Akeru's default provider
 * instances. Explicit instances keep their own switch because they may carry
 * separate credentials or isolation settings.
 */
export function subscriptionProviderSettingsPatch(
  settings: ServerSettings,
  statuses: ReadonlyArray<SubscriptionProviderStatus>,
): ServerSettingsPatch | null {
  const connected = new Map(statuses.map((status) => [status.provider, status.connected]));
  const providers: NonNullable<ServerSettingsPatch["providers"]> = {};

  for (const [driver, subscriptionProvider] of subscriptionProviderDrivers) {
    const driverKind = ProviderDriverKind.make(driver);

    if (Object.hasOwn(settings.providerInstances, defaultInstanceIdForDriver(driverKind))) continue;
    const enabled = connected.get(subscriptionProvider) ?? false;

    if (settings.providers[driver].enabled === enabled) continue;
    Object.assign(providers, { [driver]: { enabled } });
  }

  return Object.keys(providers).length > 0 ? { providers } : null;
}

/** The symbol survives environment spreads without becoming a child-process variable. */
export function mergeSubscriptionInstanceEnvironment(
  environment: ProviderInstanceEnvironment | undefined,
  baseEnv: NodeJS.ProcessEnv = process.env,
): SubscriptionEnvironment {
  return {
    ...mergeProviderInstanceEnvironment(environment, baseEnv),
    [explicitEnvironmentKeys]: new Set(environment?.map(({ name }) => name)),
  };
}

/** Drivers call this after they add their own isolation variables to a merged environment. */
export function withExplicitEnvironmentKeys(
  environment: SubscriptionEnvironment,
  keys: Iterable<string>,
): SubscriptionEnvironment {
  const existing = environment[explicitEnvironmentKeys];

  return {
    ...environment,
    [explicitEnvironmentKeys]: new Set([...(existing ?? []), ...keys]),
  };
}

function hasExplicitEnvironmentKey(environment: SubscriptionEnvironment, key: string): boolean {
  const keys = environment[explicitEnvironmentKeys];

  return keys ? keys.has(key) : environment !== process.env && Object.hasOwn(environment, key);
}

const ConfigRecord = Schema.Record(Schema.String, Schema.Unknown);

const decodeConfig = Schema.decodeUnknownSync(Schema.fromJsonString(ConfigRecord));

const decodeRecord = Schema.decodeUnknownSync(ConfigRecord);

/** Read saved API keys when a provider process starts, not when the provider registry starts. */
export const subscriptionRuntimeEnvironment = Effect.fn("subscriptionRuntimeEnvironment")(
  function* (
    secretsDir: string,
    provider: SubscriptionProviderId,
    environment: SubscriptionEnvironment = process.env,
    instanceId?: string,
  ) {
    const connectionKeys = SUBSCRIPTION_CONNECTION_ENV_KEYS[provider] ?? [];

    if (connectionKeys.some((key) => hasExplicitEnvironmentKey(environment, key)))
      return environment;
    const auth = yield* SubscriptionAuthService.forSecretsDir(secretsDir);

    return withApiKeyCredential(
      provider,
      environment,
      auth.getApiKeyCredential(provider, instanceId),
    );
  },
);

function withApiKeyCredential(
  provider: SubscriptionProviderId,
  environment: SubscriptionEnvironment,
  credential: ApiKeyCredential | undefined,
): NodeJS.ProcessEnv {
  if (!credential) return environment;
  const { [explicitEnvironmentKeys]: _explicitKeys, ...env } = environment;

  switch (provider) {
    case "anthropic":
      delete env.CLAUDE_CODE_OAUTH_TOKEN;
      delete env.ANTHROPIC_AUTH_TOKEN;
      env.ANTHROPIC_API_KEY = credential.access;

      if (credential.baseUrl) env.ANTHROPIC_BASE_URL = anthropicApiBaseUrl(credential.baseUrl);
      else delete env.ANTHROPIC_BASE_URL;
      break;
    case "xai":
      env.XAI_API_KEY = credential.access;
      break;
    case "opencode-go": {
      const config = decodeConfig(env.OPENCODE_CONFIG_CONTENT ?? "{}");
      const providers = decodeRecord(config.provider ?? {});
      const providerConfig = decodeRecord(providers["opencode-go"] ?? {});
      const options = decodeRecord(providerConfig.options ?? {});

      if (
        hasExplicitEnvironmentKey(environment, "OPENCODE_CONFIG_CONTENT") &&
        (Object.hasOwn(options, "apiKey") || Object.hasOwn(options, "baseURL"))
      )
        return environment;
      env.OPENCODE_CONFIG_CONTENT = JSON.stringify({
        ...config,
        provider: {
          ...providers,
          "opencode-go": {
            ...providerConfig,
            options: {
              ...options,
              apiKey: credential.access,
              baseURL: credential.baseUrl ?? "https://opencode.ai/zen/go/v1",
            },
          },
        },
      });
      break;
    }
  }

  return env;
}

/** Keep the SDK's endpoint suffix and request body when changing API origins. */
export function subscriptionRequestUrl(
  input: string | URL | Request,
  defaultBaseUrl: string,
  baseUrl: string | undefined,
): string | URL | Request {
  if (!baseUrl) return input;
  const url = input instanceof Request ? input.url : String(input);

  if (!url.startsWith(`${defaultBaseUrl}/`)) {
    throw new Error("The provider request does not match its API base URL.");
  }

  const target = `${baseUrl}${url.slice(defaultBaseUrl.length)}`;

  return input instanceof Request ? new Request(target, input) : target;
}