Additional providers having apikey

Signed-off-by: Geoff Wilson <[email protected]>

Author: suprjinx

packages/types/src/constants.ts

@@ -15,6 +15,17 @@ export const API_KEYS = {
 	GROQ: 'GROQ_API_KEY',
 	CHUTES: 'CHUTES_API_KEY',
 	LITELLM: 'LITELLM_API_KEY',
+	CEREBRAS: 'CEREBRAS_API_KEY',
+	DEEP_INFRA: 'DEEPINFRA_API_KEY',
+	DOUBAO: 'DOUBAO_API_KEY',
+	FEATHERLESS: 'FEATHERLESS_API_KEY',
+	FIREWORKS: 'FIREWORKS_API_KEY',
+	HUGGING_FACE: 'HUGGINGFACE_API_KEY',
+	IO_INTELLIGENCE: 'IOINTELLIGENCE_API_KEY',
+	MOONSHOOT: 'MOONSHOT_API_KEY',
+	SAMBA_NOVA: 'SAMBANOVA_API_KEY',
+	VERCEL_NOVA: 'VERCEL_API_KEY',
+	ZAI: 'ZAI_API_KEY',
 } as const
 
 /**

packages/types/src/provider-settings.ts

@@ -320,19 +320,22 @@ const deepSeekSchema = apiModelIdProviderModelSchema.extend({
 const deepInfraSchema = apiModelIdProviderModelSchema.extend({
 	deepInfraBaseUrl: z.string().optional(),
 	deepInfraApiKey: z.string().optional(),
+	deepInfraConfigUseEnvVars: z.boolean().optional(),
 	deepInfraModelId: z.string().optional(),
 })
 
 const doubaoSchema = apiModelIdProviderModelSchema.extend({
 	doubaoBaseUrl: z.string().optional(),
 	doubaoApiKey: z.string().optional(),
+	doubaoConfigUseEnvVars: z.boolean().optional(),
 })
 
 const moonshotSchema = apiModelIdProviderModelSchema.extend({
 	moonshotBaseUrl: z
 		.union([z.literal("https://api.moonshot.ai/v1"), z.literal("https://api.moonshot.cn/v1")])
 		.optional(),
 	moonshotApiKey: z.string().optional(),
+	moonshotConfigUseEnvVars: z.boolean().optional(),
 })
 
 const unboundSchema = baseProviderSettingsSchema.extend({
@@ -366,6 +369,7 @@ const groqSchema = apiModelIdProviderModelSchema.extend({
 
 const huggingFaceSchema = baseProviderSettingsSchema.extend({
 	huggingFaceApiKey: z.string().optional(),
+	huggingFaceConfigUseEnvVars: z.boolean().optional(),	
 	huggingFaceModelId: z.string().optional(),
 	huggingFaceInferenceProvider: z.string().optional(),
 })
@@ -385,10 +389,12 @@ const litellmSchema = baseProviderSettingsSchema.extend({
 
 const cerebrasSchema = apiModelIdProviderModelSchema.extend({
 	cerebrasApiKey: z.string().optional(),
+	cerebrasConfigUseEnvVars: z.boolean().optional(),
 })
 
 const sambaNovaSchema = apiModelIdProviderModelSchema.extend({
 	sambaNovaApiKey: z.string().optional(),
+	sambaNovaConfigUseEnvVars: z.boolean().optional(),	
 })
 
 export const zaiApiLineSchema = z.enum(["international_coding", "international", "china_coding", "china"])
@@ -397,20 +403,24 @@ export type ZaiApiLine = z.infer<typeof zaiApiLineSchema>
 
 const zaiSchema = apiModelIdProviderModelSchema.extend({
 	zaiApiKey: z.string().optional(),
+	zaiConfigUseEnvVars: z.boolean().optional(),
 	zaiApiLine: zaiApiLineSchema.optional(),
 })
 
 const fireworksSchema = apiModelIdProviderModelSchema.extend({
 	fireworksApiKey: z.string().optional(),
+	fireworksConfigUseEnvVars: z.boolean().optional(),
 })
 
 const featherlessSchema = apiModelIdProviderModelSchema.extend({
 	featherlessApiKey: z.string().optional(),
+	featherlessConfigUseEnvVars: z.boolean().optional(),	
 })
 
 const ioIntelligenceSchema = apiModelIdProviderModelSchema.extend({
 	ioIntelligenceModelId: z.string().optional(),
 	ioIntelligenceApiKey: z.string().optional(),
+	ioIntelligenceConfigUseEnvVars: z.boolean().optional(),
 })
 
 const qwenCodeSchema = apiModelIdProviderModelSchema.extend({
@@ -423,6 +433,7 @@ const rooSchema = apiModelIdProviderModelSchema.extend({
 
 const vercelAiGatewaySchema = baseProviderSettingsSchema.extend({
 	vercelAiGatewayApiKey: z.string().optional(),
+	vercelConfigUseEnvVars: z.boolean().optional(),
 	vercelAiGatewayModelId: z.string().optional(),
 })
 

src/api/__tests__/index.spec.ts

@@ -31,6 +31,15 @@ vi.mock("../providers", () => ({
 	HumanRelayHandler: vi.fn().mockImplementation(() => ({ provider: "human-relay" })),
 	FakeAIHandler: vi.fn().mockImplementation((options) => ({ provider: "fake-ai", options })),
 	HuggingFaceHandler: vi.fn().mockImplementation((options) => ({ provider: "huggingface", options })),
+	CerebrasHandler: vi.fn().mockImplementation((options) => ({ provider: "cerebras", options })),
+	SambaNovaHandler: vi.fn().mockImplementation((options) => ({ provider: "sambanova", options })),
+	ZAiHandler: vi.fn().mockImplementation((options) => ({ provider: "zai", options })),
+	FireworksHandler: vi.fn().mockImplementation((options) => ({ provider: "fireworks", options })),
+	FeatherlessHandler: vi.fn().mockImplementation((options) => ({ provider: "featherless", options })),
+	IOIntelligenceHandler: vi.fn().mockImplementation((options) => ({ provider: "io-intelligence", options })),
+	VercelAiGatewayHandler: vi.fn().mockImplementation((options) => ({ provider: "vercel-ai-gateway", options })),
+	DoubaoHandler: vi.fn().mockImplementation((options) => ({ provider: "doubao", options })),
+	DeepInfraHandler: vi.fn().mockImplementation((options) => ({ provider: "deepinfra", options })),
 }))
 
 describe("API Environment Variable Integration", () => {
@@ -331,6 +340,171 @@ describe("API Environment Variable Integration", () => {
 			})
 		})
 
+		describe("cerebras provider", () => {
+			it("should use environment variable when cerebrasConfigUseEnvVars is true", () => {
+				process.env.CEREBRAS_API_KEY = "env-cerebras-key"
+
+				const config: ProviderSettings = {
+					apiProvider: "cerebras",
+					cerebrasApiKey: "config-key",
+					cerebrasConfigUseEnvVars: true,
+				}
+
+				const handler = buildApiHandler(config) as any
+				expect(handler.options.cerebrasApiKey).toBe("env-cerebras-key")
+			})
+		})
+
+		describe("sambanova provider", () => {
+			it("should use environment variable when sambaNovaConfigUseEnvVars is true", () => {
+				process.env.SAMBANOVA_API_KEY = "env-sambanova-key"
+
+				const config: ProviderSettings = {
+					apiProvider: "sambanova",
+					sambaNovaApiKey: "config-key",
+					sambaNovaConfigUseEnvVars: true,
+				}
+
+				const handler = buildApiHandler(config) as any
+				expect(handler.options.sambaNovaApiKey).toBe("env-sambanova-key")
+			})
+		})
+
+		describe("zai provider", () => {
+			it("should use environment variable when zaiConfigUseEnvVars is true", () => {
+				process.env.ZAI_API_KEY = "env-zai-key"
+
+				const config: ProviderSettings = {
+					apiProvider: "zai",
+					zaiApiKey: "config-key",
+					zaiConfigUseEnvVars: true,
+				}
+
+				const handler = buildApiHandler(config) as any
+				expect(handler.options.zaiApiKey).toBe("env-zai-key")
+			})
+		})
+
+		describe("fireworks provider", () => {
+			it("should use environment variable when fireworksConfigUseEnvVars is true", () => {
+				process.env.FIREWORKS_API_KEY = "env-fireworks-key"
+
+				const config: ProviderSettings = {
+					apiProvider: "fireworks",
+					fireworksApiKey: "config-key",
+					fireworksConfigUseEnvVars: true,
+				}
+
+				const handler = buildApiHandler(config) as any
+				expect(handler.options.fireworksApiKey).toBe("env-fireworks-key")
+			})
+		})
+
+		describe("featherless provider", () => {
+			it("should use environment variable when featherlessConfigUseEnvVars is true", () => {
+				process.env.FEATHERLESS_API_KEY = "env-featherless-key"
+
+				const config: ProviderSettings = {
+					apiProvider: "featherless",
+					featherlessApiKey: "config-key",
+					featherlessConfigUseEnvVars: true,
+				}
+
+				const handler = buildApiHandler(config) as any
+				expect(handler.options.featherlessApiKey).toBe("env-featherless-key")
+			})
+		})
+
+		describe("io-intelligence provider", () => {
+			it("should use environment variable when ioIntelligenceConfigUseEnvVars is true", () => {
+				process.env.IOINTELLIGENCE_API_KEY = "env-iointelligence-key"
+
+				const config: ProviderSettings = {
+					apiProvider: "io-intelligence",
+					ioIntelligenceApiKey: "config-key",
+					ioIntelligenceConfigUseEnvVars: true,
+				}
+
+				const handler = buildApiHandler(config) as any
+				expect(handler.options.ioIntelligenceApiKey).toBe("env-iointelligence-key")
+			})
+		})
+
+		describe("vercel-ai-gateway provider", () => {
+			it("should use environment variable when vercelConfigUseEnvVars is true", () => {
+				process.env.VERCEL_API_KEY = "env-vercel-key"
+
+				const config: ProviderSettings = {
+					apiProvider: "vercel-ai-gateway",
+					vercelAiGatewayApiKey: "config-key",
+					vercelConfigUseEnvVars: true,
+				}
+
+				const handler = buildApiHandler(config) as any
+				expect(handler.options.vercelAiGatewayApiKey).toBe("env-vercel-key")
+			})
+		})
+
+		describe("doubao provider", () => {
+			it("should use environment variable when doubaoConfigUseEnvVars is true", () => {
+				process.env.DOUBAO_API_KEY = "env-doubao-key"
+
+				const config: ProviderSettings = {
+					apiProvider: "doubao",
+					doubaoApiKey: "config-key",
+					doubaoConfigUseEnvVars: true,
+				}
+
+				const handler = buildApiHandler(config) as any
+				expect(handler.options.doubaoApiKey).toBe("env-doubao-key")
+			})
+		})
+
+		describe("moonshot provider", () => {
+			it("should use environment variable when moonshotConfigUseEnvVars is true", () => {
+				process.env.MOONSHOT_API_KEY = "env-moonshot-key"
+
+				const config: ProviderSettings = {
+					apiProvider: "moonshot",
+					moonshotApiKey: "config-key",
+					moonshotConfigUseEnvVars: true,
+				}
+
+				const handler = buildApiHandler(config) as any
+				expect(handler.options.moonshotApiKey).toBe("env-moonshot-key")
+			})
+		})
+
+		describe("huggingface provider", () => {
+			it("should use environment variable when huggingFaceConfigUseEnvVars is true", () => {
+				process.env.HUGGINGFACE_API_KEY = "env-huggingface-key"
+
+				const config: ProviderSettings = {
+					apiProvider: "huggingface",
+					huggingFaceApiKey: "config-key",
+					huggingFaceConfigUseEnvVars: true,
+				}
+
+				const handler = buildApiHandler(config) as any
+				expect(handler.options.huggingFaceApiKey).toBe("env-huggingface-key")
+			})
+		})
+
+		describe("deepinfra provider", () => {
+			it("should use environment variable when deepInfraConfigUseEnvVars is true", () => {
+				process.env.DEEPINFRA_API_KEY = "env-deepinfra-key"
+
+				const config: ProviderSettings = {
+					apiProvider: "deepinfra",
+					deepInfraApiKey: "config-key",
+					deepInfraConfigUseEnvVars: true,
+				}
+
+				const handler = buildApiHandler(config) as any
+				expect(handler.options.deepInfraApiKey).toBe("env-deepinfra-key")
+			})
+		})
+
 		describe("providers without environment variable support", () => {
 			it("should not modify options for claude-code provider", () => {
 				const config: ProviderSettings = {
@@ -382,6 +556,17 @@ describe("API Environment Variable Integration", () => {
 					"GROQ_API_KEY",
 					"CHUTES_API_KEY",
 					"LITELLM_API_KEY",
+					"CEREBRAS_API_KEY",
+					"SAMBANOVA_API_KEY",
+					"ZAI_API_KEY",
+					"FIREWORKS_API_KEY",
+					"FEATHERLESS_API_KEY",
+					"IOINTELLIGENCE_API_KEY",
+					"VERCEL_API_KEY",
+					"DOUBAO_API_KEY",
+					"MOONSHOT_API_KEY",
+					"HUGGINGFACE_API_KEY",
+					"DEEPINFRA_API_KEY",
 				]
 
 				envVars.forEach((envVar, index) => {

src/api/index.ts

@@ -153,10 +153,16 @@ export function buildApiHandler(configuration: ProviderSettings): ApiHandler {
 			}
 			return new DeepSeekHandler(options)
 		case "doubao":
+			if (options.doubaoConfigUseEnvVars) {
+				options.doubaoApiKey = getEnvVar("DOUBAO_API_KEY", options.doubaoApiKey)
+			}
 			return new DoubaoHandler(options)
 		case "qwen-code":
 			return new QwenCodeHandler(options)
 		case "moonshot":
+			if (options.moonshotConfigUseEnvVars) {
+				options.moonshotApiKey = getEnvVar("MOONSHOT_API_KEY", options.moonshotApiKey)
+			}
 			return new MoonshotHandler(options)
 		case "vscode-lm":
 			return new VsCodeLmHandler(options)
@@ -190,8 +196,14 @@ export function buildApiHandler(configuration: ProviderSettings): ApiHandler {
 			}
 			return new GroqHandler(options)
 		case "deepinfra":
+			if (options.deepInfraConfigUseEnvVars) {
+				options.deepInfraApiKey = getEnvVar("DEEPINFRA_API_KEY", options.deepInfraApiKey)
+			}
 			return new DeepInfraHandler(options)
 		case "huggingface":
+			if (options.huggingFaceConfigUseEnvVars) {
+				options.huggingFaceApiKey = getEnvVar("HUGGINGFACE_API_KEY", options.huggingFaceApiKey)
+			}
 			return new HuggingFaceHandler(options)
 		case "chutes":
 			if (options.chutesConfigUseEnvVars) {
@@ -204,22 +216,43 @@ export function buildApiHandler(configuration: ProviderSettings): ApiHandler {
 			}
 			return new LiteLLMHandler(options)
 		case "cerebras":
+			if (options.cerebrasConfigUseEnvVars) {
+				options.cerebrasApiKey = getEnvVar("CEREBRAS_API_KEY", options.cerebrasApiKey)
+			}
 			return new CerebrasHandler(options)
 		case "sambanova":
+			if (options.sambaNovaConfigUseEnvVars) {
+				options.sambaNovaApiKey = getEnvVar("SAMBANOVA_API_KEY", options.sambaNovaApiKey)
+			}
 			return new SambaNovaHandler(options)
 		case "zai":
+			if (options.zaiConfigUseEnvVars) {
+				options.zaiApiKey = getEnvVar("ZAI_API_KEY", options.zaiApiKey)
+			}
 			return new ZAiHandler(options)
 		case "fireworks":
+			if (options.fireworksConfigUseEnvVars) {
+				options.fireworksApiKey = getEnvVar("FIREWORKS_API_KEY", options.fireworksApiKey)
+			}
 			return new FireworksHandler(options)
 		case "io-intelligence":
+			if (options.ioIntelligenceConfigUseEnvVars) {
+				options.ioIntelligenceApiKey = getEnvVar("IOINTELLIGENCE_API_KEY", options.ioIntelligenceApiKey)
+			}
 			return new IOIntelligenceHandler(options)
 		case "roo":
 			// Never throw exceptions from provider constructors
 			// The provider-proxy server will handle authentication and return appropriate error codes
 			return new RooHandler(options)
 		case "featherless":
+			if (options.featherlessConfigUseEnvVars) {
+				options.featherlessApiKey = getEnvVar("FEATHERLESS_API_KEY", options.featherlessApiKey)
+			}
 			return new FeatherlessHandler(options)
 		case "vercel-ai-gateway":
+			if (options.vercelConfigUseEnvVars) {
+				options.vercelAiGatewayApiKey = getEnvVar("VERCEL_API_KEY", options.vercelAiGatewayApiKey)
+			}
 			return new VercelAiGatewayHandler(options)
 		default:
 			apiProvider satisfies "gemini-cli" | undefined