fix: i18n

Author: AntiMoron

packages/types/src/codebase-index.ts

@@ -48,6 +48,7 @@ export const codebaseIndexModelsSchema = z.object({
 	"openai-compatible": z.record(z.string(), z.object({ dimension: z.number() })).optional(),
 	gemini: z.record(z.string(), z.object({ dimension: z.number() })).optional(),
 	mistral: z.record(z.string(), z.object({ dimension: z.number() })).optional(),
+	doubao: z.record(z.string(), z.object({ dimension: z.number() })).optional(),
 })
 
 export type CodebaseIndexModels = z.infer<typeof codebaseIndexModelsSchema>

packages/types/src/provider-settings.ts

@@ -24,6 +24,7 @@ export const providerNames = [
 	"mistral",
 	"moonshot",
 	"deepseek",
+	"doubao",
 	"unbound",
 	"requesty",
 	"human-relay",
@@ -194,6 +195,11 @@ const deepSeekSchema = apiModelIdProviderModelSchema.extend({
 	deepSeekApiKey: z.string().optional(),
 })
 
+const doubaoSchema = apiModelIdProviderModelSchema.extend({
+	doubaoBaseUrl: z.string().optional(),
+	doubaoApiKey: z.string().optional(),
+})
+
 const moonshotSchema = apiModelIdProviderModelSchema.extend({
 	moonshotBaseUrl: z
 		.union([z.literal("https://api.moonshot.ai/v1"), z.literal("https://api.moonshot.cn/v1")])
@@ -266,6 +272,7 @@ export const providerSettingsSchemaDiscriminated = z.discriminatedUnion("apiProv
 	openAiNativeSchema.merge(z.object({ apiProvider: z.literal("openai-native") })),
 	mistralSchema.merge(z.object({ apiProvider: z.literal("mistral") })),
 	deepSeekSchema.merge(z.object({ apiProvider: z.literal("deepseek") })),
+	doubaoSchema.merge(z.object({ apiProvider: z.literal("doubao") })),
 	moonshotSchema.merge(z.object({ apiProvider: z.literal("moonshot") })),
 	unboundSchema.merge(z.object({ apiProvider: z.literal("unbound") })),
 	requestySchema.merge(z.object({ apiProvider: z.literal("requesty") })),
@@ -297,6 +304,7 @@ export const providerSettingsSchema = z.object({
 	...openAiNativeSchema.shape,
 	...mistralSchema.shape,
 	...deepSeekSchema.shape,
+	...doubaoSchema.shape,
 	...moonshotSchema.shape,
 	...unboundSchema.shape,
 	...requestySchema.shape,

packages/types/src/providers/doubao.ts

@@ -0,0 +1,44 @@
+import type { ModelInfo } from "../model.js"
+
+export const doubaoDefaultModelId = "doubao-seed-1-6-250615"
+
+export const doubaoModels = {
+	"doubao-seed-1-6-250615": {
+		maxTokens: 32_768,
+		contextWindow: 128_000,
+		supportsImages: true,
+		supportsPromptCache: true,
+		inputPrice: 0.0001, // $0.0001 per million tokens (cache miss)
+		outputPrice: 0.0004, // $0.0004 per million tokens
+		cacheWritesPrice: 0.0001, // $0.0001 per million tokens (cache miss)
+		cacheReadsPrice: 0.00002, // $0.00002 per million tokens (cache hit)
+		description: `Doubao Seed 1.6 is a powerful model designed for high-performance tasks with extensive context handling.`,
+	},
+	"doubao-seed-1-6-thinking-250715": {
+		maxTokens: 32_768,
+		contextWindow: 128_000,
+		supportsImages: true,
+		supportsPromptCache: true,
+		inputPrice: 0.0002, // $0.0002 per million tokens
+		outputPrice: 0.0008, // $0.0008 per million tokens
+		cacheWritesPrice: 0.0002, // $0.0002 per million
+		cacheReadsPrice: 0.00004, // $0.00004 per million tokens (cache hit)
+		description: `Doubao Seed 1.6 Thinking is optimized for reasoning tasks, providing enhanced performance in complex problem-solving scenarios.`,
+	},
+	"doubao-seed-1-6-flash-250715": {
+		maxTokens: 32_768,
+		contextWindow: 128_000,
+		supportsImages: true,
+		supportsPromptCache: true,
+		inputPrice: 0.00015, // $0.00015 per million tokens
+		outputPrice: 0.0006, // $0.0006 per million tokens
+		cacheWritesPrice: 0.00015, // $0.00015 per million
+		cacheReadsPrice: 0.00003, // $0.00003 per million tokens (cache hit)
+		description: `Doubao Seed 1.6 Flash is tailored for speed and efficiency, making it ideal for applications requiring rapid responses.`,
+	},
+} as const satisfies Record<string, ModelInfo>
+
+export const doubaoDefaultModelInfo: ModelInfo = doubaoModels[doubaoDefaultModelId]
+
+export const DOUBAO_API_BASE_URL = "https://ark.cn-beijing.volces.com/api/v3"
+export const DOUBAO_API_CHAT_PATH = "/chat/completions"

packages/types/src/providers/index.ts

@@ -20,3 +20,4 @@ export * from "./unbound.js"
 export * from "./vertex.js"
 export * from "./vscode-llm.js"
 export * from "./xai.js"
+export * from "./doubao.js"

src/api/index.ts

@@ -31,6 +31,7 @@ import {
 	LiteLLMHandler,
 	ClaudeCodeHandler,
 	SambaNovaHandler,
+	DoubaoHandler,
 } from "./providers"
 
 export interface SingleCompletionHandler {
@@ -92,6 +93,8 @@ export function buildApiHandler(configuration: ProviderSettings): ApiHandler {
 			return new OpenAiNativeHandler(options)
 		case "deepseek":
 			return new DeepSeekHandler(options)
+		case "doubao":
+			return new DoubaoHandler(options)
 		case "moonshot":
 			return new MoonshotHandler(options)
 		case "vscode-lm":

src/api/providers/doubao.ts

@@ -0,0 +1,93 @@
+import { OpenAiHandler } from "./openai"
+import type { ApiHandlerOptions } from "../../shared/api"
+import { DOUBAO_API_BASE_URL, doubaoDefaultModelId, doubaoModels } from "@roo-code/types"
+import { getModelParams } from "../transform/model-params"
+import { ApiStreamUsageChunk } from "../transform/stream"
+
+// by a fan of Doubao, his name on Github is AntiMoron.
+// Core types for Doubao API
+interface ChatCompletionMessageParam {
+	role: "system" | "user" | "assistant" | "developer"
+	content:
+		| string
+		| Array<{
+				type: "text" | "image_url"
+				text?: string
+				image_url?: { url: string }
+		  }>
+}
+
+interface ChatCompletionParams {
+	model: string
+	messages: ChatCompletionMessageParam[]
+	temperature?: number
+	stream?: boolean
+	stream_options?: { include_usage: boolean }
+	max_completion_tokens?: number
+}
+
+interface ChatCompletion {
+	choices: Array<{
+		message: {
+			content: string
+		}
+	}>
+	usage?: {
+		prompt_tokens: number
+		completion_tokens: number
+	}
+}
+
+interface ChatCompletionChunk {
+	choices: Array<{
+		delta: {
+			content?: string
+		}
+	}>
+	usage?: {
+		prompt_tokens: number
+		completion_tokens: number
+	}
+}
+
+// interface ApiHandlerOptions {
+// 	doubaoBaseUrl?: string
+// 	doubaoApiKey?: string
+// 	doubaoHeaders?: Record<string, string>
+// 	doubaoModelId?: string
+// 	doubaoStreamingEnabled?: boolean
+// 	modelTemperature?: number
+// 	includeMaxTokens?: boolean
+// 	modelMaxTokens?: number
+// }
+
+export class DoubaoHandler extends OpenAiHandler {
+	constructor(options: ApiHandlerOptions) {
+		super({
+			...options,
+			openAiApiKey: options.doubaoApiKey ?? "not-provided",
+			openAiModelId: options.apiModelId ?? doubaoDefaultModelId,
+			openAiBaseUrl: options.doubaoBaseUrl ?? DOUBAO_API_BASE_URL,
+			openAiStreamingEnabled: true,
+			includeMaxTokens: true,
+		})
+	}
+
+	override getModel() {
+		const id = this.options.apiModelId ?? doubaoDefaultModelId
+		const info = doubaoModels[id as keyof typeof doubaoModels] || doubaoModels[doubaoDefaultModelId]
+		const params = getModelParams({ format: "openai", modelId: id, model: info, settings: this.options })
+		return { id, info, ...params }
+	}
+
+	// Override to handle Doubao's usage metrics, including caching.
+	protected override processUsageMetrics(usage: any): ApiStreamUsageChunk {
+		return {
+			type: "usage",
+			inputTokens: usage?.prompt_tokens || 0,
+			outputTokens: usage?.completion_tokens || 0,
+			cacheWriteTokens: usage?.prompt_tokens_details?.cache_miss_tokens,
+			cacheReadTokens: usage?.prompt_tokens_details?.cached_tokens,
+		}
+	}
+}

src/api/providers/index.ts

@@ -4,6 +4,7 @@ export { AwsBedrockHandler } from "./bedrock"
 export { ChutesHandler } from "./chutes"
 export { ClaudeCodeHandler } from "./claude-code"
 export { DeepSeekHandler } from "./deepseek"
+export { DoubaoHandler } from "./doubao"
 export { MoonshotHandler } from "./moonshot"
 export { FakeAIHandler } from "./fake-ai"
 export { GeminiHandler } from "./gemini"

src/services/code-index/constants/index.ts

@@ -29,3 +29,6 @@ export const BATCH_PROCESSING_CONCURRENCY = 10
 
 /**Gemini Embedder */
 export const GEMINI_MAX_ITEM_TOKENS = 2048
+
+/**Doubao Embedder */
+export const DOUBAO_MAX_ITEM_TOKENS = 2048

src/services/code-index/embedders/doubao.ts

@@ -0,0 +1,76 @@
+import { OpenAICompatibleEmbedder } from "./openai-compatible"
+import { IEmbedder, EmbeddingResponse, EmbedderInfo } from "../interfaces/embedder"
+import { t } from "../../../i18n"
+import { TelemetryEventName } from "@roo-code/types"
+import { TelemetryService } from "@roo-code/telemetry"
+import { DOUBAO_MAX_ITEM_TOKENS } from "../constants"
+
+export class DoubaoEmbedder implements IEmbedder {
+	private readonly openAICompatibleEmbedder: OpenAICompatibleEmbedder
+	private static readonly Doubao_BASE_URL = "https://ark.cn-beijing.volces.com/api/v3/"
+	private static readonly DEFAULT_MODEL = "doubao-embedding-text-240515"
+	private readonly modelId: string
+
+	constructor(apiKey: string, modelId?: string) {
+		if (!apiKey) {
+			throw new Error(t("embeddings:validation.apiKeyRequired"))
+		}
+
+		// Use provided model or default
+		this.modelId = modelId || DoubaoEmbedder.DEFAULT_MODEL
+
+		// Create an OpenAI Compatible embedder with Doubao's configuration
+		this.openAICompatibleEmbedder = new OpenAICompatibleEmbedder(
+			DoubaoEmbedder.Doubao_BASE_URL,
+			apiKey,
+			this.modelId,
+			DOUBAO_MAX_ITEM_TOKENS,
+		)
+	}
+
+	/**
+	 * Creates embeddings for the given texts using Doubao's embedding API
+	 * @param texts Array of text strings to embed
+	 * @param model Optional model identifier (uses constructor model if not provided)
+	 * @returns Promise resolving to embedding response
+	 */
+	async createEmbeddings(texts: string[], model?: string): Promise<EmbeddingResponse> {
+		try {
+			// Use the provided model or fall back to the instance's model
+			const modelToUse = model || this.modelId
+			return await this.openAICompatibleEmbedder.createEmbeddings(texts, modelToUse)
+		} catch (error) {
+			TelemetryService.instance.captureEvent(TelemetryEventName.CODE_INDEX_ERROR, {
+				error: error instanceof Error ? error.message : String(error),
+				stack: error instanceof Error ? error.stack : undefined,
+				location: "DoubaoEmbedder:createEmbeddings",
+			})
+			throw error
+		}
+	}
+
+	/**
+	 * Validates the Doubao embedder configuration by delegating to the underlying OpenAI-compatible embedder
+	 * @returns Promise resolving to validation result with success status and optional error message
+	 */
+	async validateConfiguration(): Promise<{ valid: boolean; error?: string }> {
+		try {
+			// Delegate validation to the OpenAI-compatible embedder
+			// The error messages will be specific to Doubao since we're using Doubao's base URL
+			return await this.openAICompatibleEmbedder.validateConfiguration()
+		} catch (error) {
+			TelemetryService.instance.captureEvent(TelemetryEventName.CODE_INDEX_ERROR, {
+				error: error instanceof Error ? error.message : String(error),
+				stack: error instanceof Error ? error.stack : undefined,
+				location: "DoubaoEmbedder:validateConfiguration",
+			})
+			throw error
+		}
+	}
+
+	get embedderInfo(): EmbedderInfo {
+		return {
+			name: "doubao",
+		}
+	}
+}

src/services/code-index/embedders/index.ts

@@ -0,0 +1,6 @@
+export * from "./openai-compatible"
+export * from "./openai"
+export * from "./ollama"
+export * from "./gemini"
+export * from "./mistral"
+export * from "./doubao"