chore: import upstream snapshot with attribution

apps/sim/providers/google/index.ts

@@ -0,0 +1,42 @@
+import { GoogleGenAI } from '@google/genai'
+import { createLogger } from '@sim/logger'
+import type { StreamingExecution } from '@/executor/types'
+import { executeGeminiRequest } from '@/providers/gemini/core'
+import { getProviderDefaultModel, getProviderModels } from '@/providers/models'
+import type { ProviderConfig, ProviderRequest, ProviderResponse } from '@/providers/types'
+
+const logger = createLogger('GoogleProvider')
+
+/**
+ * Google Gemini provider
+ *
+ * Uses the @google/genai SDK with API key authentication.
+ * Shares core execution logic with Vertex AI provider.
+ */
+export const googleProvider: ProviderConfig = {
+  id: 'google',
+  name: 'Google',
+  description: "Google's Gemini models",
+  version: '1.0.0',
+  models: getProviderModels('google'),
+  defaultModel: getProviderDefaultModel('google'),
+
+  executeRequest: async (
+    request: ProviderRequest
+  ): Promise<ProviderResponse | StreamingExecution> => {
+    if (!request.apiKey) {
+      throw new Error('API key is required for Google Gemini')
+    }
+
+    logger.info('Creating Google Gemini client', { model: request.model })
+
+    const ai = new GoogleGenAI({ apiKey: request.apiKey })
+
+    return executeGeminiRequest({
+      ai,
+      model: request.model,
+      request,
+      providerType: 'google',
+    })
+  },
+}

apps/sim/providers/google/utils.test.ts

@@ -0,0 +1,549 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  convertToGeminiFormat,
+  ensureStructResponse,
+  mapToThinkingBudget,
+  supportsDisablingGemini25Thinking,
+} from '@/providers/google/utils'
+import type { ProviderRequest } from '@/providers/types'
+
+describe('mapToThinkingBudget', () => {
+  it('maps named levels to a within-range budget for gemini-2.5-pro (128-32768, cannot disable)', () => {
+    expect(mapToThinkingBudget('gemini-2.5-pro', 'low')).toBeGreaterThanOrEqual(128)
+    expect(mapToThinkingBudget('gemini-2.5-pro', 'high')).toBeLessThanOrEqual(32768)
+  })
+
+  it('maps named levels to a within-range budget for gemini-2.5-flash (0-24576)', () => {
+    expect(mapToThinkingBudget('gemini-2.5-flash', 'low')).toBeLessThanOrEqual(24576)
+    expect(mapToThinkingBudget('gemini-2.5-flash', 'high')).toBeLessThanOrEqual(24576)
+  })
+
+  it('maps named levels to a within-range budget for gemini-2.5-flash-lite (512-24576)', () => {
+    expect(mapToThinkingBudget('gemini-2.5-flash-lite', 'low')).toBeGreaterThanOrEqual(512)
+    expect(mapToThinkingBudget('gemini-2.5-flash-lite', 'high')).toBeLessThanOrEqual(24576)
+  })
+
+  it('strips the vertex/ prefix before looking up the model', () => {
+    expect(mapToThinkingBudget('vertex/gemini-2.5-flash', 'medium')).toBe(
+      mapToThinkingBudget('gemini-2.5-flash', 'medium')
+    )
+  })
+
+  it('falls back to dynamic budget (-1) for models with no explicit mapping', () => {
+    expect(mapToThinkingBudget('gemini-2.0-flash', 'medium')).toBe(-1)
+  })
+
+  it('falls back to the high budget for an unrecognized level on a mapped model', () => {
+    expect(mapToThinkingBudget('gemini-2.5-flash', 'unknown-level')).toBe(
+      mapToThinkingBudget('gemini-2.5-flash', 'high')
+    )
+  })
+})
+
+describe('supportsDisablingGemini25Thinking', () => {
+  it('returns true for gemini-2.5-flash and gemini-2.5-flash-lite', () => {
+    expect(supportsDisablingGemini25Thinking('gemini-2.5-flash')).toBe(true)
+    expect(supportsDisablingGemini25Thinking('gemini-2.5-flash-lite')).toBe(true)
+  })
+
+  it('returns false for gemini-2.5-pro, which cannot disable thinking', () => {
+    expect(supportsDisablingGemini25Thinking('gemini-2.5-pro')).toBe(false)
+  })
+
+  it('strips the vertex/ prefix before checking', () => {
+    expect(supportsDisablingGemini25Thinking('vertex/gemini-2.5-flash')).toBe(true)
+    expect(supportsDisablingGemini25Thinking('vertex/gemini-2.5-pro')).toBe(false)
+  })
+
+  it('returns false for models with no explicit mapping', () => {
+    expect(supportsDisablingGemini25Thinking('gemini-3.5-flash')).toBe(false)
+  })
+})
+
+describe('ensureStructResponse', () => {
+  describe('should return objects unchanged', () => {
+    it('should return plain object unchanged', () => {
+      const input = { key: 'value', nested: { a: 1 } }
+      const result = ensureStructResponse(input)
+      expect(result).toBe(input) // Same reference
+      expect(result).toEqual({ key: 'value', nested: { a: 1 } })
+    })
+
+    it('should return empty object unchanged', () => {
+      const input = {}
+      const result = ensureStructResponse(input)
+      expect(result).toBe(input)
+      expect(result).toEqual({})
+    })
+  })
+
+  describe('should wrap primitive values in { value: ... }', () => {
+    it('should wrap boolean true', () => {
+      const result = ensureStructResponse(true)
+      expect(result).toEqual({ value: true })
+      expect(typeof result).toBe('object')
+    })
+
+    it('should wrap boolean false', () => {
+      const result = ensureStructResponse(false)
+      expect(result).toEqual({ value: false })
+      expect(typeof result).toBe('object')
+    })
+
+    it('should wrap string', () => {
+      const result = ensureStructResponse('success')
+      expect(result).toEqual({ value: 'success' })
+      expect(typeof result).toBe('object')
+    })
+
+    it('should wrap empty string', () => {
+      const result = ensureStructResponse('')
+      expect(result).toEqual({ value: '' })
+      expect(typeof result).toBe('object')
+    })
+
+    it('should wrap number', () => {
+      const result = ensureStructResponse(42)
+      expect(result).toEqual({ value: 42 })
+      expect(typeof result).toBe('object')
+    })
+
+    it('should wrap zero', () => {
+      const result = ensureStructResponse(0)
+      expect(result).toEqual({ value: 0 })
+      expect(typeof result).toBe('object')
+    })
+
+    it('should wrap null', () => {
+      const result = ensureStructResponse(null)
+      expect(result).toEqual({ value: null })
+      expect(typeof result).toBe('object')
+    })
+
+    it('should wrap undefined', () => {
+      const result = ensureStructResponse(undefined)
+      expect(result).toEqual({ value: undefined })
+      expect(typeof result).toBe('object')
+    })
+  })
+
+  describe('should wrap arrays in { value: ... }', () => {
+    it('should wrap array of strings', () => {
+      const result = ensureStructResponse(['a', 'b', 'c'])
+      expect(result).toEqual({ value: ['a', 'b', 'c'] })
+      expect(typeof result).toBe('object')
+      expect(Array.isArray(result)).toBe(false)
+    })
+
+    it('should wrap array of objects', () => {
+      const result = ensureStructResponse([{ id: 1 }, { id: 2 }])
+      expect(result).toEqual({ value: [{ id: 1 }, { id: 2 }] })
+      expect(typeof result).toBe('object')
+      expect(Array.isArray(result)).toBe(false)
+    })
+
+    it('should wrap empty array', () => {
+      const result = ensureStructResponse([])
+      expect(result).toEqual({ value: [] })
+      expect(typeof result).toBe('object')
+      expect(Array.isArray(result)).toBe(false)
+    })
+  })
+
+  describe('edge cases', () => {
+    it('should handle nested objects correctly', () => {
+      const input = { a: { b: { c: 1 } }, d: [1, 2, 3] }
+      const result = ensureStructResponse(input)
+      expect(result).toBe(input) // Same reference, unchanged
+    })
+
+    it('should handle object with array property correctly', () => {
+      const input = { items: ['a', 'b'], count: 2 }
+      const result = ensureStructResponse(input)
+      expect(result).toBe(input) // Same reference, unchanged
+    })
+  })
+})
+
+describe('convertToGeminiFormat', () => {
+  it('should convert user message files to inline data parts', () => {
+    const request: ProviderRequest = {
+      model: 'gemini-2.5-flash',
+      messages: [
+        {
+          role: 'user',
+          content: 'Analyze this image',
+          files: [
+            {
+              id: 'file-1',
+              key: 'workspace/ws-1/example.png',
+              name: 'example.png',
+              url: '/api/files/serve/workspace%2Fws-1%2Fexample.png?context=workspace',
+              size: 128,
+              type: 'image/png',
+              base64: 'iVBORw0KGgo=',
+            },
+          ],
+        },
+      ],
+    }
+
+    const result = convertToGeminiFormat(request)
+
+    expect(result.contents[0]).toEqual({
+      role: 'user',
+      parts: [
+        { text: 'Analyze this image' },
+        {
+          inlineData: {
+            mimeType: 'image/png',
+            data: 'iVBORw0KGgo=',
+          },
+        },
+      ],
+    })
+  })
+
+  describe('tool message handling', () => {
+    it('should convert tool message with object response correctly', () => {
+      const request: ProviderRequest = {
+        model: 'gemini-2.5-flash',
+        messages: [
+          { role: 'user', content: 'Hello' },
+          {
+            role: 'assistant',
+            content: '',
+            tool_calls: [
+              {
+                id: 'call_123',
+                type: 'function',
+                function: { name: 'get_weather', arguments: '{"city": "London"}' },
+              },
+            ],
+          },
+          {
+            role: 'tool',
+            name: 'get_weather',
+            tool_call_id: 'call_123',
+            content: '{"temperature": 20, "condition": "sunny"}',
+          },
+        ],
+      }
+
+      const result = convertToGeminiFormat(request)
+
+      const toolResponseContent = result.contents.find(
+        (c) => c.parts?.[0] && 'functionResponse' in c.parts[0]
+      )
+      expect(toolResponseContent).toBeDefined()
+
+      const functionResponse = (toolResponseContent?.parts?.[0] as { functionResponse?: unknown })
+        ?.functionResponse as { response?: unknown }
+      expect(functionResponse?.response).toEqual({ temperature: 20, condition: 'sunny' })
+      expect(typeof functionResponse?.response).toBe('object')
+    })
+
+    it('should wrap boolean true response in an object for Gemini compatibility', () => {
+      const request: ProviderRequest = {
+        model: 'gemini-2.5-flash',
+        messages: [
+          { role: 'user', content: 'Check if user exists' },
+          {
+            role: 'assistant',
+            content: '',
+            tool_calls: [
+              {
+                id: 'call_456',
+                type: 'function',
+                function: { name: 'user_exists', arguments: '{"userId": "123"}' },
+              },
+            ],
+          },
+          {
+            role: 'tool',
+            name: 'user_exists',
+            tool_call_id: 'call_456',
+            content: 'true', // Boolean true as JSON string
+          },
+        ],
+      }
+
+      const result = convertToGeminiFormat(request)
+
+      const toolResponseContent = result.contents.find(
+        (c) => c.parts?.[0] && 'functionResponse' in c.parts[0]
+      )
+      expect(toolResponseContent).toBeDefined()
+
+      const functionResponse = (toolResponseContent?.parts?.[0] as { functionResponse?: unknown })
+        ?.functionResponse as { response?: unknown }
+
+      expect(typeof functionResponse?.response).toBe('object')
+      expect(functionResponse?.response).not.toBe(true)
+      expect(functionResponse?.response).toEqual({ value: true })
+    })
+
+    it('should wrap boolean false response in an object for Gemini compatibility', () => {
+      const request: ProviderRequest = {
+        model: 'gemini-2.5-flash',
+        messages: [
+          { role: 'user', content: 'Check if user exists' },
+          {
+            role: 'assistant',
+            content: '',
+            tool_calls: [
+              {
+                id: 'call_789',
+                type: 'function',
+                function: { name: 'user_exists', arguments: '{"userId": "999"}' },
+              },
+            ],
+          },
+          {
+            role: 'tool',
+            name: 'user_exists',
+            tool_call_id: 'call_789',
+            content: 'false', // Boolean false as JSON string
+          },
+        ],
+      }
+
+      const result = convertToGeminiFormat(request)
+
+      const toolResponseContent = result.contents.find(
+        (c) => c.parts?.[0] && 'functionResponse' in c.parts[0]
+      )
+      const functionResponse = (toolResponseContent?.parts?.[0] as { functionResponse?: unknown })
+        ?.functionResponse as { response?: unknown }
+
+      expect(typeof functionResponse?.response).toBe('object')
+      expect(functionResponse?.response).toEqual({ value: false })
+    })
+
+    it('should wrap string response in an object for Gemini compatibility', () => {
+      const request: ProviderRequest = {
+        model: 'gemini-2.5-flash',
+        messages: [
+          { role: 'user', content: 'Get status' },
+          {
+            role: 'assistant',
+            content: '',
+            tool_calls: [
+              {
+                id: 'call_str',
+                type: 'function',
+                function: { name: 'get_status', arguments: '{}' },
+              },
+            ],
+          },
+          {
+            role: 'tool',
+            name: 'get_status',
+            tool_call_id: 'call_str',
+            content: '"success"', // String as JSON
+          },
+        ],
+      }
+
+      const result = convertToGeminiFormat(request)
+
+      const toolResponseContent = result.contents.find(
+        (c) => c.parts?.[0] && 'functionResponse' in c.parts[0]
+      )
+      const functionResponse = (toolResponseContent?.parts?.[0] as { functionResponse?: unknown })
+        ?.functionResponse as { response?: unknown }
+
+      expect(typeof functionResponse?.response).toBe('object')
+      expect(functionResponse?.response).toEqual({ value: 'success' })
+    })
+
+    it('should wrap number response in an object for Gemini compatibility', () => {
+      const request: ProviderRequest = {
+        model: 'gemini-2.5-flash',
+        messages: [
+          { role: 'user', content: 'Get count' },
+          {
+            role: 'assistant',
+            content: '',
+            tool_calls: [
+              {
+                id: 'call_num',
+                type: 'function',
+                function: { name: 'get_count', arguments: '{}' },
+              },
+            ],
+          },
+          {
+            role: 'tool',
+            name: 'get_count',
+            tool_call_id: 'call_num',
+            content: '42', // Number as JSON
+          },
+        ],
+      }
+
+      const result = convertToGeminiFormat(request)
+
+      const toolResponseContent = result.contents.find(
+        (c) => c.parts?.[0] && 'functionResponse' in c.parts[0]
+      )
+      const functionResponse = (toolResponseContent?.parts?.[0] as { functionResponse?: unknown })
+        ?.functionResponse as { response?: unknown }
+
+      expect(typeof functionResponse?.response).toBe('object')
+      expect(functionResponse?.response).toEqual({ value: 42 })
+    })
+
+    it('should wrap null response in an object for Gemini compatibility', () => {
+      const request: ProviderRequest = {
+        model: 'gemini-2.5-flash',
+        messages: [
+          { role: 'user', content: 'Get data' },
+          {
+            role: 'assistant',
+            content: '',
+            tool_calls: [
+              {
+                id: 'call_null',
+                type: 'function',
+                function: { name: 'get_data', arguments: '{}' },
+              },
+            ],
+          },
+          {
+            role: 'tool',
+            name: 'get_data',
+            tool_call_id: 'call_null',
+            content: 'null', // null as JSON
+          },
+        ],
+      }
+
+      const result = convertToGeminiFormat(request)
+
+      const toolResponseContent = result.contents.find(
+        (c) => c.parts?.[0] && 'functionResponse' in c.parts[0]
+      )
+      const functionResponse = (toolResponseContent?.parts?.[0] as { functionResponse?: unknown })
+        ?.functionResponse as { response?: unknown }
+
+      expect(typeof functionResponse?.response).toBe('object')
+      expect(functionResponse?.response).toEqual({ value: null })
+    })
+
+    it('should keep array response as-is since arrays are valid Struct values', () => {
+      const request: ProviderRequest = {
+        model: 'gemini-2.5-flash',
+        messages: [
+          { role: 'user', content: 'Get items' },
+          {
+            role: 'assistant',
+            content: '',
+            tool_calls: [
+              {
+                id: 'call_arr',
+                type: 'function',
+                function: { name: 'get_items', arguments: '{}' },
+              },
+            ],
+          },
+          {
+            role: 'tool',
+            name: 'get_items',
+            tool_call_id: 'call_arr',
+            content: '["item1", "item2"]', // Array as JSON
+          },
+        ],
+      }
+
+      const result = convertToGeminiFormat(request)
+
+      const toolResponseContent = result.contents.find(
+        (c) => c.parts?.[0] && 'functionResponse' in c.parts[0]
+      )
+      const functionResponse = (toolResponseContent?.parts?.[0] as { functionResponse?: unknown })
+        ?.functionResponse as { response?: unknown }
+
+      expect(typeof functionResponse?.response).toBe('object')
+      expect(functionResponse?.response).toEqual({ value: ['item1', 'item2'] })
+    })
+
+    it('should handle invalid JSON by wrapping in output object', () => {
+      const request: ProviderRequest = {
+        model: 'gemini-2.5-flash',
+        messages: [
+          { role: 'user', content: 'Get data' },
+          {
+            role: 'assistant',
+            content: '',
+            tool_calls: [
+              {
+                id: 'call_invalid',
+                type: 'function',
+                function: { name: 'get_data', arguments: '{}' },
+              },
+            ],
+          },
+          {
+            role: 'tool',
+            name: 'get_data',
+            tool_call_id: 'call_invalid',
+            content: 'not valid json {',
+          },
+        ],
+      }
+
+      const result = convertToGeminiFormat(request)
+
+      const toolResponseContent = result.contents.find(
+        (c) => c.parts?.[0] && 'functionResponse' in c.parts[0]
+      )
+      const functionResponse = (toolResponseContent?.parts?.[0] as { functionResponse?: unknown })
+        ?.functionResponse as { response?: unknown }
+
+      expect(typeof functionResponse?.response).toBe('object')
+      expect(functionResponse?.response).toEqual({ output: 'not valid json {' })
+    })
+
+    it('should handle empty content by wrapping in output object', () => {
+      const request: ProviderRequest = {
+        model: 'gemini-2.5-flash',
+        messages: [
+          { role: 'user', content: 'Do something' },
+          {
+            role: 'assistant',
+            content: '',
+            tool_calls: [
+              {
+                id: 'call_empty',
+                type: 'function',
+                function: { name: 'do_action', arguments: '{}' },
+              },
+            ],
+          },
+          {
+            role: 'tool',
+            name: 'do_action',
+            tool_call_id: 'call_empty',
+            content: '', // Empty content - falls back to default '{}'
+          },
+        ],
+      }
+
+      const result = convertToGeminiFormat(request)
+
+      const toolResponseContent = result.contents.find(
+        (c) => c.parts?.[0] && 'functionResponse' in c.parts[0]
+      )
+      const functionResponse = (toolResponseContent?.parts?.[0] as { functionResponse?: unknown })
+        ?.functionResponse as { response?: unknown }
+
+      expect(typeof functionResponse?.response).toBe('object')
+      // Empty string is not valid JSON, so it falls back to { output: "" }
+      expect(functionResponse?.response).toEqual({ output: '' })
+    })
+  })
+})

apps/sim/providers/google/utils.ts

@@ -0,0 +1,444 @@
+import {
+  type Candidate,
+  type Content,
+  type FunctionCall,
+  FunctionCallingConfigMode,
+  type GenerateContentResponse,
+  type GenerateContentResponseUsageMetadata,
+  type Part,
+  type Schema,
+  type SchemaUnion,
+  ThinkingLevel,
+  type ToolConfig,
+  Type,
+} from '@google/genai'
+import { createLogger } from '@sim/logger'
+import { toError } from '@sim/utils/errors'
+import { isRecordLike } from '@sim/utils/object'
+import { buildGeminiMessageParts } from '@/providers/attachments'
+import type { ProviderRequest } from '@/providers/types'
+import { trackForcedToolUsage } from '@/providers/utils'
+
+const logger = createLogger('GoogleUtils')
+
+/**
+ * Ensures a value is a valid object for Gemini's functionResponse.response field.
+ * Gemini's API requires functionResponse.response to be a google.protobuf.Struct,
+ * which must be an object with string keys. Primitive values (boolean, string,
+ * number, null) and arrays are wrapped in { value: ... }.
+ *
+ * @param value - The value to ensure is a Struct-compatible object
+ * @returns A Record<string, unknown> suitable for functionResponse.response
+ */
+export function ensureStructResponse(value: unknown): Record<string, unknown> {
+  if (isRecordLike(value)) {
+    return value
+  }
+  return { value }
+}
+
+/**
+ * Usage metadata for Google Gemini responses
+ */
+export interface GeminiUsage {
+  promptTokenCount: number
+  candidatesTokenCount: number
+  totalTokenCount: number
+}
+
+/**
+ * Parsed function call from Gemini response
+ */
+interface ParsedFunctionCall {
+  name: string
+  args: Record<string, unknown>
+}
+
+/**
+ * Removes additionalProperties from a schema object (not supported by Gemini)
+ */
+export function cleanSchemaForGemini(schema: SchemaUnion): SchemaUnion {
+  if (schema === null || schema === undefined) return schema
+  if (typeof schema !== 'object') return schema
+  if (Array.isArray(schema)) {
+    return schema.map((item) => cleanSchemaForGemini(item))
+  }
+
+  const cleanedSchema: Record<string, unknown> = {}
+  const schemaObj = schema as Record<string, unknown>
+
+  for (const key in schemaObj) {
+    if (key === 'additionalProperties') continue
+    cleanedSchema[key] = cleanSchemaForGemini(schemaObj[key] as SchemaUnion)
+  }
+
+  return cleanedSchema
+}
+
+/**
+ * Extracts text content from a Gemini response candidate.
+ * Filters out thought parts (model reasoning) from the output.
+ */
+export function extractTextContent(candidate: Candidate | undefined): string {
+  if (!candidate?.content?.parts) return ''
+
+  const textParts = candidate.content.parts.filter(
+    (part): part is Part & { text: string } => Boolean(part.text) && part.thought !== true
+  )
+
+  if (textParts.length === 0) return ''
+  if (textParts.length === 1) return textParts[0].text
+
+  return textParts.map((part) => part.text).join('\n')
+}
+
+/**
+ * Extracts the first function call from a Gemini response candidate
+ */
+export function extractFunctionCall(candidate: Candidate | undefined): ParsedFunctionCall | null {
+  if (!candidate?.content?.parts) return null
+
+  for (const part of candidate.content.parts) {
+    if (part.functionCall) {
+      return {
+        name: part.functionCall.name ?? '',
+        args: (part.functionCall.args ?? {}) as Record<string, unknown>,
+      }
+    }
+  }
+
+  return null
+}
+
+/**
+ * Extracts the full Part containing the function call (preserves thoughtSignature)
+ * @deprecated Use extractAllFunctionCallParts for proper multi-tool handling
+ */
+export function extractFunctionCallPart(candidate: Candidate | undefined): Part | null {
+  if (!candidate?.content?.parts) return null
+
+  for (const part of candidate.content.parts) {
+    if (part.functionCall) {
+      return part
+    }
+  }
+
+  return null
+}
+
+/**
+ * Extracts ALL Parts containing function calls from a candidate.
+ * Gemini can return multiple function calls in a single response,
+ * and all should be executed before continuing the conversation.
+ */
+export function extractAllFunctionCallParts(candidate: Candidate | undefined): Part[] {
+  if (!candidate?.content?.parts) return []
+
+  return candidate.content.parts.filter((part) => part.functionCall)
+}
+
+/**
+ * Converts usage metadata from SDK response to our format.
+ * Per Gemini docs, total = promptTokenCount + candidatesTokenCount + toolUsePromptTokenCount + thoughtsTokenCount
+ * We include toolUsePromptTokenCount in input and thoughtsTokenCount in output for correct billing.
+ */
+export function convertUsageMetadata(
+  usageMetadata: GenerateContentResponseUsageMetadata | undefined
+): GeminiUsage {
+  const thoughtsTokenCount = usageMetadata?.thoughtsTokenCount ?? 0
+  const toolUsePromptTokenCount = usageMetadata?.toolUsePromptTokenCount ?? 0
+  const promptTokenCount = (usageMetadata?.promptTokenCount ?? 0) + toolUsePromptTokenCount
+  const candidatesTokenCount = (usageMetadata?.candidatesTokenCount ?? 0) + thoughtsTokenCount
+  return {
+    promptTokenCount,
+    candidatesTokenCount,
+    totalTokenCount: usageMetadata?.totalTokenCount ?? 0,
+  }
+}
+
+/**
+ * Tool definition for Gemini format
+ */
+export interface GeminiToolDef {
+  name: string
+  description: string
+  parameters: Schema
+}
+
+/**
+ * Converts OpenAI-style request format to Gemini format
+ */
+export function convertToGeminiFormat(
+  request: ProviderRequest,
+  providerId = 'google'
+): {
+  contents: Content[]
+  tools: GeminiToolDef[] | undefined
+  systemInstruction: Content | undefined
+} {
+  const contents: Content[] = []
+  let systemInstruction: Content | undefined
+
+  if (request.systemPrompt) {
+    systemInstruction = { parts: [{ text: request.systemPrompt }] }
+  }
+
+  if (request.context) {
+    contents.push({ role: 'user', parts: [{ text: request.context }] })
+  }
+
+  if (request.messages?.length) {
+    for (const message of request.messages) {
+      if (message.role === 'system') {
+        if (!systemInstruction) {
+          systemInstruction = { parts: [{ text: message.content ?? '' }] }
+        } else if (systemInstruction.parts?.[0] && 'text' in systemInstruction.parts[0]) {
+          systemInstruction.parts[0].text = `${systemInstruction.parts[0].text}\n${message.content}`
+        }
+      } else if (message.role === 'user' || message.role === 'assistant') {
+        const geminiRole = message.role === 'user' ? 'user' : 'model'
+        const parts = buildGeminiMessageParts(message.content, message.files, providerId) as Part[]
+
+        if (parts.length > 0) {
+          contents.push({ role: geminiRole, parts })
+        }
+
+        if (message.role === 'assistant' && message.tool_calls?.length) {
+          const functionCalls = message.tool_calls.map((toolCall) => ({
+            functionCall: {
+              name: toolCall.function?.name,
+              args: JSON.parse(toolCall.function?.arguments || '{}') as Record<string, unknown>,
+            },
+          }))
+          contents.push({ role: 'model', parts: functionCalls })
+        }
+      } else if (message.role === 'tool') {
+        if (!message.name) {
+          logger.warn('Tool message missing function name, skipping')
+          continue
+        }
+        let responseData: Record<string, unknown>
+        try {
+          const parsed = JSON.parse(message.content ?? '{}')
+          responseData = ensureStructResponse(parsed)
+        } catch {
+          responseData = { output: message.content }
+        }
+        contents.push({
+          role: 'user',
+          parts: [
+            {
+              functionResponse: {
+                id: message.tool_call_id,
+                name: message.name,
+                response: responseData,
+              },
+            },
+          ],
+        })
+      }
+    }
+  }
+
+  const tools = request.tools?.map((tool): GeminiToolDef => {
+    const toolParameters = { ...(tool.parameters || {}) }
+
+    if (toolParameters.properties) {
+      const properties = { ...toolParameters.properties }
+      const required = toolParameters.required ? [...toolParameters.required] : []
+
+      // Remove default values from properties (not supported by Gemini)
+      for (const key in properties) {
+        const prop = properties[key] as Record<string, unknown>
+        if (prop.default !== undefined) {
+          const { default: _, ...cleanProp } = prop
+          properties[key] = cleanProp
+        }
+      }
+
+      const parameters: Schema = {
+        type: (toolParameters.type as Schema['type']) || Type.OBJECT,
+        properties: properties as Record<string, Schema>,
+        ...(required.length > 0 ? { required } : {}),
+      }
+
+      return {
+        name: tool.id,
+        description: tool.description || `Execute the ${tool.id} function`,
+        parameters: cleanSchemaForGemini(parameters) as Schema,
+      }
+    }
+
+    return {
+      name: tool.id,
+      description: tool.description || `Execute the ${tool.id} function`,
+      parameters: cleanSchemaForGemini(toolParameters) as Schema,
+    }
+  })
+
+  return { contents, tools, systemInstruction }
+}
+
+/**
+ * Creates a ReadableStream from a Google Gemini streaming response
+ */
+export function createReadableStreamFromGeminiStream(
+  stream: AsyncGenerator<GenerateContentResponse>,
+  onComplete?: (content: string, usage: GeminiUsage) => void
+): ReadableStream<Uint8Array> {
+  let fullContent = ''
+  let usage: GeminiUsage = { promptTokenCount: 0, candidatesTokenCount: 0, totalTokenCount: 0 }
+
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const chunk of stream) {
+          if (chunk.usageMetadata) {
+            usage = convertUsageMetadata(chunk.usageMetadata)
+          }
+
+          const text = chunk.text
+          if (text) {
+            fullContent += text
+            controller.enqueue(new TextEncoder().encode(text))
+          }
+        }
+
+        onComplete?.(fullContent, usage)
+        controller.close()
+      } catch (error) {
+        logger.error('Error reading Google Gemini stream', {
+          error: toError(error).message,
+        })
+        controller.error(error)
+      }
+    },
+  })
+}
+
+/**
+ * Maps string mode to FunctionCallingConfigMode enum
+ */
+function mapToFunctionCallingMode(mode: string): FunctionCallingConfigMode {
+  switch (mode) {
+    case 'AUTO':
+      return FunctionCallingConfigMode.AUTO
+    case 'ANY':
+      return FunctionCallingConfigMode.ANY
+    case 'NONE':
+      return FunctionCallingConfigMode.NONE
+    default:
+      return FunctionCallingConfigMode.AUTO
+  }
+}
+
+/**
+ * Maps string level to ThinkingLevel enum
+ */
+export function mapToThinkingLevel(level: string): ThinkingLevel {
+  switch (level.toLowerCase()) {
+    case 'minimal':
+      return ThinkingLevel.MINIMAL
+    case 'low':
+      return ThinkingLevel.LOW
+    case 'medium':
+      return ThinkingLevel.MEDIUM
+    case 'high':
+      return ThinkingLevel.HIGH
+    default:
+      return ThinkingLevel.HIGH
+  }
+}
+
+/**
+ * Per-model thinkingBudget ranges for Gemini 2.5-series models. Unlike Gemini 3.x, these
+ * models reject `thinkingLevel` entirely (Gemini API docs: "Gemini 2.5 series models don't
+ * support thinkingLevel; use thinkingBudget instead") and require a numeric token budget
+ * within each model's own documented range.
+ */
+const GEMINI_25_THINKING_BUDGETS: Record<string, Record<string, number>> = {
+  'gemini-2.5-pro': { low: 2048, medium: 8192, high: 32768 }, // valid range 128-32768, cannot disable
+  'gemini-2.5-flash': { low: 2048, medium: 8192, high: 24576 }, // valid range 0-24576
+  'gemini-2.5-flash-lite': { low: 1024, medium: 8192, high: 24576 }, // valid range 512-24576
+}
+
+/**
+ * Maps a named thinking level to a `thinkingBudget` token count for Gemini 2.5-series models.
+ * Falls back to -1 (dynamic/automatic budget) for any model not in the explicit table above,
+ * rather than guessing a number that could fall outside an unmapped model's valid range.
+ */
+export function mapToThinkingBudget(model: string, level: string): number {
+  const normalized = model.toLowerCase().replace(/^vertex\//, '')
+  const budgets = GEMINI_25_THINKING_BUDGETS[normalized]
+  if (!budgets) return -1
+  return budgets[level.toLowerCase()] ?? budgets.high
+}
+
+/**
+ * Gemini 2.5-series models that accept `thinkingBudget: 0` to explicitly disable thinking.
+ * gemini-2.5-pro cannot disable thinking at all (its documented budget floor is 128, not 0),
+ * so it's deliberately excluded here.
+ */
+const GEMINI_25_MODELS_SUPPORTING_DISABLE = new Set(['gemini-2.5-flash', 'gemini-2.5-flash-lite'])
+
+/**
+ * Whether this Gemini 2.5-series model supports explicitly disabling thinking via budget=0.
+ * Omitting thinkingConfig entirely (the 'none' no-op path) falls back to the API's own
+ * dynamic default, which is ON for gemini-2.5-flash — not the same as actually disabling it.
+ */
+export function supportsDisablingGemini25Thinking(model: string): boolean {
+  const normalized = model.toLowerCase().replace(/^vertex\//, '')
+  return GEMINI_25_MODELS_SUPPORTING_DISABLE.has(normalized)
+}
+
+/**
+ * Result of checking forced tool usage
+ */
+export interface ForcedToolResult {
+  hasUsedForcedTool: boolean
+  usedForcedTools: string[]
+  nextToolConfig: ToolConfig | undefined
+}
+
+/**
+ * Checks for forced tool usage in Google Gemini responses
+ */
+export function checkForForcedToolUsage(
+  functionCalls: FunctionCall[] | undefined,
+  toolConfig: ToolConfig | undefined,
+  forcedTools: string[],
+  usedForcedTools: string[]
+): ForcedToolResult | null {
+  if (!functionCalls?.length) return null
+
+  const adaptedToolCalls = functionCalls.map((fc) => ({
+    name: fc.name ?? '',
+    arguments: (fc.args ?? {}) as Record<string, unknown>,
+  }))
+
+  const result = trackForcedToolUsage(
+    adaptedToolCalls,
+    toolConfig,
+    logger,
+    'google',
+    forcedTools,
+    usedForcedTools
+  )
+
+  if (!result) return null
+
+  const nextToolConfig: ToolConfig | undefined = result.nextToolConfig?.functionCallingConfig?.mode
+    ? {
+        functionCallingConfig: {
+          mode: mapToFunctionCallingMode(result.nextToolConfig.functionCallingConfig.mode),
+          allowedFunctionNames: result.nextToolConfig.functionCallingConfig.allowedFunctionNames,
+        },
+      }
+    : undefined
+
+  return {
+    hasUsedForcedTool: result.hasUsedForcedTool,
+    usedForcedTools: result.usedForcedTools,
+    nextToolConfig,
+  }
+}