antigravity-proxy 0.1.1

package/tests/functional/models.test.ts

@@ -0,0 +1,100 @@
+import { expect, test, describe, beforeAll } from "bun:test";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const CONFIG_PATH = join(homedir(), ".config/opencode/opencode.json");
+
+function parseConfig(text: string) {
+  const cleaned = text.replace(/,(\s*[\]}])/g, "$1");
+  return JSON.parse(cleaned);
+}
+
+describe("Antigravity Proxy Functional Tests", () => {
+  let config: any;
+  let provider: any;
+  let baseURL: string;
+  let headers: Record<string, string>;
+  let modelIds: string[] = [];
+
+  beforeAll(() => {
+    if (!existsSync(CONFIG_PATH)) {
+      throw new Error(`Config file not found at ${CONFIG_PATH}`);
+    }
+
+    try {
+      const content = readFileSync(CONFIG_PATH, "utf8");
+      config = parseConfig(content);
+      provider = config.provider?.["antigravity-proxy"];
+      
+      if (!provider) {
+        throw new Error("Provider 'antigravity-proxy' not found in config");
+      }
+
+      baseURL = provider.options?.baseURL;
+      if (!baseURL) {
+        throw new Error("baseURL not defined in provider options");
+      }
+
+      headers = provider.options?.headers || {};
+      modelIds = Object.keys(provider.models || {});
+    } catch (e: any) {
+      throw new Error(`Failed to initialize test: ${e.message}`);
+    }
+  });
+
+  test("Config should have models defined", () => {
+    expect(modelIds.length).toBeGreaterThan(0);
+  });
+
+  test("Proxy should be reachable", async () => {
+    const response = await fetch(`${baseURL}/models`, {
+      headers: { ...headers }
+    });
+    expect(response.ok).toBe(true);
+  });
+
+  describe("Model Completions", () => {
+    test("All models should respond to a basic prompt", async () => {
+      console.log(`\n🚀 Testing ${modelIds.length} models...`);
+      
+      const results = await Promise.all(modelIds.map(async (modelId) => {
+        try {
+          const response = await fetch(`${baseURL}/chat/completions`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              ...headers
+            },
+            body: JSON.stringify({
+              model: modelId,
+              messages: [{ role: "user", content: "Say 'OK'" }],
+              max_tokens: 10,
+              stream: false
+            })
+          });
+
+          if (response.ok) {
+            const data = await response.json() as any;
+            return { modelId, success: true, status: response.status };
+          } else {
+            const error = await response.text();
+            return { modelId, success: false, status: response.status, error };
+          }
+        } catch (e: any) {
+          return { modelId, success: false, error: e.message };
+        }
+      }));
+
+      const failures = results.filter(r => !r.success);
+      if (failures.length > 0) {
+        console.error("Failures detected:");
+        failures.forEach(f => {
+          console.error(`- ${f.modelId}: ${f.error || 'Status ' + f.status}`);
+        });
+      }
+
+      expect(failures.length).toBe(0);
+    }, 120000);
+  });
+});

package/tests/unit/manager.test.ts

@@ -0,0 +1,13 @@
+import { expect, test, describe } from "bun:test";
+import { getFamilyName } from "../../src/auth/manager";
+
+describe("Manager Utils", () => {
+  test("getFamilyName should correctly classify models", () => {
+    expect(getFamilyName("gemini-1.5-flash")).toBe("Gemini 3 Flash");
+    expect(getFamilyName("gemini-1.5-pro")).toBe("Gemini 3 Pro");
+    expect(getFamilyName("claude-3-5-sonnet")).toBe("Claude/GPT");
+    expect(getFamilyName("gpt-4o")).toBe("Claude/GPT");
+    expect(getFamilyName("gemini-2.5-flash")).toBe("Gemini 2.5");
+    expect(getFamilyName("unknown-model")).toBe("Other");
+  });
+});

package/tests/unit/transform.test.ts

@@ -0,0 +1,135 @@
+
+import { describe, expect, test } from "bun:test";
+import { transformToGoogleBody, transformGoogleEventToOpenAI } from "../../src/utils/transform";
+
+describe("Unit Tests: transformToGoogleBody", () => {
+  test("Basic message transformation", () => {
+    const openaiBody = {
+      model: "gpt-4o",
+      messages: [
+        { role: "user", content: "Hello Gemini" }
+      ],
+      temperature: 0.5
+    };
+
+    const result = transformToGoogleBody(openaiBody, "test-project", false, "us-central1");
+
+    expect(result.project).toBe("test-project");
+    expect(result.model).toBe("gpt-4o"); // It passes through if no antigravity prefix
+    expect(result.request.contents).toHaveLength(1);
+    expect(result.request.contents[0].role).toBe("user");
+    expect(result.request.contents[0].parts[0].text).toBe("Hello Gemini");
+    expect(result.request.generationConfig.temperature).toBe(0.5);
+  });
+
+  test("Antigravity model prefix removal", () => {
+    const openaiBody = {
+      model: "antigravity-gemini-2.0-flash",
+      messages: [{ role: "user", content: "Hi" }]
+    };
+
+    const result = transformToGoogleBody(openaiBody, "p", false, "us-central1");
+    expect(result.model).toBe("gemini-2.0-flash");
+  });
+
+  test("Thinking level extraction for CLI", () => {
+    const openaiBody = {
+      model: "gemini-3-flash-thinking-medium",
+      messages: [{ role: "user", content: "Hi" }]
+    };
+
+    const result = transformToGoogleBody(openaiBody, "p", true, "us-central1"); // isCli = true
+    expect(result.model).toBe("gemini-3-flash-preview");
+    expect(result.request.generationConfig.thinkingConfig.thinkingLevel).toBe("medium");
+  });
+
+  test("Multi-turn conversation", () => {
+    const openaiBody = {
+      model: "gemini-1.5-pro",
+      messages: [
+        { role: "user", content: "Hello" },
+        { role: "assistant", content: "Hi there!" },
+        { role: "user", content: "How are you?" }
+      ]
+    };
+
+    const result = transformToGoogleBody(openaiBody, "p", false, "us-central1");
+    expect(result.request.contents).toHaveLength(3);
+    expect(result.request.contents[0].role).toBe("user");
+    expect(result.request.contents[1].role).toBe("model"); // OpenAI assistant -> Google model
+    expect(result.request.contents[2].role).toBe("user");
+  });
+
+  test("Tool transformation", () => {
+    const openaiBody = {
+      model: "gemini-1.5-pro",
+      messages: [{ role: "user", content: "Check weather" }],
+      tools: [
+        {
+          type: "function",
+          function: {
+            name: "get_weather",
+            description: "Get weather",
+            parameters: {
+              type: "object",
+              properties: {
+                location: { type: "string" }
+              },
+              required: ["location"]
+            }
+          }
+        }
+      ]
+    };
+
+    const result = transformToGoogleBody(openaiBody, "p", false, "us-central1");
+    expect(result.request.tools).toBeDefined();
+    expect(result.request.tools[0].functionDeclarations).toHaveLength(1);
+    expect(result.request.tools[0].functionDeclarations[0].name).toBe("get_weather");
+    expect(result.request.tools[0].functionDeclarations[0].parameters.properties.location).toBeDefined();
+  });
+});
+
+describe("Unit Tests: transformGoogleEventToOpenAI", () => {
+  test("Basic text response", () => {
+    const googleData = {
+      candidates: [{
+        content: {
+          parts: [{ text: "Hello world" }]
+        },
+        finishReason: "STOP"
+      }]
+    };
+
+    const result = transformGoogleEventToOpenAI(googleData, "gemini-1.5-pro", "req-123");
+    expect(result).not.toBeNull();
+    expect(result.choices[0].delta.content).toBe("Hello world");
+    expect(result.choices[0].finish_reason).toBe("stop");
+  });
+
+  test("Tool call response", () => {
+    const googleData = {
+      candidates: [{
+        content: {
+          parts: [{
+            functionCall: {
+              name: "get_weather",
+              args: { location: "London" }
+            }
+          }]
+        }
+      }]
+    };
+
+    const result = transformGoogleEventToOpenAI(googleData, "gemini-1.5-pro");
+    expect(result.choices[0].delta.tool_calls).toHaveLength(1);
+    expect(result.choices[0].delta.tool_calls[0].function.name).toBe("get_weather");
+    expect(JSON.parse(result.choices[0].delta.tool_calls[0].function.arguments).location).toBe("London");
+  });
+
+  test("Empty/Invalid response", () => {
+    const googleData = { candidates: [] };
+    const result = transformGoogleEventToOpenAI(googleData, "model");
+    expect(result).toBeNull();
+  });
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "module": "esnext",
+    "target": "esnext",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "jsx": "react-jsx",
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowJs": true,
+    "types": [
+      "bun-types" 
+    ]
+  }
+}