OmniRoute/tests/unit/translator-openai-to-gemini.test.ts

import test from "node:test";
import assert from "node:assert/strict";

const { openaiToAntigravityRequest, openaiToGeminiCLIRequest, openaiToGeminiRequest } =
  await import("../../open-sse/translator/request/openai-to-gemini.ts");
const { getRequestTranslator } = await import("../../open-sse/translator/registry.ts");
const { FORMATS } = await import("../../open-sse/translator/formats.ts");
const {
  DEFAULT_SAFETY_SETTINGS,
  cleanJSONSchemaForAntigravity,
  convertOpenAIContentToParts,
  generateRequestId,
  generateSessionId,
  tryParseJSON,
} = await import("../../open-sse/translator/helpers/geminiHelper.ts");
const { ANTIGRAVITY_DEFAULT_SYSTEM } = await import("../../open-sse/config/constants.ts");

type UnknownRecord = Record<string, unknown>;

function getFunctionCall(part: unknown) {
  assert.ok(part && typeof part === "object", "expected Gemini functionCall part");
  const functionCall = (part as UnknownRecord).functionCall;
  assert.ok(functionCall && typeof functionCall === "object", "expected functionCall payload");
  return functionCall as { id?: string; name: string; args?: unknown };
}

function getFunctionResponse(part: unknown) {
  assert.ok(part && typeof part === "object", "expected Gemini functionResponse part");
  const functionResponse = (part as UnknownRecord).functionResponse;
  assert.ok(
    functionResponse && typeof functionResponse === "object",
    "expected functionResponse payload"
  );
  return functionResponse as { id?: string; name: string; response?: unknown };
}

function getFunctionDeclarationParameters(parameters: unknown) {
  assert.ok(
    parameters && typeof parameters === "object",
    "expected function declaration parameters"
  );
  return parameters as UnknownRecord & {
    properties?: Record<string, UnknownRecord>;
    examples?: unknown;
    $schema?: unknown;
  };
}

test("OpenAI -> Gemini helper converts text, images and files into Gemini parts", () => {
  // Suppress warn emitted for the remote https://example.com/skip.png URL in the
  // fixture below — that warn is expected and tested separately. Suppressing here
  // keeps stderr clean so CI does not flag spurious output.
  const originalWarn = console.warn;
  console.warn = () => {};
  try {
    const parts = convertOpenAIContentToParts([
      { type: "text", text: "Hello" },
      { type: "image_url", image_url: { url: "data:image/png;base64,abc" } },
      { type: "file_url", file_url: { url: "data:application/pdf;base64,Zm9v" } },
      { type: "document", document: { url: "data:text/plain;base64,YmFy" } },
      { type: "image_url", image_url: { url: "https://example.com/skip.png" } },
      { type: "file_url", file_url: { url: "not-a-data-url" } },
    ]);

    assert.deepEqual(parts, [
      { text: "Hello" },
      { inlineData: { mimeType: "image/png", data: "abc" } },
      { inlineData: { mimeType: "application/pdf", data: "Zm9v" } },
      { inlineData: { mimeType: "text/plain", data: "YmFy" } },
    ]);
    assert.deepEqual(convertOpenAIContentToParts("raw text"), [{ text: "raw text" }]);
  } finally {
    console.warn = originalWarn;
  }
});

test("OpenAI -> Gemini helper cleans complex JSON Schema structures for Gemini compatibility", () => {
  const cleaned = cleanJSONSchemaForAntigravity({
    type: "object",
    title: "Root schema",
    properties: {
      mode: { const: "fast" },
      retries: { type: "integer", enum: [1, 2, 3] },
      payload: {
        anyOf: [
          { type: "null" },
          {
            type: "object",
            properties: {
              id: { type: ["string", "null"], minLength: 1 },
              nested: {
                allOf: [
                  {
                    properties: {
                      a: { type: "string" },
                    },
                    required: ["a"],
                  },
                  {
                    properties: {
                      b: { type: "number" },
                    },
                    required: ["missing", "b"],
                  },
                ],
              },
            },
            required: ["id", "missing"],
          },
        ],
      },
      emptyObject: {
        type: "object",
        additionalProperties: false,
      },
    },
    required: ["mode", "payload", "missingRoot"],
  });

  assert.equal(cleaned.properties.mode.type, "string");
  assert.deepEqual(cleaned.properties.mode.enum, ["fast"]);
  assert.equal(cleaned.properties.retries.enum, undefined);
  assert.equal(cleaned.properties.payload.type, "object");
  assert.equal(cleaned.properties.payload.properties.id.type, "string");
  assert.equal("minLength" in cleaned.properties.payload.properties.id, false);
  assert.deepEqual(cleaned.properties.payload.required, ["id"]);
  assert.deepEqual(cleaned.properties.payload.properties.nested.required.sort(), ["a", "b"]);
  assert.deepEqual(cleaned.required.sort(), ["mode", "payload"]);
  assert.deepEqual(cleaned.properties.emptyObject.required, ["reason"]);
  assert.equal(cleaned.properties.emptyObject.properties.reason.type, "string");
});

test("OpenAI -> Gemini helper inlines local refs and preserves only additionalProperties=true", () => {
  const cleaned = cleanJSONSchemaForAntigravity({
    type: "object",
    $defs: {
      Address: {
        type: "object",
        properties: {
          street: { type: "string", minLength: 1 },
        },
        required: ["street"],
        additionalProperties: false,
      },
    },
    properties: {
      shipping: { $ref: "#/$defs/Address" },
      metadata: {
        type: "object",
        additionalProperties: true,
      },
      options: {
        type: "object",
        additionalProperties: { type: "string" },
      },
    },
    required: ["shipping"],
  });

  assert.equal(cleaned.$defs, undefined);
  assert.equal(cleaned.properties.shipping.$ref, undefined);
  assert.equal(cleaned.properties.shipping.properties.street.type, "string");
  assert.equal(cleaned.properties.shipping.properties.street.minLength, undefined);
  assert.deepEqual(cleaned.properties.shipping.required, ["street"]);
  assert.equal(cleaned.properties.shipping.additionalProperties, undefined);
  assert.equal(cleaned.properties.metadata.additionalProperties, undefined);
  assert.equal(cleaned.properties.options.additionalProperties, undefined);
});

test("OpenAI -> Gemini request maps messages, merged system instructions, tools and response schema", () => {
  const result = openaiToGeminiRequest(
    "gemini-2.5-pro",
    {
      messages: [
        { role: "system", content: "Rule A" },
        { role: "system", content: [{ type: "text", text: "Rule B" }] },
        {
          role: "user",
          content: [
            { type: "text", text: "What is the weather?" },
            { type: "image_url", image_url: { url: "data:image/png;base64,abc" } },
          ],
        },
        {
          role: "assistant",
          reasoning_content: "Need live data",
          content: "Calling a tool",
          tool_calls: [
            {
              id: "call_1",
              type: "function",
              function: { name: "weather", arguments: '{"city":"Tokyo"}' },
            },
          ],
        },
        {
          role: "tool",
          tool_call_id: "call_1",
          content: '{"temp":20}',
        },
      ],
      tools: [
        {
          type: "function",
          function: {
            name: "weather",
            description: "Fetch weather",
            parameters: {
              type: "object",
              properties: {
                city: { type: ["string", "null"] },
              },
              required: ["city"],
            },
          },
        },
      ],
      max_completion_tokens: 2222,
      temperature: 0.3,
      top_p: 0.9,
      stop: ["DONE"],
      response_format: {
        type: "json_schema",
        json_schema: {
          schema: {
            type: "object",
            properties: {
              answer: { const: "ok" },
            },
            required: ["answer"],
          },
        },
      },
    },
    false
  );

  assert.equal((result as any).systemInstruction.role, "system");
  assert.deepEqual((result as any).systemInstruction.parts, [
    { text: "Rule A" },
    { text: "Rule B" },
  ]);
  assert.equal(result.contents[0].role, "user");
  assert.deepEqual(result.contents[0].parts, [
    { text: "What is the weather?" },
    { inlineData: { mimeType: "image/png", data: "abc" } },
  ]);

  const modelTurn = result.contents.find(
    (content) => content.role === "model" && content.parts.some((part) => part.functionCall)
  );
  assert.ok(modelTurn, "expected a model turn with functionCall");
  const modelTurnThought = modelTurn.parts[0] as { thought?: boolean; text?: string };
  const modelTurnFunctionCall = getFunctionCall(modelTurn.parts[2]);
  assert.equal(modelTurn.parts[0].thought, true);
  assert.equal(modelTurnThought.text, "Need live data");
  assert.equal(modelTurn.parts[1].text, "Calling a tool");
  assert.equal(modelTurnFunctionCall.name, "weather");
  assert.deepEqual(modelTurnFunctionCall.args, { city: "Tokyo" });

  const toolResponseTurn = result.contents.find(
    (content) => content.role === "user" && content.parts.some((part) => part.functionResponse)
  );
  assert.ok(toolResponseTurn, "expected a tool response turn");
  assert.deepEqual(getFunctionResponse(toolResponseTurn.parts[0]), {
    id: "call_1",
    name: "weather",
    response: { result: { temp: 20 } },
  });

  assert.equal((result as any).generationConfig.maxOutputTokens, 2222);
  assert.equal((result as any).generationConfig.temperature, 0.3);
  assert.equal((result as any).generationConfig.topP, 0.9);
  assert.deepEqual((result as any).generationConfig.stopSequences, ["DONE"]);
  assert.equal((result as any).generationConfig.responseMimeType, "application/json");
  const responseSchema = (result as any).generationConfig.responseSchema as {
    properties: { answer: { type: string; enum?: string[] } };
  };
  assert.equal(responseSchema.properties.answer.type, "string");
  assert.deepEqual(responseSchema.properties.answer.enum, ["ok"]);
  const parameters = getFunctionDeclarationParameters(
    (result as any).tools[0].functionDeclarations[0].parameters
  );
  assert.deepEqual(parameters, {
    type: "object",
    properties: {
      city: { type: "string" },
    },
    required: ["city"],
  });
  assert.deepEqual(result.safetySettings, DEFAULT_SAFETY_SETTINGS);
});

test("OpenAI -> Gemini request preserves custom safety settings and handles system-only requests", () => {
  const customSafety = [{ category: "HARM_CATEGORY_HATE_SPEECH", threshold: "BLOCK_ONLY_HIGH" }];

  const result = openaiToGeminiRequest(
    "gemini-2.5-flash",
    {
      messages: [{ role: "system", content: "Only rules" }],
      safetySettings: customSafety,
    },
    false
  );

  assert.deepEqual(result.safetySettings, customSafety);
  assert.equal((result as any).systemInstruction, undefined);
  assert.equal(result.contents.length, 1);
  assert.equal(result.contents[0].role, "user");
  assert.deepEqual(result.contents[0].parts, [{ text: "Only rules" }]);
});

test("OpenAI -> Gemini CLI adds thinking config and normalizes namespaced tool names", () => {
  const result = openaiToGeminiCLIRequest(
    "gemini-2.5-pro",
    {
      messages: [
        { role: "user", content: "Check weather" },
        {
          role: "assistant",
          tool_calls: [
            {
              id: "call_1",
              type: "function",
              function: { name: "ns:weather", arguments: '{"city":"Tokyo"}' },
            },
          ],
        },
        {
          role: "tool",
          tool_call_id: "call_1",
          content: '{"temp":20}',
        },
      ],
      tools: [
        {
          type: "function",
          function: {
            name: "ns:weather",
            parameters: { type: "object", properties: {} },
          },
        },
      ],
      reasoning_effort: "high",
    },
    false
  );

  assert.equal((result as any).generationConfig.thinkingConfig.includeThoughts, true);
  assert.ok((result as any).generationConfig.thinkingConfig.thinkingBudget > 0);
  assert.equal((result as any).tools[0].functionDeclarations[0].name, "weather");
  assert.equal((result as any)._toolNameMap.get("weather"), "ns:weather");

  const modelTurn = result.contents.find((content) => content.role === "model");
  assert.ok(modelTurn, "expected a model turn");
  assert.equal(getFunctionCall(modelTurn.parts[0]).name, "weather");

  const responseTurn = result.contents.find(
    (content) => content.role === "user" && content.parts.some((part) => part.functionResponse)
  );
  assert.ok(responseTurn, "expected a function response turn");
  assert.equal(getFunctionResponse(responseTurn.parts[0]).name, "weather");
});

test("OpenAI -> Gemini CLI wraps Cloud Code envelope with native top-level and request keys", async () => {
  const { getRequestTranslator } = await import("../../open-sse/translator/registry.ts");
  const { FORMATS } = await import("../../open-sse/translator/formats.ts");
  await import("../../open-sse/translator/request/openai-to-gemini.ts");

  const translate = getRequestTranslator(FORMATS.OPENAI, FORMATS.GEMINI_CLI);
  assert.ok(translate, "expected Gemini CLI translator to be registered");

  const result = translate(
    "models/gemini-2.5-flash",
    { messages: [{ role: "user", content: "Hello" }] },
    true,
    { projectId: "projects/demo" }
  ) as UnknownRecord;
  const request = result.request as UnknownRecord;

  assert.deepEqual(Object.keys(result), ["model", "project", "user_prompt_id", "request"]);
  assert.equal(result.model, "gemini-2.5-flash");
  assert.equal(result.project, "projects/demo");
  assert.equal(typeof result.user_prompt_id, "string");
  assert.equal(result.userAgent, undefined);
  assert.equal(result.requestId, undefined);
  assert.equal(result.requestType, undefined);
  assert.equal(typeof request.session_id, "string");
  assert.equal(request.sessionId, undefined);
  assert.ok(Array.isArray(request.contents));
});

test("OpenAI -> Gemini request sanitizes long MCP tool names and strips unsupported schema fields", () => {
  const longToolName =
    "mcp__filesystem__read_multiple_files_with_validation_and_metadata_bundle_v2";
  const result = openaiToGeminiRequest(
    "gemini-2.5-pro",
    {
      messages: [
        { role: "user", content: "Read the file set" },
        {
          role: "assistant",
          tool_calls: [
            {
              id: "call_long_1",
              type: "function",
              function: { name: longToolName, arguments: '{"paths":["/tmp/a","/tmp/b"]}' },
            },
          ],
        },
        {
          role: "tool",
          tool_call_id: "call_long_1",
          content: '{"ok":true}',
        },
      ],
      tools: [
        {
          type: "function",
          function: {
            name: longToolName,
            parameters: {
              type: "object",
              $schema: "http://json-schema.org/draft-07/schema#",
              examples: [{ paths: ["/tmp/a"] }],
              properties: {
                paths: {
                  type: "array",
                  items: { type: "string", "x-ui": "hidden" },
                },
              },
            },
          },
        },
      ],
    },
    false
  );

  const sanitizedToolName = (result as any).tools[0].functionDeclarations[0].name;
  assert.ok(longToolName.length > 64);
  assert.equal(sanitizedToolName.length, 64);
  assert.match(sanitizedToolName, /_[a-f0-9]{8}$/);
  assert.equal((result as any)._toolNameMap.get(sanitizedToolName), longToolName);

  const modelTurn = result.contents.find((content) => content.role === "model");
  assert.ok(modelTurn, "expected a model turn");
  assert.equal(getFunctionCall(modelTurn.parts[0]).name, sanitizedToolName);

  const toolTurn = result.contents.find(
    (content) => content.role === "user" && content.parts.some((part) => part.functionResponse)
  );
  assert.ok(toolTurn, "expected a tool response turn");
  assert.equal(getFunctionResponse(toolTurn.parts[0]).name, sanitizedToolName);
  const longToolParameters = getFunctionDeclarationParameters(
    (result as any).tools[0].functionDeclarations[0].parameters
  ) as UnknownRecord & {
    properties?: {
      paths?: {
        items?: UnknownRecord;
      };
    };
  };
  assert.equal(longToolParameters.$schema, undefined);
  assert.equal(longToolParameters.examples, undefined);
  assert.equal(longToolParameters.properties?.paths?.items?.["x-ui"], undefined);
});

test("OpenAI -> Gemini request gives googleSearch precedence over function tools", () => {
  const result = openaiToGeminiRequest(
    "gemini-2.5-pro",
    {
      messages: [{ role: "user", content: "Search the web" }],
      tools: [
        {
          type: "function",
          function: {
            name: "weather",
            description: "Fetch weather",
            parameters: { type: "object", properties: {} },
          },
        },
        { type: "web_search" },
      ],
    },
    false
  );

  assert.deepEqual((result as any).tools, [{ googleSearch: {} }]);
});

test("OpenAI -> Antigravity keeps googleSearch without function calling config", () => {
  const result = openaiToAntigravityRequest(
    "gemini-2.5-pro",
    {
      messages: [{ role: "user", content: "Search the web" }],
      tools: [
        {
          type: "function",
          function: {
            name: "weather",
            parameters: { type: "object", properties: {} },
          },
        },
        { type: "web_search_preview" },
      ],
    },
    false,
    { projectId: "proj-search" } as any
  );

  assert.deepEqual((result as any).request?.tools, [{ googleSearch: {} }]);
  assert.equal(result.request.toolConfig, undefined);
});

test("OpenAI -> Gemini helper IDs and JSON parsing stay in the expected format", () => {
  assert.match(generateRequestId(), /^agent-/);
  assert.match(generateSessionId(), /^-\d+$/);
  assert.deepEqual(tryParseJSON('{"ok":true}'), { ok: true });
  assert.equal(tryParseJSON("not-json"), null as any);
});

test("OpenAI -> Gemini CLI wraps requests like native Cloud Code", () => {
  const translate = getRequestTranslator(FORMATS.OPENAI, FORMATS.GEMINI_CLI);
  assert.ok(translate, "expected Gemini CLI translator registration");

  const envelope = translate(
    "gemini-3-flash-preview",
    {
      messages: [{ role: "user", content: "Hello" }],
      reasoning_effort: "high",
    },
    true,
    { projectId: "project-1" }
  ) as any;

  assert.equal(envelope.model, "gemini-3-flash-preview");
  assert.equal(envelope.userAgent, undefined);
  assert.equal(envelope.requestId, undefined);
  assert.equal(envelope.request.sessionId, undefined);
  assert.match(envelope.request.session_id, /^[0-9a-f-]{36}$/i);
  assert.equal(envelope.user_prompt_id, envelope.request.session_id);
});

test("OpenAI -> Gemini CLI emits native Cloud Code functionResponse output", () => {
  const translate = getRequestTranslator(FORMATS.OPENAI, FORMATS.GEMINI_CLI);
  assert.ok(translate, "expected Gemini CLI translator registration");

  const envelope = translate(
    "gemini-3-flash-preview",
    {
      messages: [
        { role: "user", content: "Read fixture" },
        {
          role: "assistant",
          tool_calls: [
            {
              id: "read_file_123_0",
              type: "function",
              function: { name: "read_file", arguments: '{"file_path":"fixture.txt"}' },
            },
          ],
        },
        {
          role: "tool",
          tool_call_id: "read_file_123_0",
          content: "The answer is capybara-4729.",
        },
      ],
    },
    true,
    { projectId: "project-1" }
  ) as any;

  const toolTurn = envelope.request.contents.find(
    (content) => content.role === "user" && content.parts.some((part) => part.functionResponse)
  );
  assert.ok(toolTurn, "expected Gemini CLI tool response turn");
  assert.deepEqual(getFunctionResponse(toolTurn.parts[0]), {
    id: "read_file_123_0",
    name: "read_file",
    response: { output: "The answer is capybara-4729." },
  });
});

test("OpenAI -> Antigravity wraps Gemini requests in a Cloud Code envelope", () => {
  const result = openaiToAntigravityRequest(
    "gemini-2.5-pro",
    {
      messages: [{ role: "user", content: "Hello" }],
      tools: [
        {
          type: "function",
          function: {
            name: "weather",
            parameters: { type: "object", properties: {} },
          },
        },
      ],
      reasoning_effort: "medium",
    },
    false,
    { projectId: "proj-1" } as any
  );

  assert.equal(result.project, "proj-1");
  assert.deepEqual(Object.keys(result), [
    "project",
    "requestId",
    "request",
    "model",
    "userAgent",
    "requestType",
    "enabledCreditTypes",
  ]);
  assert.equal(result.userAgent, "antigravity");
  assert.equal(result.requestType, "agent");
  assert.match(result.requestId, /^agent\/\d+\/[0-9a-f]{8}$/);
  assert.match(result.request.sessionId, /^-?\d+$/);
  assert.deepEqual(result.enabledCreditTypes, ["GOOGLE_ONE_AI"]);
  assert.equal(result.request.generationConfig.topK, 40);
  assert.equal(result.request.generationConfig.topP, 1.0);
  assert.equal(
    (result as any).request?.systemInstruction.parts[0].text,
    ANTIGRAVITY_DEFAULT_SYSTEM
  );
  assert.deepEqual(result.request.toolConfig, {
    functionCallingConfig: { mode: "VALIDATED" },
  });
});

test("OpenAI -> Antigravity Gemini preserves signature-less historical tool calls as inert text", () => {
  const result = openaiToAntigravityRequest(
    "gemini-3.5-flash-low",
    {
      messages: [
        { role: "user", content: "Update todo" },
        {
          role: "assistant",
          tool_calls: [
            {
              id: "call_synthetic_1",
              type: "function",
              function: { name: "default_api:todowrite_ide", arguments: '{"todos":[]}' },
            },
          ],
        },
        {
          role: "tool",
          tool_call_id: "call_synthetic_1",
          content: "[]",
        },
      ],
      tools: [
        {
          type: "function",
          function: {
            name: "default_api:todowrite_ide",
            parameters: { type: "object", properties: {} },
          },
        },
      ],
    },
    false,
    { projectId: "proj-antigravity-gemini" } as any
  );

  const modelTurn = result.request.contents.find((content) => content.role === "model");
  assert.ok(modelTurn, "expected a model turn");
  assert.ok(
    modelTurn.parts.some(
      (part) =>
        typeof part.text === "string" &&
        part.text.includes("Historical tool-call record only") &&
        part.text.includes("Tool name: default_api:todowrite_ide") &&
        part.text.includes('Tool arguments JSON: {"todos":[]}')
    ),
    "expected signature-less tool call to be preserved as inert text"
  );
  assert.equal(
    modelTurn.parts.some(
      (part) => typeof part.text === "string" && part.text.includes("[Tool call:")
    ),
    false,
    "signature-less historical call must not use executable textual tool-call markers"
  );
  assert.equal(
    modelTurn.parts.some((part) => part.functionCall),
    false,
    "signature-less historical call must not be emitted as native functionCall"
  );

  const toolTurn = result.request.contents.find(
    (content) =>
      content.role === "user" &&
      content.parts.some(
        (part) =>
          typeof part.text === "string" &&
          part.text.includes("Historical tool-response record only") &&
          part.text.includes("Tool name: default_api:todowrite_ide") &&
          part.text.includes("Tool result: []")
      )
  );
  assert.ok(toolTurn, "expected signature-less tool response to be preserved as inert text");
  assert.equal(
    toolTurn.parts.some(
      (part) => typeof part.text === "string" && part.text.includes("[Tool response:")
    ),
    false,
    "signature-less historical response must not use executable textual tool-response markers"
  );
  assert.equal(
    toolTurn.parts.some((part) => part.functionResponse),
    false,
    "signature-less historical response must not be emitted as native functionResponse"
  );
});

test("OpenAI -> Antigravity preserves multiple signature-less historical tool responses as text", () => {
  const result = openaiToAntigravityRequest(
    "gemini-3.5-flash-low",
    {
      messages: [
        { role: "user", content: "Inspect OmniRoute config" },
        {
          role: "assistant",
          tool_calls: [
            {
              id: "call_missing_db",
              type: "function",
              function: { name: "terminal", arguments: '{"command":"cat data/db.json"}' },
            },
            {
              id: "call_list_dir",
              type: "function",
              function: { name: "terminal", arguments: '{"command":"ls ~/.omniroute"}' },
            },
          ],
        },
        { role: "tool", tool_call_id: "call_missing_db", content: "data/db.json: No such file" },
        { role: "tool", tool_call_id: "call_list_dir", content: "storage.sqlite" },
      ],
      tools: [
        {
          type: "function",
          function: {
            name: "terminal",
            parameters: { type: "object", properties: {} },
          },
        },
      ],
    },
    false,
    { projectId: "proj-antigravity-gemini" } as any
  );

  const text = JSON.stringify(result.request.contents);
  assert.ok(text.includes("Historical tool-call record only"), "expected signature-less calls as text");
  assert.ok(text.includes("Tool name: terminal"), "expected signature-less calls as text");
  assert.ok(
    text.includes("data/db.json: No such file"),
    "expected first signature-less tool response as text"
  );
  assert.ok(
    text.includes("storage.sqlite"),
    "expected second signature-less tool response as text"
  );
  assert.equal(
    result.request.contents.some((content) => content.parts.some((part) => part.functionResponse)),
    false,
    "signature-less historical responses must not be emitted as native functionResponse"
  );
});

test("OpenAI -> Antigravity maps Claude-family models to Gemini-compatible schema", () => {
  const result = openaiToAntigravityRequest(
    "claude-3-7-sonnet",
    {
      messages: [
        { role: "system", content: "Project rules" },
        { role: "user", content: "Read a file" },
        {
          role: "assistant",
          tool_calls: [
            {
              id: "call_1",
              type: "function",
              function: { name: "read_file", arguments: '{"path":"/tmp/demo"}' },
            },
          ],
        },
        {
          role: "tool",
          tool_call_id: "call_1",
          content: '{"ok":true}',
        },
      ],
      tools: [
        {
          type: "function",
          function: {
            name: "read_file",
            parameters: {
              type: "object",
              properties: { path: { type: "string" } },
              required: ["path"],
            },
          },
        },
      ],
    },
    false,
    { projectId: "proj-claude" } as any
  );

  assert.equal(result.project, "proj-claude");
  assert.equal(result.userAgent, "antigravity");
  assert.match(result.requestId, /^agent\/\d+\/[0-9a-f]{8}$/);
  assert.deepEqual((result as any).enabledCreditTypes, ["GOOGLE_ONE_AI"]);
  assert.equal(result.request.systemInstruction.parts[0].text, ANTIGRAVITY_DEFAULT_SYSTEM);
  assert.equal(result.request.systemInstruction.parts[1].text, "Project rules");
  assert.equal((result as any).request?.generationConfig.maxOutputTokens, undefined);
  assert.equal((result as any).request?.messages, undefined);
  assert.equal((result as any).request?.system, undefined);
  assert.equal((result as any).request?.max_tokens, undefined);
  assert.equal((result as any).request?.stream, undefined);

  const modelTurn = result.request.contents.find(
    (content) => content.role === "model" && content.parts.some((part) => part.functionCall)
  );
  assert.ok(modelTurn, "expected a Gemini-compatible model turn");
  const bridgeFunctionCall = getFunctionCall(modelTurn.parts[0]);
  assert.equal(bridgeFunctionCall.name, "read_file");
  assert.deepEqual(bridgeFunctionCall.args, { path: "/tmp/demo" });

  const toolTurn = result.request.contents.find(
    (content) => content.role === "user" && content.parts.some((part) => part.functionResponse)
  );
  assert.ok(toolTurn, "expected a Gemini-compatible tool response turn");
  const toolResultBlock = getFunctionResponse(toolTurn.parts[0]);
  assert.equal(toolResultBlock.id, "call_1");
  assert.equal((result as any).request?.tools[0].functionDeclarations[0].name, "read_file");
});

test("OpenAI -> Antigravity Claude path sanitizes tool names for Gemini schema", () => {
  const longToolName =
    "ns:mcp__filesystem__read_multiple_files_with_validation_and_metadata_bundle";
  const result = openaiToAntigravityRequest(
    "claude-3-7-sonnet",
    {
      messages: [
        { role: "user", content: "Read a file" },
        {
          role: "assistant",
          tool_calls: [
            {
              id: "call_long_2",
              type: "function",
              function: { name: longToolName, arguments: '{"path":"/tmp/demo"}' },
            },
          ],
        },
        {
          role: "tool",
          tool_call_id: "call_long_2",
          content: '{"ok":true}',
        },
      ],
      tools: [
        {
          type: "function",
          function: {
            name: longToolName,
            parameters: {
              type: "object",
              properties: { path: { type: "string", "x-ui": "hidden" } },
              required: ["path"],
            },
          },
        },
      ],
    },
    false,
    { projectId: "proj-claude-map" } as any
  );

  const sanitizedToolName = (result as any).request?.tools[0].functionDeclarations[0].name;
  assert.notEqual(sanitizedToolName, longToolName);
  assert.match(
    sanitizedToolName,
    /^mcp_filesystem_read_multiple_files_with_validation_and__\w{8}$/
  );

  const modelTurn = result.request.contents.find(
    (content) => content.role === "model" && content.parts.some((part) => part.functionCall)
  );
  assert.ok(modelTurn, "expected a model turn");
  const toolUseBlock = getFunctionCall(modelTurn.parts[0]);
  assert.equal(toolUseBlock.name, sanitizedToolName);

  const toolTurn = result.request.contents.find(
    (content) => content.role === "user" && content.parts.some((part) => part.functionResponse)
  );
  assert.ok(toolTurn, "expected a tool response turn");
  const toolResultBlock = getFunctionResponse(toolTurn.parts[0]);
  assert.equal(toolResultBlock.id, "call_long_2");
  assert.equal(toolResultBlock.name, sanitizedToolName);
  assert.deepEqual(toolResultBlock.response, { result: { ok: true } });
});

test("OpenAI -> Antigravity Claude path applies output cap and strips thinkingConfig", () => {
  // For Claude on Antigravity, applyAntigravityGenerationDefaults must bump
  // maxOutputTokens to thinkingBudget+1 BEFORE the envelope strips thinkingConfig
  // (because Claude on Cloud Code does not understand Gemini's thinkingConfig
  // shape but still benefits from the larger output cap derived from it).
  const result = openaiToAntigravityRequest(
    "claude-3-7-sonnet",
    {
      messages: [{ role: "user", content: "Summarize this" }],
      max_completion_tokens: 32000,
      reasoning_effort: "high",
    },
    false,
    { projectId: "proj-claude-thinking" } as any
  );

  assert.equal((result as any).request?.generationConfig.maxOutputTokens, 32769);
  // thinkingConfig must be stripped for Claude — Cloud Code Claude endpoint
  // does not understand the Gemini-shape thinkingConfig field.
  assert.equal((result as any).request?.generationConfig.thinkingConfig, undefined);
  assert.equal((result as any).request?.max_tokens, undefined);
  assert.equal((result as any).request?.thinking, undefined);
});

test("OpenAI -> Antigravity Claude path preserves lower requested output and strips thinkingConfig", () => {
  const result = openaiToAntigravityRequest(
    "claude-3-7-sonnet",
    {
      messages: [{ role: "user", content: "Short answer" }],
      max_completion_tokens: 1000,
      reasoning_effort: "high",
    },
    false,
    { projectId: "proj-claude-short" } as any
  );

  assert.equal((result as any).request?.generationConfig.maxOutputTokens, 32769);
  assert.equal((result as any).request?.generationConfig.thinkingConfig, undefined);
  assert.equal((result as any).request?.max_tokens, undefined);
  assert.equal((result as any).request?.thinking, undefined);
});

test("OpenAI -> Antigravity Gemini path preserves thinkingConfig (only Claude is stripped)", () => {
  // Negative-control for the Claude-thinkingConfig-strip behavior. Gemini models
  // on Antigravity must still receive thinkingConfig — only Claude needs it removed
  // (Cloud Code Claude endpoint does not understand the Gemini-shape field).
  const result = openaiToAntigravityRequest(
    "gemini-2.5-pro",
    {
      messages: [{ role: "user", content: "Summarize this" }],
      max_completion_tokens: 32000,
      reasoning_effort: "high",
    },
    false,
    { projectId: "proj-gemini-thinking" } as any
  );

  // For Gemini, thinkingConfig must remain in place because the Cloud Code
  // Gemini endpoint understands and uses it.
  assert.ok(
    (result as any).request?.generationConfig.thinkingConfig,
    "thinkingConfig must be preserved for Gemini models on Antigravity"
  );
  assert.equal((result as any).request?.generationConfig.thinkingConfig.thinkingBudget > 0, true);
  assert.equal((result as any).request?.generationConfig.thinkingConfig.includeThoughts, true);
});

// Regression for #2480: when projectId is stored in providerSpecificData rather than at
// the top level of the credential record, the Antigravity Cloud Code envelope must still
// pick it up — otherwise the /v1beta path 422s with "Missing Google projectId".
test("openaiToAntigravityRequest falls back to providerSpecificData.projectId (#2480)", () => {
  const result = openaiToAntigravityRequest(
    "gemini-3.1-flash-lite",
    { messages: [{ role: "user", content: "Hello" }] },
    false,
    { providerSpecificData: { projectId: "proj-from-psd" } } as any
  );
  assert.equal(result.project, "proj-from-psd");
});

test("openaiToAntigravityRequest prefers top-level projectId over providerSpecificData (#2480)", () => {
  const result = openaiToAntigravityRequest(
    "gemini-3.1-flash-lite",
    { messages: [{ role: "user", content: "Hello" }] },
    false,
    { projectId: "proj-top", providerSpecificData: { projectId: "proj-psd" } } as any
  );
  assert.equal(result.project, "proj-top");
});

// Regression for #2515: a PDF sent in the Responses-API `input_file` shape must reach
// Gemini as inlineData instead of being silently dropped.
test("convertOpenAIContentToParts handles input_file file_data (#2515)", () => {
  const parts = convertOpenAIContentToParts([
    { type: "input_file", file_data: "JVBERi0xLjcKJ", filename: "doc.pdf" },
  ]);
  const inline = parts.find((p) => (p as any).inlineData);
  assert.ok(inline, "input_file with file_data must produce an inlineData part");
  assert.equal((inline as any).inlineData.data, "JVBERi0xLjcKJ");
});

test("convertOpenAIContentToParts handles input_file file_url data URI (#2515)", () => {
  const parts = convertOpenAIContentToParts([
    { type: "input_file", file_url: "data:application/pdf;base64,QUJD", filename: "d.pdf" },
  ]);
  const inline = parts.find((p) => (p as any).inlineData);
  assert.ok(inline, "input_file with file_url data URI must produce an inlineData part");
  assert.equal((inline as any).inlineData.data, "QUJD");
  assert.equal((inline as any).inlineData.mimeType, "application/pdf");
});

test("convertOpenAIContentToParts handles rec.image with nested {url} as base64 data URI (#2807)", () => {
  const parts = convertOpenAIContentToParts([
    { type: "text", text: "What's this?" },
    { type: "image", image: { url: "data:image/png;base64,iVBORw0KGgo=" } },
  ]);
  const inline = parts.find((p) => (p as any).inlineData);
  assert.ok(
    inline,
    "rec.image with nested {url} must produce an inlineData part (was previously silently dropped)"
  );
  assert.equal((inline as any).inlineData.data, "iVBORw0KGgo=");
  assert.equal((inline as any).inlineData.mimeType, "image/png");
});

test("convertOpenAIContentToParts warns and drops remote http(s) URLs (#2807 - until async refactor)", () => {
  const originalWarn = console.warn;
  const warnings: string[] = [];
  console.warn = (...args: unknown[]) => {
    warnings.push(args.map(String).join(" "));
  };
  try {
    const parts = convertOpenAIContentToParts([
      { type: "image_url", image_url: { url: "https://example.com/cat.png" } },
    ]);
    const inline = parts.find((p) => (p as any).inlineData);
    assert.equal(
      inline,
      undefined,
      "remote URL still cannot be encoded into inlineData (sync function) - that's expected"
    );
    assert.ok(
      warnings.some((w) => /Dropped remote image URL/i.test(w) && /example\.com\/cat\.png/.test(w)),
      `expected a warning naming the dropped URL, got: ${JSON.stringify(warnings)}`
    );
  } finally {
    console.warn = originalWarn;
  }
});

test("convertOpenAIContentToParts warns and drops rec.image remote http(s) URLs (#2807)", () => {
  // rec.image is the alternative content shape emitted by MCP tool wrappers and
  // LangChain shim layers. Remote URLs in this shape must also hit the warn-and-drop
  // branch rather than being silently ignored.
  const originalWarn = console.warn;
  const warnings: string[] = [];
  console.warn = (...args: unknown[]) => {
    warnings.push(args.map(String).join(" "));
  };
  try {
    const parts = convertOpenAIContentToParts([
      { type: "image", image: { url: "https://example.com/remote.png" } },
    ]);
    const inline = parts.find((p) => (p as any).inlineData);
    assert.equal(
      inline,
      undefined,
      "rec.image remote URL must not produce an inlineData part (sync function cannot fetch)"
    );
    assert.ok(
      warnings.some(
        (w) => /Dropped remote image URL/i.test(w) && /example\.com\/remote\.png/.test(w)
      ),
      `expected a warning naming the dropped rec.image URL, got: ${JSON.stringify(warnings)}`
    );
  } finally {
    console.warn = originalWarn;
  }
});

// Regression for #2504: with credentials._signatureNamespace set, a previously-cached
// Gemini thoughtSignature must be re-attached to the functionCall on the follow-up turn.
test("openaiToGeminiRequest re-attaches cached thoughtSignature for FORMATS.GEMINI (#2504)", async () => {
  const { buildGeminiThoughtSignatureKey, storeGeminiThoughtSignature } =
    await import("../../open-sse/services/geminiThoughtSignatureStore.ts");
  const ns = "conn-2504";
  const toolId = "call_2504_abc";
  storeGeminiThoughtSignature(buildGeminiThoughtSignatureKey(ns, toolId), "SIG_2504_XYZ");

  const result: any = openaiToGeminiRequest(
    "gemini-2.5-pro-preview",
    {
      messages: [
        { role: "user", content: "run a tool" },
        {
          role: "assistant",
          tool_calls: [
            { id: toolId, type: "function", function: { name: "Bash", arguments: '{"cmd":"ls"}' } },
          ],
        },
        { role: "tool", tool_call_id: toolId, content: "ok" },
      ],
    },
    false,
    { _signatureNamespace: ns }
  );

  const json = JSON.stringify(result);
  assert.ok(
    json.includes("SIG_2504_XYZ"),
    "cached thoughtSignature must be re-attached to the functionCall"
  );
});
test("OpenAI -> Gemini request maps reasoning_effort to thinkingConfig", () => {
  const result = openaiToGeminiRequest(
    "gemini-2.0-flash-thinking",
    {
      messages: [{ role: "user", content: "Solve this complex puzzle" }],
      reasoning_effort: "high",
    },
    false
  );

  assert.ok((result as any).generationConfig.thinkingConfig, "expected thinkingConfig");
  assert.equal((result as any).generationConfig.thinkingConfig.includeThoughts, true);
  assert.equal((result as any).generationConfig.thinkingConfig.thinkingBudget, 32768);
});

test("OpenAI -> Gemini request maps google_search tool", () => {
  const result = openaiToGeminiRequest(
    "gemini-2.0-flash",
    {
      messages: [{ role: "user", content: "What happened today?" }],
      tools: [{ type: "function", function: { name: "google_search" } }],
    },
    false
  );

  assert.ok(Array.isArray((result as any).tools), "expected tools array");
  assert.ok(
    (result as any).tools.some((t: any) => t.googleSearch),
    "expected googleSearch tool"
  );
});