feat(api): add cognima provider support

packages/types/src/global-settings.ts

@@ -214,6 +214,7 @@ export const SECRET_STATE_KEYS = [
 	"chutesApiKey",
 	"litellmApiKey",
 	"deepInfraApiKey",
+	"cognimaApiKey",
 	"codeIndexOpenAiKey",
 	"codeIndexQdrantApiKey",
 	"codebaseIndexOpenAiCompatibleApiKey",

packages/types/src/provider-settings.ts

@@ -40,6 +40,7 @@ export const DEFAULT_CONSECUTIVE_MISTAKE_LIMIT = 3
 
 export const dynamicProviders = [
 	"openrouter",
+	"cognima",
 	"vercel-ai-gateway",
 	"huggingface",
 	"litellm",
@@ -122,6 +123,7 @@ export const providerNames = [
 	"cerebras",
 	"chutes",
 	"claude-code",
+	"cognima",
 	"doubao",
 	"deepseek",
 	"featherless",
@@ -352,6 +354,10 @@ const groqSchema = apiModelIdProviderModelSchema.extend({
 	groqApiKey: z.string().optional(),
 })
 
+const cognimaSchema = apiModelIdProviderModelSchema.extend({
+	cognimaApiKey: z.string().optional(),
+})
+
 const huggingFaceSchema = baseProviderSettingsSchema.extend({
 	huggingFaceApiKey: z.string().optional(),
 	huggingFaceModelId: z.string().optional(),
@@ -441,6 +447,7 @@ export const providerSettingsSchemaDiscriminated = z.discriminatedUnion("apiProv
 	fakeAiSchema.merge(z.object({ apiProvider: z.literal("fake-ai") })),
 	xaiSchema.merge(z.object({ apiProvider: z.literal("xai") })),
 	groqSchema.merge(z.object({ apiProvider: z.literal("groq") })),
+	cognimaSchema.merge(z.object({ apiProvider: z.literal("cognima") })),
 	huggingFaceSchema.merge(z.object({ apiProvider: z.literal("huggingface") })),
 	chutesSchema.merge(z.object({ apiProvider: z.literal("chutes") })),
 	litellmSchema.merge(z.object({ apiProvider: z.literal("litellm") })),
@@ -482,6 +489,7 @@ export const providerSettingsSchema = z.object({
 	...fakeAiSchema.shape,
 	...xaiSchema.shape,
 	...groqSchema.shape,
+	...cognimaSchema.shape,
 	...huggingFaceSchema.shape,
 	...chutesSchema.shape,
 	...litellmSchema.shape,
@@ -568,6 +576,7 @@ export const modelIdKeysByProvider: Record<TypicalProvider, ModelIdKey> = {
 	requesty: "requestyModelId",
 	xai: "apiModelId",
 	groq: "apiModelId",
+	cognima: "apiModelId",
 	chutes: "apiModelId",
 	litellm: "litellmModelId",
 	huggingface: "huggingFaceModelId",
@@ -661,6 +670,7 @@ export const MODELS_BY_PROVIDER: Record<
 		models: Object.keys(geminiModels),
 	},
 	groq: { id: "groq", label: "Groq", models: Object.keys(groqModels) },
+	"cognima": { id: "cognima", label: "Cognima", models: [] },
 	"io-intelligence": {
 		id: "io-intelligence",
 		label: "IO Intelligence",

packages/types/src/providers/cognima.ts

@@ -0,0 +1,5 @@
+import type { ModelInfo } from "../model.js"
+
+export type CognimaModelId = string
+
+export const cognimaDefaultModelId: CognimaModelId = "gpt-4o"

packages/types/src/providers/index.ts

@@ -2,6 +2,7 @@ export * from "./anthropic.js"
 export * from "./bedrock.js"
 export * from "./cerebras.js"
 export * from "./chutes.js"
+export * from "./cognima.js"
 export * from "./claude-code.js"
 export * from "./deepseek.js"
 export * from "./doubao.js"

src/api/index.ts

@@ -9,6 +9,7 @@ import {
 	AnthropicHandler,
 	AwsBedrockHandler,
 	CerebrasHandler,
+	CognimaHandler,
 	OpenRouterHandler,
 	VertexHandler,
 	AnthropicVertexHandler,
@@ -139,6 +140,8 @@ export function buildApiHandler(configuration: ProviderSettings): ApiHandler {
 			return new XAIHandler(options)
 		case "groq":
 			return new GroqHandler(options)
+		case "cognima":
+			return new CognimaHandler(options)
 		case "deepinfra":
 			return new DeepInfraHandler(options)
 		case "huggingface":

src/api/providers/cognima.ts

@@ -0,0 +1,92 @@
+import { Anthropic } from "@anthropic-ai/sdk"
+import OpenAI from "openai"
+
+import { type CognimaModelId, cognimaDefaultModelId } from "@roo-code/types"
+
+import type { ApiHandlerOptions } from "../../shared/api"
+
+import { convertToOpenAiMessages } from "../transform/openai-format"
+import { ApiStreamChunk } from "../transform/stream"
+import { RouterProvider } from "./router-provider"
+import { handleOpenAIError } from "./utils/openai-error-handler"
+
+export class CognimaHandler extends RouterProvider {
+	private readonly providerName = "Cognima"
+
+	constructor(options: ApiHandlerOptions) {
+		super({
+			options,
+			name: "cognima",
+			baseURL: "https://cog2.cognima.com.br/openai/v1",
+			apiKey: options.cognimaApiKey,
+			modelId: options.cognimaModelId,
+			defaultModelId: cognimaDefaultModelId,
+			defaultModelInfo: {
+				maxTokens: 16384,
+				contextWindow: 128000,
+				supportsImages: true,
+				supportsPromptCache: false,
+				inputPrice: 2.5,
+				outputPrice: 10,
+				supportsTemperature: true,
+			},
+		})
+	}
+
+	override async *createMessage(
+		systemPrompt: string,
+		messages: Anthropic.Messages.MessageParam[],
+	): AsyncGenerator<ApiStreamChunk> {
+		const model = await this.fetchModel()
+		const modelId = model.id
+		const maxTokens = model.info.maxTokens
+		const temperature = 0 // Default temperature
+
+		// Convert Anthropic messages to OpenAI format
+		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
+			{ role: "system", content: systemPrompt },
+			...convertToOpenAiMessages(messages),
+		]
+
+		const completionParams: OpenAI.Chat.ChatCompletionCreateParams = {
+			model: modelId,
+			...(maxTokens && maxTokens > 0 && { max_tokens: maxTokens }),
+			temperature,
+			messages: openAiMessages,
+			stream: true,
+			stream_options: { include_usage: true },
+		}
+
+		let stream
+		try {
+			stream = await this.client.chat.completions.create(completionParams)
+		} catch (error) {
+			throw handleOpenAIError(error, this.providerName)
+		}
+
+		for await (const chunk of stream) {
+			// Handle OpenAI error responses
+			if ("error" in chunk) {
+				const error = chunk.error as { message?: string; code?: number }
+				console.error(`Cognima API Error: ${error?.code} - ${error?.message}`)
+				throw new Error(`Cognima API Error ${error?.code}: ${error?.message}`)
+			}
+
+			const delta = chunk.choices[0]?.delta
+
+			if (delta?.content) {
+				yield { type: "text", text: delta.content }
+			}
+
+			if (chunk.usage) {
+				const usage = chunk.usage
+				yield {
+					type: "usage",
+					inputTokens: usage.prompt_tokens || 0,
+					outputTokens: usage.completion_tokens || 0,
+					totalCost: 0, // Cognima doesn't provide cost info in usage
+				}
+			}
+		}
+	}
+}

src/api/providers/fetchers/cognima.ts

@@ -0,0 +1,113 @@
+import axios from "axios"
+import { z } from "zod"
+
+import type { ModelInfo } from "@roo-code/types"
+
+import { parseApiPrice } from "../../../shared/cost"
+
+/**
+ * CognimaModel
+ */
+
+const cognimaModelSchema = z.object({
+	id: z.string(),
+	owned_by: z.string(),
+	object: z.string(),
+	created: z.number().optional(),
+	updated: z.number().optional(),
+})
+
+export type CognimaModel = z.infer<typeof cognimaModelSchema>
+
+/**
+ * CognimaModelsResponse
+ */
+
+const cognimaModelsResponseSchema = z.object({
+	data: z.array(cognimaModelSchema),
+	object: z.string(),
+})
+
+type CognimaModelsResponse = z.infer<typeof cognimaModelsResponseSchema>
+
+/**
+ * getCognimaModels
+ */
+
+export async function getCognimaModels(apiKey?: string, baseUrl?: string): Promise<Record<string, ModelInfo>> {
+	const models: Record<string, ModelInfo> = {}
+	const baseURL = baseUrl || "https://cog2.cognima.com.br/openai/v1"
+
+	try {
+		const response = await axios.get<CognimaModelsResponse>(`${baseURL}/models`, {
+			headers: {
+				Authorization: `Bearer ${apiKey || "not-provided"}`,
+				"Content-Type": "application/json",
+			},
+		})
+
+		const result = cognimaModelsResponseSchema.safeParse(response.data)
+		const data = result.success ? result.data.data : response.data.data
+
+		if (!result.success) {
+			console.error("Cognima models response is invalid", result.error.format())
+		}
+
+		for (const model of data) {
+			models[model.id] = parseCognimaModel(model)
+		}
+	} catch (error) {
+		console.error(
+			`Error fetching Cognima models: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`,
+		)
+	}
+
+	return models
+}
+
+/**
+ * parseCognimaModel
+ */
+
+const parseCognimaModel = (model: CognimaModel): ModelInfo => {
+	// Provide basic ModelInfo with default values since Cognima API doesn't provide detailed pricing/info
+	// These defaults can be adjusted based on the actual models available
+	const modelInfo: ModelInfo = {
+		maxTokens: 4096, // Default value, can be adjusted per model if needed
+		contextWindow: 128000, // Default value, can be adjusted per model if needed
+		supportsImages: false, // Default to false, can be determined by model id patterns
+		supportsPromptCache: false, // Default to false
+		inputPrice: 0, // Default pricing, should be determined by actual API response or config
+		outputPrice: 0, // Default pricing, should be determined by actual API response or config
+		supportsTemperature: true,
+	}
+
+	// Add model-specific overrides based on ID patterns
+	if (model.id.includes("gpt-4o")) {
+		modelInfo.maxTokens = 16384
+		modelInfo.contextWindow = 128000
+		modelInfo.supportsImages = true
+		modelInfo.inputPrice = 2.5
+		modelInfo.outputPrice = 10
+	} else if (model.id.includes("gpt-4o-mini")) {
+		modelInfo.maxTokens = 16384
+		modelInfo.contextWindow = 128000
+		modelInfo.supportsImages = true
+		modelInfo.inputPrice = 0.15
+		modelInfo.outputPrice = 0.6
+	} else if (model.id.includes("claude-3-5-sonnet")) {
+		modelInfo.maxTokens = 8192
+		modelInfo.contextWindow = 200000
+		modelInfo.supportsImages = true
+		modelInfo.inputPrice = 3.0
+		modelInfo.outputPrice = 15.0
+	} else if (model.id.includes("llama-3.1-70b")) {
+		modelInfo.maxTokens = 4096
+		modelInfo.contextWindow = 128000
+		modelInfo.supportsImages = false
+		modelInfo.inputPrice = 0.52
+		modelInfo.outputPrice = 0.75
+	}
+
+	return modelInfo
+}

src/api/providers/fetchers/modelCache.ts

@@ -25,6 +25,7 @@ import { getIOIntelligenceModels } from "./io-intelligence"
 import { getDeepInfraModels } from "./deepinfra"
 import { getHuggingFaceModels } from "./huggingface"
 import { getRooModels } from "./roo"
+import { getCognimaModels } from "./cognima"
 
 const memoryCache = new NodeCache({ stdTTL: 5 * 60, checkperiod: 5 * 60 })
 
@@ -67,6 +68,9 @@ export const getModels = async (options: GetModelsOptions): Promise<ModelRecord>
 			case "openrouter":
 				models = await getOpenRouterModels()
 				break
+			case "cognima":
+				models = await getCognimaModels(options.apiKey, options.baseUrl)
+				break
 			case "requesty":
 				// Requesty models endpoint requires an API key for per-user custom policies.
 				models = await getRequestyModels(options.baseUrl, options.apiKey)

src/api/providers/index.ts

@@ -2,6 +2,7 @@ export { AnthropicVertexHandler } from "./anthropic-vertex"
 export { AnthropicHandler } from "./anthropic"
 export { AwsBedrockHandler } from "./bedrock"
 export { CerebrasHandler } from "./cerebras"
+export { CognimaHandler } from "./cognima"
 export { ChutesHandler } from "./chutes"
 export { ClaudeCodeHandler } from "./claude-code"
 export { DeepSeekHandler } from "./deepseek"

src/shared/api.ts

@@ -153,6 +153,7 @@ type CommonFetchParams = {
 // until a corresponding entry is added here.
 const dynamicProviderExtras = {
 	openrouter: {} as {}, // eslint-disable-line @typescript-eslint/no-empty-object-type
+	cognima: {} as {}, // eslint-disable-line @typescript-eslint/no-empty-object-type
 	"vercel-ai-gateway": {} as {}, // eslint-disable-line @typescript-eslint/no-empty-object-type
 	huggingface: {} as {}, // eslint-disable-line @typescript-eslint/no-empty-object-type
 	litellm: {} as { apiKey: string; baseUrl: string },