Function callEmbeddingAPI

apps/sim/lib/knowledge/embeddings.ts:259–311

(
  inputs: string[],
  provider: ResolvedProvider,
  inputType: EmbeddingInputType
)

}

async function callEmbeddingAPI(
  inputs: string[],
  provider: ResolvedProvider,
  inputType: EmbeddingInputType
): Promise<{ embeddings: number[][]; totalTokens: number }> {
  return retryWithExponentialBackoff(
    async () => {
      const request = provider.buildRequest(inputs, inputType)

      const controller = new AbortController()
      const timeout = setTimeout(() => controller.abort(), EMBEDDING_REQUEST_TIMEOUT_MS)

      const response = await fetch(request.apiUrl, {
        method: 'POST',
        headers: request.headers,
        body: JSON.stringify(request.body),
        signal: controller.signal,
      }).finally(() => clearTimeout(timeout))

      if (!response.ok) {
        const errorText = await response.text()
        throw new EmbeddingAPIError(
          `Embedding API failed: ${response.status} ${response.statusText} - ${errorText}`,
          response.status
        )
      }

      const json = await response.json()
      const embeddings = request.parse(json)
      const usage = (json as { usage?: { total_tokens?: number } }).usage
      const totalTokens =
        usage?.total_tokens ??
        // Gemini does not return usage.total_tokens — estimate with the provider's tokenizer
        inputs.reduce(
          (sum, text) => sum + estimateTokenCount(text, provider.tokenizerProvider).count,
          0
        )

      return { embeddings, totalTokens }
    },
    {
      maxRetries: 3,
      initialDelayMs: 1000,
      maxDelayMs: 10000,
      retryCondition: (error: unknown) => {
        if (error instanceof EmbeddingAPIError) {
          return error.status === 429 || error.status >= 500
        }
        return isRetryableError(error)
      },
    }
  )
}

function splitByItemLimit<T>(items: T[], limit: number): T[][] {
  if (items.length <= limit) return [items]