proxy.ts (3)

37-37: Replace 'void' with 'undefined' in return type to avoid confusion

Using void in a union type can be confusing. Consider replacing void with undefined for clarity.

Apply this diff to update the return type:

-private handleAllRequest(c: any, next: () => Promise<any>): Response | Promise<void | Response> {
+private handleAllRequest(c: any, next: () => Promise<any>): Response | Promise<Response | undefined> {

🧰 Tools

🪛 Biome (1.9.4)

[error] 37-37: void is confusing inside a union type.

Unsafe fix: Use undefined instead.

(lint/suspicious/noConfusingVoidType)

---

97-100: Improve type safety by specifying explicit types instead of 'any'

The method isVerifyRequest uses parameters typed as any. Specifying explicit types enhances type safety and code readability.

Consider defining a type or interface for the context c and the json object. For example:

interface RequestContext {
  req: Request;
  res: Response;
  // other properties...
}

interface JsonBody {
  model: string;
  stream: boolean;
  // other properties...
}

Then, update the method signature:

-private isVerifyRequest(c: any, json: any) {
+private isVerifyRequest(c: RequestContext, json: JsonBody) {

---

190-207: Handle potential errors when parsing JSON in 'getModelsList'

In the getModelsList method, if the response is not valid JSON, res.json() could throw an error. Consider adding a check to handle this scenario gracefully.

Apply this diff to catch JSON parsing errors:

 try {
   const res = await fetch(req);
-  const data = await res.json();
+  const data = await res.json().catch(() => null);
+  if (!data) {
+    throw new Error("Invalid JSON response");
+  }
   return data.models || [];
 } catch (error) {

main.ts (1)

90-90: Fix typo: 'OpenAl' should be 'OpenAI'

There's a typo in the console output. The term 'OpenAl' should be corrected to 'OpenAI' to reflect the proper name.

Apply this diff to correct the typo:

 italic(`Override OpenAl Base URL`)
+italic(`Override OpenAI Base URL`)

util.ts (1)

42-44: Avoid exporting from a test file by separating tests into a dedicated file

Static analysis indicates that exports are present in a test file, which is discouraged. Consider moving the test cases to a separate file to adhere to best practices.

Steps to refactor:

1. Create a new file named util.test.ts for the test cases.
2. Move all the Deno.test blocks from util.ts to util.test.ts.
3. Ensure the imports in util.test.ts are updated accordingly.
4. Keep the utility functions and exports in util.ts.

This separation enhances code organization and maintainability.

🧰 Tools

🪛 Biome (1.9.4)

[error] 43-44: Do not export from a test file.

(lint/suspicious/noExportsInTest)

Configuration used: CodeRabbit UI
Review profile: CHILL

proxy.ts (5)

Line range hint 1-30: LGTM! Consider adding TypeScript interfaces for better type safety.

The class structure is well-organized with proper encapsulation and documentation. However, consider defining interfaces for the configuration and request/response types to improve type safety.

Add these type definitions at the beginning of the file:

interface ProxyConfig {
  openAIEndpoint: string;
  ollamaEndpoint: string;
  OPENAI_API_KEY?: string;
}

interface OllamaModel {
  name: string;
  // add other relevant fields
}

🧰 Tools

🪛 Biome (1.9.4)

[error] 37-37: void is confusing inside a union type.

Unsafe fix: Use undefined instead.

(lint/suspicious/noConfusingVoidType)

---

110-137: Enhance error handling in POST request processing.

While the request handling is good, consider adding try-catch blocks and more specific error responses.

Apply this improvement:

 private async handlePostRequest(c: any): Promise<Response> {
+  try {
     const json = await c.req.raw.clone().json();
     assert(json, is.ObjectOf({ model: is.String }));
     const endpoint = chooseEndpoint({
       model: json.model,
       ollamaEndpoint: this.ollamaEndpoint,
       openAIEndpoint: this.openAIEndpoint,
     });

     let res = await this.handleOpenAIModelVerify(c, json);
     if (res) {
       return res;
     }

     const origin = new URL(this.ollamaEndpoint).origin;
     const url = convertToCustomEndpoint(c.req.url, parseURL(endpoint));
     const reqHeaders = this.setCORSHeaders(c.req.raw, origin);
     reqHeaders.set('Origin', origin);
     const req = new Request(url, {
       ...c.req.raw,
       method: "POST",
       body: JSON.stringify(json),
       headers: reqHeaders,
       mode: 'no-cors'
     });
     return fetch(req);
+  } catch (error) {
+    console.error('Error processing POST request:', error);
+    return new Response(
+      JSON.stringify({ error: 'Failed to process request' }),
+      {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' }
+      }
+    );
+  }
 }

---

65-72: Add type definitions for CORS configuration.

Consider adding type definitions for CORS configuration to make the code more maintainable.

Add these types:

interface CORSConfig {
  allowedOrigins: string | string[];
  allowedMethods: string[];
  allowedHeaders: string[];
  allowCredentials: boolean;
}

Then use them in the method:

-  private setCORSHeaders(res: Response, origin: string): Headers {
+  private setCORSHeaders(res: Response, origin: string, config?: Partial<CORSConfig>): Headers {
     const headers = new Headers(res.headers);
-    headers.set('Access-Control-Allow-Origin', origin || '*');
+    headers.set('Access-Control-Allow-Origin', origin || config?.allowedOrigins || '*');
     // ... rest of the method
   }

---

74-78: Translate Chinese comments to English for consistency.

The codebase appears to be primarily in English, but these comments are in Chinese. Consider translating them for better maintainability.

Replace with:

-  /**
-   * 处理验证请求的模型
-   * @param c 
-   * @param json 
-   * @returns 
-   */
+  /**
+   * Handles model verification requests
+   * @param c - The context object
+   * @param json - The request body
+   * @returns Response or null if verification succeeds
+   */

---

37-37: Replace void with undefined in union type.

Using void in a union type can be confusing. Consider using undefined instead for better type clarity.

-  private handleAllRequest(c: any, next: () => Promise<any>): Response | Promise<void | Response> {
+  private handleAllRequest(c: any, next: () => Promise<any>): Response | Promise<undefined | Response> {

🧰 Tools

🪛 Biome (1.9.4)

[error] 37-37: void is confusing inside a union type.

Unsafe fix: Use undefined instead.

(lint/suspicious/noConfusingVoidType)

Configuration used: CodeRabbit UI
Review profile: CHILL

proxy.ts (3)

37-37: Consider refining the return type signature

The return type Response | Promise<void | Response> could be simplified to Promise<Response | undefined> for better type clarity.

-  private handleAllRequest(c: any, next: () => Promise<any>): Response | Promise<void | Response> {
+  private handleAllRequest(c: any, next: () => Promise<any>): Promise<Response | undefined> {

🧰 Tools

🪛 Biome (1.9.4)

[error] 37-37: void is confusing inside a union type.

Unsafe fix: Use undefined instead.

(lint/suspicious/noConfusingVoidType)

---

96-100: Translate comments to English for consistency

The Chinese comment should be translated to English to maintain documentation consistency.

-   * 验证是否是Cursor的请求
+   * Verifies if this is a Cursor request

---

79-94: Enhance error handling with more specific messages

The error handling could be more informative by including additional context about why the model wasn't found.

-        console.error(`Ollama Model not found: ${json.model}`);
-        return new Response(JSON.stringify({ error: "Model not found" }), {
+        const errorMessage = `Model '${json.model}' not found in available models: ${models.map((m: any) => m.name).join(', ')}`;
+        console.error(errorMessage);
+        return new Response(JSON.stringify({ error: errorMessage }), {

Configuration used: CodeRabbit UI
Review profile: CHILL