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.
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;
}