attempt 1

Author: Himanshu-Singh-Chauhan

src/api/index.ts

@@ -28,8 +28,9 @@ export interface SingleCompletionHandler {
 }
 
 export interface ApiHandler {
-	createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream
-	getModel(): { id: string; info: ModelInfo }
+	// completePrompt(prompt: string): Promise<string>
+	createMessage(systemPrompt: string, messages: any[]): AsyncGenerator<any>
+	getModel(): { id: string; info: ModelInfo } | Promise<{ id: string; info: ModelInfo }>
 
 	/**
 	 * Counts tokens for content blocks
@@ -42,7 +43,7 @@ export interface ApiHandler {
 	countTokens(content: Array<Anthropic.Messages.ContentBlockParam>): Promise<number>
 }
 
-export function buildApiHandler(configuration: ApiConfiguration): ApiHandler {
+export function buildApiHandler(configuration: ApiConfiguration): ApiHandler | Promise<ApiHandler> {
 	const { apiProvider, ...options } = configuration
 	switch (apiProvider) {
 		case "anthropic":
@@ -76,7 +77,7 @@ export function buildApiHandler(configuration: ApiConfiguration): ApiHandler {
 		case "requesty":
 			return new RequestyHandler(options)
 		case "pearai":
-			return new PearAiHandler(options)
+			return PearAiHandler.create(options)
 		case "human-relay":
 			return new HumanRelayHandler(options)
 		case "fake-ai":

src/api/providers/base-provider.ts

@@ -15,7 +15,7 @@ export abstract class BaseProvider implements ApiHandler {
 	// Cache the Tiktoken encoder instance since it's stateless
 	private encoder: Tiktoken | null = null
 	abstract createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream
-	abstract getModel(): { id: string; info: ModelInfo }
+	abstract getModel(): { id: string; info: ModelInfo } | Promise<{ id: string; info: ModelInfo }>
 
 	/**
 	 * Default token counting implementation using tiktoken

src/api/providers/pearai/pearai.ts

@@ -25,8 +25,10 @@ export class PearAiHandler extends BaseProvider implements SingleCompletionHandl
 	private handler!: AnthropicHandler | PearAIGenericHandler
 	private pearAiModelsResponse: PearAiModelsResponse | null = null
 	private options: ApiHandlerOptions
+	private initializationPromise: Promise<void> | null = null
 
-	constructor(options: ApiHandlerOptions) {
+	// Private constructor - use the static create method instead
+	private constructor(options: ApiHandlerOptions) {
 		super()
 		if (!options.pearaiApiKey) {
 			vscode.window.showErrorMessage("PearAI API key not found.", "Login to PearAI").then(async (selection) => {
@@ -45,18 +47,16 @@ export class PearAiHandler extends BaseProvider implements SingleCompletionHandl
 			vscode.commands.executeCommand("pearai.checkPearAITokens", undefined)
 		}
 		this.options = options
+		// Start initialization immediately
+		this.initializationPromise = this.initializeHandler(options)
+	}
 
-		this.handler = new PearAIGenericHandler({
-			...options,
-			openAiBaseUrl: PEARAI_URL,
-			openAiApiKey: options.pearaiApiKey,
-			openAiModelId: "deepseek/deepseek-chat",
-		})
-
-		// Then try to initialize the correct handler asynchronously
-		this.initializeHandler(options).catch((error) => {
-			console.error("Failed to initialize PearAI handler:", error)
-		})
+	// Static factory method that properly awaits initialization
+	public static async create(options: ApiHandlerOptions): Promise<PearAiHandler> {
+		const instance = new PearAiHandler(options)
+		// Wait for initialization to complete
+		await instance.initializationPromise
+		return instance
 	}
 
 	private async initializeHandler(options: ApiHandlerOptions): Promise<void> {
@@ -116,7 +116,15 @@ export class PearAiHandler extends BaseProvider implements SingleCompletionHandl
 		}
 	}
 
-	getModel(): { id: string; info: ModelInfo } {
+	private async ensureInitialized(): Promise<void> {
+		if (this.initializationPromise) {
+			await this.initializationPromise
+		}
+	}
+
+	async getModel(): Promise<{ id: string; info: ModelInfo }> {
+		await this.ensureInitialized()
+		
 		if (this.options.apiModelId) {
 			let modelInfo = null
 			if (this.options.apiModelId.startsWith("pearai")) {
@@ -142,6 +150,7 @@ export class PearAiHandler extends BaseProvider implements SingleCompletionHandl
 	}
 
 	async *createMessage(systemPrompt: string, messages: any[]): AsyncGenerator<any> {
+		await this.ensureInitialized()
 		const generator = this.handler.createMessage(systemPrompt, messages)
 		let warningMsg = ""
 
@@ -168,6 +177,7 @@ export class PearAiHandler extends BaseProvider implements SingleCompletionHandl
 	}
 
 	async completePrompt(prompt: string): Promise<string> {
+		await this.ensureInitialized()
 		return this.handler.completePrompt(prompt)
 	}
 }

src/core/Cline.ts

@@ -83,6 +83,7 @@ import { parseXml } from "../utils/xml"
 import { readLines } from "../integrations/misc/read-lines"
 import { getWorkspacePath } from "../utils/path"
 import { isBinaryFile } from "isbinaryfile"
+import { AnthropicHandler } from "../api/providers/anthropic"
 
 type ToolResponse = string | Array<Anthropic.TextBlockParam | Anthropic.ImageBlockParam>
 type UserContent = Array<Anthropic.Messages.ContentBlockParam>
@@ -208,7 +209,15 @@ export class Cline extends EventEmitter<ClineEvents> {
 		this.instanceId = crypto.randomUUID().slice(0, 8)
 		this.taskNumber = -1
 		this.apiConfiguration = apiConfiguration
-		this.api = buildApiHandler(apiConfiguration)
+		
+		// Initialize with a temporary handler that will be replaced
+		this.api = new AnthropicHandler(apiConfiguration)
+		
+		// Then asynchronously initialize the correct handler
+		this.initializeApiHandler(apiConfiguration).catch(error => {
+			console.error("Failed to initialize API handler:", error)
+		})
+		
 		this.urlContentFetcher = new UrlContentFetcher(provider.context)
 		this.browserSession = new BrowserSession(provider.context)
 		this.customInstructions = customInstructions
@@ -4173,6 +4182,15 @@ export class Cline extends EventEmitter<ClineEvents> {
 			this.enableCheckpoints = false
 		}
 	}
+
+	private async initializeApiHandler(apiConfiguration: ApiConfiguration): Promise<void> {
+		const apiHandler = buildApiHandler(apiConfiguration)
+		if (apiHandler instanceof Promise) {
+			this.api = await apiHandler
+		} else {
+			this.api = apiHandler
+		}
+	}
 }
 
 function escapeRegExp(string: string): string {

src/core/webview/ClineProvider.ts

@@ -2159,7 +2159,12 @@ export class ClineProvider extends EventEmitter<ClineProviderEvents> implements
 		await this.contextProxy.setApiConfiguration(apiConfiguration)
 
 		if (this.getCurrentCline()) {
-			this.getCurrentCline()!.api = buildApiHandler(apiConfiguration)
+			const apiHandler = buildApiHandler(apiConfiguration)
+			if (apiHandler instanceof Promise) {
+				this.getCurrentCline()!.api = await apiHandler
+			} else {
+				this.getCurrentCline()!.api = apiHandler
+			}
 		}
 	}
 

src/utils/__tests__/enhance-prompt.test.ts

@@ -37,7 +37,8 @@ describe("enhancePrompt", () => {
 		const result = await singleCompletionHandler(mockApiConfig, "Test prompt")
 
 		expect(result).toBe("Enhanced prompt")
-		const handler = buildApiHandler(mockApiConfig)
+		const handlerPromise = buildApiHandler(mockApiConfig)
+		const handler = await (handlerPromise instanceof Promise ? handlerPromise : Promise.resolve(handlerPromise))
 		expect((handler as any).completePrompt).toHaveBeenCalledWith(`Test prompt`)
 	})
 
@@ -59,7 +60,8 @@ describe("enhancePrompt", () => {
 		)
 
 		expect(result).toBe("Enhanced prompt")
-		const handler = buildApiHandler(mockApiConfig)
+		const handlerPromise = buildApiHandler(mockApiConfig)
+		const handler = await (handlerPromise instanceof Promise ? handlerPromise : Promise.resolve(handlerPromise))
 		expect((handler as any).completePrompt).toHaveBeenCalledWith(`${customEnhancePrompt}\n\nTest prompt`)
 	})
 

src/utils/single-completion-handler.ts

@@ -13,7 +13,8 @@ export async function singleCompletionHandler(apiConfiguration: ApiConfiguration
 		throw new Error("No valid API configuration provided")
 	}
 
-	const handler = buildApiHandler(apiConfiguration)
+	const handlerPromise = buildApiHandler(apiConfiguration)
+	const handler = await (handlerPromise instanceof Promise ? handlerPromise : Promise.resolve(handlerPromise))
 
 	// Check if handler supports single completions
 	if (!("completePrompt" in handler)) {